import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void shouldReturnPresentInstance_whenWordsAreNotEmpty() {
    // given
    List<String> wordsByLetterK = Lists.newArrayList("ka", "kb");
    wordsByLetter.put("k", wordsByLetterK);
    baseIndexes.put("k", 0);
    List<String> wordsByLetterO = Lists.newArrayList("on", "oz");
    wordsByLetter.put("o", wordsByLetterO);
    baseIndexes.put("o", 1);

    Words words = new Words(wordsByLetter, baseIndexes);

    // when
    Optional<WordsResult> result = testObj.find(words);


    // then
    assertThat(result.isPresent()).isTrue();
    WordsResult wordResult = result.get();
    assertThat(wordResult.getList()).isEqualTo(wordsByLetterK);
    assertThat(wordResult.getIndex()).isEqualTo(0);
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void shouldReturnFirstIndex_whenBaseIndexesIsNotEmpty() {
    // given
    List<String> wordsByLetterK = Lists.newArrayList("ka", "kb");
    wordsByLetter.put("k", wordsByLetterK);
    baseIndexes.put("k", 0);
    List<String> wordsByLetterO = Lists.newArrayList("on", "oz");
    wordsByLetter.put("o", wordsByLetterO);
    baseIndexes.put("o", 1);

    testObj = new Words(wordsByLetter, baseIndexes);

    // when
    Optional<String> result = testObj.getFirstIndex();

    // than
    assertEquals(result.get(), "k");
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void shouldInitSounds() {
    // given
    SlideBean slide = mock(SlideBean.class);
    SoundBean soundBean = mock(SoundBean.class);
    List<SlideBean> slides = Lists.newArrayList();
    slides.add(slide);

    String audiopath = "test.mp3";
    when(slide.getSound()).thenReturn(soundBean);
    when(slide.hasSound()).thenReturn(true);
    when(soundBean.getSrc()).thenReturn(audiopath);

    // when
    testObj.init(slides, inlineBodyGeneratorSocket);

    // then
    verify(slideshowSoundController).initSound(audiopath);
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void shouldResetSlide_whenCantSwitchToNextSlide() {
    // given
    List<SlideBean> slides = Lists.newArrayList();
    testObj.init(slides, inlineBodyGeneratorSocket);
    verify(slidesSwitcher).setSlideEnd(slideEndCaptor.capture());
    SlideEndHandler value = slideEndCaptor.getValue();

    when(slidesSwitcher.canSwitchToNextSlide()).thenReturn(false);

    // when
    value.onEnd();

    // then
    verify(slidesSwitcher, times(2)).reset();
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void shouldContinuePlayingSlideshow_whenCanSwitchToNextSlide() {
    // given
    List<SlideBean> slides = Lists.newArrayList();
    testObj.init(slides, inlineBodyGeneratorSocket);
    verify(slidesSwitcher).setSlideEnd(slideEndCaptor.capture());
    SlideEndHandler value = slideEndCaptor.getValue();

    when(slidesSwitcher.canSwitchToNextSlide()).thenReturn(true);

    // when
    value.onEnd();

    // then
    verify(slidesSwitcher).showNextSlide();
    verify(slidesSwitcher).stopAndPlaySlide();
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void shouldStopSlideshow_whenCanNotSwitchToNextSlide() {
    // given
    List<SlideBean> slides = Lists.newArrayList();
    testObj.init(slides, inlineBodyGeneratorSocket);
    verify(slidesSwitcher).setSlideEnd(slideEndCaptor.capture());
    SlideEndHandler value = slideEndCaptor.getValue();

    when(slidesSwitcher.canSwitchToNextSlide()).thenReturn(false);

    // when
    value.onEnd();

    // then
    verify(slidesSwitcher, times(2)).reset();
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void shouldRestoreView() {
    // given
    String firstId = "firstId";
    String secondId = "secondId";
    when(firstPresenter.getIdentifier()).thenReturn(firstId);
    when(secondPresenter.getIdentifier()).thenReturn(secondId);

    List<String> selectedChoices = Lists.newArrayList();
    selectedChoices.add(firstId);

    // when
    testObj.restoreView(selectedChoices);

    // then
    verify(firstPresenter).setSelected(true);
    verify(secondPresenter).setSelected(false);
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void testFindAnswersObjectsOfGivenType_findCorrectAnswers() {
    TestIdentifiableObject correctObject = createObject("correct");
    TestIdentifiableObject notCorrectObject = createObject("notCorrect");

    List<TestIdentifiableObject> identifiableObjects = Lists.newArrayList(correctObject, notCorrectObject);

    when(responseModel.isCorrectAnswer("correct")).thenReturn(true);

    when(responseModel.isCorrectAnswer("notCorrect")).thenReturn(false);

    // then
    List<TestIdentifiableObject> resultObjects = answersByTypeFinder.findAnswersObjectsOfGivenType(MarkAnswersType.CORRECT, identifiableObjects,
            responseModel);

    assertEquals(1, resultObjects.size());
    assertEquals(correctObject, resultObjects.get(0));
    verify(responseModel).isCorrectAnswer("correct");
    verify(responseModel).isCorrectAnswer("notCorrect");
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void testFindAnswersObjectsOfGivenType_findWrongAnswers() {
    TestIdentifiableObject correctObject = createObject("correct");
    TestIdentifiableObject notCorrectObject = createObject("notCorrect");

    List<TestIdentifiableObject> identifiableObjects = Lists.newArrayList(correctObject, notCorrectObject);

    when(responseModel.isCorrectAnswer("correct")).thenReturn(true);

    when(responseModel.isCorrectAnswer("notCorrect")).thenReturn(false);

    // then
    List<TestIdentifiableObject> resultObjects = answersByTypeFinder.findAnswersObjectsOfGivenType(MarkAnswersType.WRONG, identifiableObjects,
            responseModel);

    assertEquals(1, resultObjects.size());
    assertEquals(notCorrectObject, resultObjects.get(0));
    verify(responseModel).isCorrectAnswer("correct");
    verify(responseModel).isCorrectAnswer("notCorrect");
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void testFillFirstColumnWithItems() {
    SelectionItemBean itemBean = new SelectionItemBean();
    XMLContent xmlContent = mock(XMLContent.class);

    itemBean.setXmlContent(xmlContent);
    List<SelectionItemBean> items = Lists.newArrayList(itemBean);

    SelectionGridElementPosition updatedElementPositon = new SelectionGridElementPosition(0, 0);
    when(positionGenerator.getItemLabelElementPosition(0)).thenReturn(updatedElementPositon);

    // then
    viewBuilder.fillFirstColumnWithItems(items);

    SelectionGridElementPosition position = new SelectionGridElementPosition(0, items.indexOf(itemBean));
    verify(selectionModuleView).setItemDisplayedName(itemBean.getXmlContent(), position);
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void testFillFirstRowWithChoices() {
    SelectionSimpleChoiceBean choiceBean = new SelectionSimpleChoiceBean();
    XMLContent xmlContent = mock(XMLContent.class);

    choiceBean.setXmlContent(xmlContent);
    List<SelectionSimpleChoiceBean> simpleChoices = Lists.newArrayList(choiceBean);
    ;

    SelectionGridElementPosition updatedElementPositon = new SelectionGridElementPosition(0, 0);
    when(positionGenerator.getChoiceLabelElementPosition(0)).thenReturn(updatedElementPositon);

    // then
    viewBuilder.fillFirstRowWithChoices(simpleChoices);

    SelectionGridElementPosition position = new SelectionGridElementPosition(simpleChoices.indexOf(choiceBean), 0);
    verify(selectionModuleView).setChoiceOptionDisplayedName(choiceBean.getXmlContent(), position);
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void testGetSelectedAnswers() throws Exception {
    // given
    SelectionAnswerDto selectedAnswer1 = new SelectionAnswerDto();
    List<SelectionAnswerDto> selectedAnswers1 = Lists.newArrayList(selectedAnswer1);

    SelectionAnswerDto selectedAnswer2 = new SelectionAnswerDto();
    List<SelectionAnswerDto> selectedAnswers2 = Lists.newArrayList(selectedAnswer2);

    // when
    when(groupController1.getSelectedAnswers()).thenReturn(selectedAnswers1);

    when(groupController2.getSelectedAnswers()).thenReturn(selectedAnswers2);

    List<SelectionAnswerDto> allSelectedAnswers = groupAnswersControllerModel.getSelectedAnswers();

    // then
    assertEquals(2, allSelectedAnswers.size());
    assertEquals(selectedAnswer1, allSelectedAnswers.get(0));
    assertEquals(selectedAnswer2, allSelectedAnswers.get(1));
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void testGetNotSelectedAnswers() throws Exception {
    // given
    SelectionAnswerDto notSelectedAnswer1 = new SelectionAnswerDto();
    List<SelectionAnswerDto> notSelectedAnswers1 = Lists.newArrayList(notSelectedAnswer1);

    SelectionAnswerDto notSelectedAnswer2 = new SelectionAnswerDto();
    List<SelectionAnswerDto> notSelectedAnswers2 = Lists.newArrayList(notSelectedAnswer2);

    // when
    when(groupController1.getNotSelectedAnswers()).thenReturn(notSelectedAnswers1);

    when(groupController2.getNotSelectedAnswers()).thenReturn(notSelectedAnswers2);

    List<SelectionAnswerDto> notSelectedAnswers = groupAnswersControllerModel.getNotSelectedAnswers();

    // then
    assertEquals(2, notSelectedAnswers.size());
    assertEquals(notSelectedAnswer1, notSelectedAnswers.get(0));
    assertEquals(notSelectedAnswer2, notSelectedAnswers.get(1));
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void testGetButtonsToMarkForType() throws Exception {
    // given
    SelectionAnswerDto selectedAnswer1 = new SelectionAnswerDto();
    List<SelectionAnswerDto> selectedAnswers1 = Lists.newArrayList(selectedAnswer1);

    MarkAnswersType type = MarkAnswersType.CORRECT;

    // when
    when(groupController1.getSelectedAnswers()).thenReturn(selectedAnswers1);

    groupAnswersControllerModel.getButtonsToMarkForType(type);

    // then
    verify(identifiableAnswersByTypeFinder).findAnswersObjectsOfGivenType(type, groupAnswersControllerModel.getSelectedAnswers(), model);
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void testReset() {
    // given
    GroupAnswersController groupController1 = mock(GroupAnswersController.class);
    GroupAnswersController groupController2 = mock(GroupAnswersController.class);

    List<GroupAnswersController> groupControllers = Lists.newArrayList(groupController1, groupController2);

    // when
    when(answersControllerModel.getGroupChoicesControllers()).thenReturn(groupControllers);

    // then
    presenter.reset();

    verify(groupController1).reset();
    verify(groupController2).reset();

    Mockito.verifyNoMoreInteractions(groupController1, groupController2);
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void shouldBuildView() throws Exception {
    // given
    SimpleOrderChoiceBean choiceBean = getChoiceBean("a");
    SimpleOrderChoiceBean secondChoiceBean = getChoiceBean("b");
    List<SimpleOrderChoiceBean> choiceBeans = Lists.newArrayList(choiceBean, secondChoiceBean);
    bean.setChoiceBeans(choiceBeans);

    // when
    orderingViewBuilder.buildView(bean, bodyGeneratorSocket);

    // then
    verifyThatItemWasAddedToDaoWithCorrectValues(choiceBean, "0");
    verifyThatItemWasAddedToDaoWithCorrectValues(secondChoiceBean, "1");
    verify(orderingItemsDao).createInitialItemsOrder();
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void shouldShowCorrectAnswers() throws Exception {
    // given
    ShowAnswersType mode = ShowAnswersType.CORRECT;

    List<String> correctAnswers = Lists.newArrayList("correctAnswers");
    when(model.getCorrectAnswers()).thenReturn(correctAnswers);

    List<String> newAnswersOrder = Lists.newArrayList("newAnswersOrder");
    when(itemsResponseOrderController.getCorrectItemsOrderByAnswers(correctAnswers)).thenReturn(newAnswersOrder);

    // when
    List<String> result = controller.findNewAnswersOrderToShow(mode);

    // then
    assertEquals(newAnswersOrder, result);
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void shouldShowAnswersSpecyfiedByCurrentAnswers() throws Exception {
    // given
    ShowAnswersType mode = ShowAnswersType.USER;

    List<String> currentAnswers = Lists.newArrayList("correctAnswers");
    when(model.getCurrentAnswers()).thenReturn(currentAnswers);

    List<String> newAnswersOrder = Lists.newArrayList("newAnswersOrder");
    when(itemsResponseOrderController.getCorrectItemsOrderByAnswers(currentAnswers)).thenReturn(newAnswersOrder);

    // when
    List<String> result = controller.findNewAnswersOrderToShow(mode);

    // then
    assertEquals(newAnswersOrder, result);
    verify(orderingItemsDao).setItemsOrder(newAnswersOrder);
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Test
public void shouldResetAnswersToNewRandomOnes() throws Exception {
    List<String> currentAnswers = Lists.newArrayList("currAnswers");
    when(model.getCurrentAnswers()).thenReturn(currentAnswers);

    List<String> correctAnswers = Lists.newArrayList("correctAnswers");
    when(model.getCorrectAnswers()).thenReturn(correctAnswers);

    List<String> newAnswersOrder = Lists.newArrayList("new Answers Order");
    when(orderingAnswersShuffler.shuffleAnswers(currentAnswers, correctAnswers)).thenReturn(newAnswersOrder);

    List<String> newItemsOrder = Lists.newArrayList("newItemsOrder");
    when(itemsResponseOrderController.getCorrectItemsOrderByAnswers(newAnswersOrder)).thenReturn(newItemsOrder);

    controller.reset();

    InOrder inOrder = Mockito.inOrder(orderingItemsDao, itemsResponseOrderController, orderingAnswersShuffler);
    inOrder.verify(orderingAnswersShuffler).shuffleAnswers(currentAnswers, correctAnswers);
    inOrder.verify(itemsResponseOrderController).getCorrectItemsOrderByAnswers(newAnswersOrder);
    inOrder.verify(orderingItemsDao).setItemsOrder(newItemsOrder);
    inOrder.verify(itemsResponseOrderController).updateResponseWithNewOrder(newItemsOrder);

    Mockito.verifyNoMoreInteractions(orderingAnswersShuffler, orderingItemsDao, itemsResponseOrderController);
}
 

import com.google.gwt.thirdparty.guava.common.collect.Lists; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    orderingItemsDao = new OrderingItemsDao();
    itemsMarkingController = new ItemsMarkingController(responseOrderController, responseSocket, model, orderingItemsDao);

    correctItem1 = createItem("correctItem1");
    wrongItem = createItem("wrongItem");
    correctItem2 = createItem("correctItem2");

    Response response = Mockito.mock(Response.class);
    when(model.getResponse()).thenReturn(response);

    when(responseSocket.evaluateResponse(response)).thenReturn(answersEvaluation);

    List<String> currentItemsOrder = Lists.newArrayList("correctItem1", "wrongItem", "correctItem2");
    when(responseOrderController.getCurrentItemsOrderByAnswers()).thenReturn(currentItemsOrder);
}