Java 类org.hamcrest.core.Is 实例源码

@Test
public void refresh() throws Exception {
    final Reddit reddit = new Reddit();
    PublishSubject<Reddit> subject = PublishSubject.create();
    Mockito.doReturn(subject.asObservable().toList())
            .when(mRepository)
            .getReddits(Mockito.anyString());
    mViewModel.refresh();
    Mockito.verify(mRepository).getReddits("test");
    Assert.assertThat(mViewModel.errorText.get(), IsNull.nullValue());
    Assert.assertThat(mViewModel.isLoading.get(), Is.is(true));
    subject.onNext(reddit);
    subject.onCompleted();
    Assert.assertThat(mViewModel.isLoading.get(), Is.is(false));
    Assert.assertThat(mViewModel.reddits, IsCollectionContaining.hasItems(reddit));
}

@Test
public void searchQueryChange() throws Exception {
    final Subreddit subreddit = new Subreddit();
    PublishSubject<Subreddit> subject = PublishSubject.create();
    Mockito.doReturn(subject.asObservable().toList())
            .when(mRepository)
            .searchSubreddits(Mockito.anyString());
    mViewModel.subscribeOnSearchQueryChange();
    mViewModel.mSearchQuery.onNext("test");
    Mockito.verify(mRepository).searchSubreddits("test");
    Assert.assertThat(mViewModel.isLoading.get(), Is.is(true));
    subject.onNext(subreddit);
    subject.onCompleted();
    Assert.assertThat(mViewModel.isLoading.get(), Is.is(false));
    Assert.assertThat(mViewModel.subreddits, IsCollectionContaining.hasItems(subreddit));
}

@Test
public void persistsEvent() {
  asyncStub.onConnected(serviceConfig, compensateResponseObserver);
  blockingStub.onTxEvent(someGrpcEvent(TxStartedEvent));
  // use the asynchronous stub need to wait for some time
  await().atMost(1, SECONDS).until(() -> !eventRepo.findByGlobalTxId(globalTxId).isEmpty());

  assertThat(receivedCommands.isEmpty(), is(true));

  TxEvent envelope = eventRepo.findByGlobalTxId(globalTxId).get(0);

  assertThat(envelope.serviceName(), is(serviceName));
  assertThat(envelope.instanceId(), is(instanceId));
  assertThat(envelope.globalTxId(), is(globalTxId));
  assertThat(envelope.localTxId(), is(localTxId));
  assertThat(envelope.parentTxId(), is(parentTxId));
  assertThat(envelope.type(), Is.is(TxStartedEvent.name()));
  assertThat(envelope.compensationMethod(), is(compensationMethod));
  assertThat(envelope.payloads(), is(payload.getBytes()));
}

@Test
@SuppressWarnings("ConstantConditions")
public void testSaveStateWithoutInstantiatedFragments() {
    final FragmentManager mockFragmentManager = mock(FragmentManager.class);
    final FragmentStatePagerAdapter adapter = new Adapter(mockFragmentManager);
    final Bundle restoreState = new Bundle();
    final Fragment.SavedState mockFragmentState = mock(Fragment.SavedState.class);
    final long itemId = adapter.getItemId(0);
    restoreState.putParcelable("android:pager:fragment_state:" + itemId, mockFragmentState);
    restoreState.putLongArray(FragmentStatePagerAdapter.STATE_FRAGMENT_STATES, new long[]{itemId});
    adapter.restoreState(restoreState, Adapter.class.getClassLoader());
    final Parcelable state = adapter.saveState();
    assertThat(state, is(not(nullValue())));
    assertThat(state, instanceOf(Bundle.class));
    final Bundle savedState = (Bundle) state;
    final long[] savedStateIds = savedState.getLongArray(FragmentStatePagerAdapter.STATE_FRAGMENT_STATES);
    assertThat(savedStateIds, is(not(nullValue())));
    assertThat(savedStateIds.length, is(1));
    assertThat(savedStateIds[0], is(itemId));
    assertThat(savedState.getParcelable("android:pager:fragment_state:" + itemId), Is.<Parcelable>is(mockFragmentState));
}

@Test
public void refreshError() throws Exception {
    PublishSubject<Reddit> subject = PublishSubject.create();
    Mockito.doReturn(subject.asObservable().toList())
            .when(mRepository)
            .getReddits(Mockito.anyString());
    mViewModel.refresh();
    Mockito.verify(mRepository).getReddits("test");
    Assert.assertThat(mViewModel.errorText.get(), IsNull.nullValue());
    Assert.assertThat(mViewModel.isLoading.get(), Is.is(true));
    subject.onError(new Exception("error text"));
    Assert.assertThat(mViewModel.isLoading.get(), Is.is(false));
    Assert.assertThat(mViewModel.errorText.get(), IsEqual.equalTo("error text"));
}

/**
 * Tests swiping to change tabs
 */
public void testTabSwiping() {
    final Matcher<View> mealsTab = withText(R.string.meals);
    final Matcher<View> recipesTab = withText(R.string.recipes);
    final Matcher<View> mealList = withTagKey(R.id.test_tag_meal_list,
            Is.<Object>is("Meal List"));
    final Matcher<View> recipeList = withTagKey(R.id.test_tag_recipe_list,
            Is.<Object>is("Recipe List"));
    final Matcher<View> pager = withClassName(IsEqual.equalTo(ViewPager.class.getName()));

    onView(pager).perform(swipeLeft());
    SystemClock.sleep(SWITCH_DELAY_MS);
    onView(recipesTab).check(matches(isSelected()));
    onView(pager).perform(swipeRight());
    SystemClock.sleep(SWITCH_DELAY_MS);
    onView(mealsTab).check(matches(isSelected()));
}

@Test
public void testAddToExistingGroup() {
    initiliase();
    ApplicationRegistrationMetadata metadata4 = new ApplicationRegistrationMetadata();
    metadata4.setId(4);
    metadata4.setName("API4");
    metadata4.setGroupId("za.co.moronicgeek.api4");
    metadata4.setSwaggerUrl("Another");
    registry.addApi(metadata4);
    Assert.assertThat(registry.sizeOf("za.co.moronicgeek.api4"), Is.is(1));
    ApiDefinition meta = registry.getMetadataByGroupId("za.co.moronicgeek.api4");

    ApplicationRegistrationMetadata metadata2 = new ApplicationRegistrationMetadata();
    metadata2.setId(4);
    metadata2.setName("API4");
    metadata2.setGroupId("za.co.moronicgeek.api4");
    metadata2.setSwaggerUrl("Dont care");
    registry.unRegisterApplication(metadata2);
    Assert.assertThat(registry.sizeOf("za.co.moronicgeek.api4"), Is.is(0));

}

@Test
public void testValidatePropertyTypes_objectClass() throws Exception {
    Map<String, Object> map = new HashMap<String, Object>();
    map.put(Constants.OBJECTCLASS, "test");
    Map<String, Object> config = validatePropertyTypes(map);
    assertThat(config.containsKey(Constants.OBJECTCLASS), is(true));
    assertThat(config.get(Constants.OBJECTCLASS), Is.<Object>is(new String[]{"test"}));

    map = new HashMap<String, Object>();
    map.put(Constants.OBJECTCLASS, new String[]{"test"});
    config = validatePropertyTypes(map);
    assertThat(config.get(Constants.OBJECTCLASS), Is.<Object>is(new String[]{"test"}));

    map = new HashMap<String, Object>();
    map.put(Constants.OBJECTCLASS, singletonList("test"));
    config = validatePropertyTypes(map);
    assertThat(config.get(Constants.OBJECTCLASS), Is.<Object>is(new String[]{"test"}));
}

@Override
protected void validateModel(CmmnModel model) {
    Case caseModel = model.getPrimaryCase();
    assertEquals("dmnExportCase", caseModel.getId());
    assertEquals("dmnExportCase", caseModel.getName());

    Stage planModelStage = caseModel.getPlanModel();
    assertNotNull(planModelStage);
    assertEquals("casePlanModel", planModelStage.getId());

    PlanItem planItem = planModelStage.findPlanItemInPlanFragmentOrUpwards("planItem1");
    assertNotNull(planItem);
    assertEquals("planItem1", planItem.getId());
    assertEquals("dmnTask", planItem.getName());
    PlanItemDefinition planItemDefinition = planItem.getPlanItemDefinition();
    assertNotNull(planItemDefinition);
    assertTrue(planItemDefinition instanceof DecisionTask);
    DecisionTask decisionTask = (DecisionTask) planItemDefinition;
    assertEquals("sid-F4BCA0C7-8737-4279-B50F-59272C7C65A2", decisionTask.getId());
    assertEquals("dmnTask", decisionTask.getName());

    FieldExtension fieldExtension = new FieldExtension();
    fieldExtension.setFieldName("decisionTaskThrowErrorOnNoHits");
    fieldExtension.setStringValue("false");
    assertThat(((DecisionTask) planItemDefinition).getFieldExtensions(), Is.is(Collections.singletonList(fieldExtension)));
}

@Test
public void require_that_session_created_from_active_that_is_no_longer_active_cannot_be_activated() throws Exception {
    Clock clock = Clock.systemUTC();

    long sessionId = 1;
    activateAndAssertOK(1, 0, clock);
    sessionId++;
    activateAndAssertOK(sessionId, 1, clock);

    sessionId++;
    ActivateRequest activateRequest = new ActivateRequest(sessionId, 1, "", Clock.systemUTC()).invoke();
    HttpResponse actResponse = activateRequest.getActResponse();
    String message = getRenderedString(actResponse);
    assertThat(message, actResponse.getStatus(), Is.is(CONFLICT));
    assertThat(message,
               containsString("Cannot activate session 3 because the currently active session (2) has changed since session 3 was created (was 1 at creation time)"));
}

@Ignore
@Test
public void markProgressForUser() throws Exception {
    final ProgressService service = JujacoreProgressServiceIntegrationTest
        .injector.getInstance(ProgressService.class);
    final SpreadSheetReader spreadsheet =
        JujacoreProgressServiceIntegrationTest.injector.getInstance(
            Key.get(SpreadSheetReader.class, Names.named("progress"))
        );
    Cell cell = new GdataCell(
        spreadsheet, "viktorkuchyn", "log-код", "+lms"
    );
    cell.update("");
    service.markProgressDone(
        User.create().withSlackNick("viktorkuchyn").build(), "+lms"
    );
    cell = new GdataCell(spreadsheet, "viktorkuchyn", "log-код", "+lms");
    MatcherAssert.assertThat(cell.value(), Is.is("DONE"));
}

@Test
public void checkHealthCheck_isHealthy() throws JsonProcessingException {
    SortedMap<String,HealthCheck.Result> map = new TreeMap<>();
    map.put("postgresql", HealthCheck.Result.healthy());
    map.put("deadlocks", HealthCheck.Result.healthy());
    when(healthCheckRegistry.runHealthChecks()).thenReturn(map);
    Response response = resource.healthCheck();
    assertThat(response.getStatus(), is(200));
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    String body = ow.writeValueAsString(response.getEntity());

    JsonAssert.with(body)
        .assertThat("$.*", hasSize(2))
        .assertThat("$.postgresql.healthy", Is.is(true))
        .assertThat("$.deadlocks.healthy", Is.is(true));
}

@Test
public void shouldRetrieveAuthorities() {
    MotechUser user = mock(MotechUser.class);
    RoleDto role = mock(RoleDto.class);
    List<String> roles = Arrays.asList("role1");
    when(user.getRoles()).thenReturn(roles);

    when(motechRoleService.getRole("role1")).thenReturn(role);

    List<String> permissions = Arrays.asList("permission1");
    when(role.getPermissionNames()).thenReturn(permissions);

    List<GrantedAuthority> authorities = authoritiesService.authoritiesFor(user);

    assertThat(authorities.size(), Is.is(1));
    assertThat(authorities.get(0).getAuthority(), Is.is("permission1"));

}

@Test
public void selected() {
  MatcherAssert.assertThat(
      JCheckBoxBuilder.builder()
          .selected(false)
          .build()
          .isSelected(),
      Is.is(false));

  MatcherAssert.assertThat(
      JCheckBoxBuilder.builder()
          .selected(true)
          .build()
          .isSelected(),
      Is.is(true));
}

@Test
public void itemListener() {

  final AtomicInteger triggerCount = new AtomicInteger(0);

  final String secondOption = "option 2";
  final JComboBox<String> box = JComboBoxBuilder.builder()
      .menuOptions("option 1", secondOption, "option 3")
      .itemListener(value -> {
        if (value.equals(secondOption)) {
          triggerCount.incrementAndGet();
        }
      }).build();
  box.setSelectedIndex(1);
  MatcherAssert.assertThat(triggerCount.get(), Is.is(1));
}

@Test
public void useLastSelectionAsFutureDefaultWithStringKey() {
  final String settingKey = "settingKey";
  ClientSetting.save(settingKey, "");
  MatcherAssert.assertThat("establish a preconditions state to avoid pollution between runs",
      ClientSetting.load(settingKey), Is.is(""));

  final JComboBox<String> box = JComboBoxBuilder.builder()
      .menuOptions("option 1", "option 2")
      .useLastSelectionAsFutureDefault(settingKey)
      .build();
  Mockito.when(mockItemEvent.getStateChange()).thenReturn(ItemEvent.SELECTED);
  Mockito.when(mockItemEvent.getSource()).thenReturn(box);
  final String valueFromEvent = "test value";
  Mockito.when(mockItemEvent.getItem()).thenReturn(valueFromEvent);
  Arrays.stream(box.getItemListeners())
      .forEach(listener -> listener.itemStateChanged(mockItemEvent));

  MatcherAssert.assertThat(
      "selecting the 1st index should be 'option 2', we expect that to "
          + "have been flushed to client settings",
      ClientSetting.load(settingKey), Is.is(valueFromEvent));
}

@Test
public void useLastSelectionAsFutureDefaultWithClientKey() {
  ClientSetting.TEST_SETTING.saveAndFlush("");

  final JComboBox<String> box = JComboBoxBuilder.builder()
      .menuOptions("option 1", "option 2")
      .useLastSelectionAsFutureDefault(ClientSetting.TEST_SETTING)
      .build();

  Mockito.when(mockItemEvent.getStateChange()).thenReturn(ItemEvent.SELECTED);
  Mockito.when(mockItemEvent.getSource()).thenReturn(box);
  final String valueFromEvent = "test value";
  Mockito.when(mockItemEvent.getItem()).thenReturn(valueFromEvent);
  Arrays.stream(box.getItemListeners())
      .forEach(listener -> listener.itemStateChanged(mockItemEvent));

  MatcherAssert.assertThat("We expect any selected value to have been bound to our test setting",
      ClientSetting.TEST_SETTING.value(), Is.is(valueFromEvent));
}

@Test
public void checkHealthCheck_isUnHealthy() throws JsonProcessingException {
    SortedMap<String,HealthCheck.Result> map = new TreeMap<>();
    map.put("ping", HealthCheck.Result.unhealthy("application is unavailable"));
    map.put("deadlocks", HealthCheck.Result.unhealthy("no new threads available"));
    when(healthCheckRegistry.runHealthChecks()).thenReturn(map);
    Response response = resource.healthCheck();
    assertThat(response.getStatus(), is(503));
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    String body = ow.writeValueAsString(response.getEntity());

    JsonAssert.with(body)
            .assertThat("$.*", hasSize(2))
            .assertThat("$.ping.healthy", Is.is(false))
            .assertThat("$.deadlocks.healthy", Is.is(false));
}

@Test
public void checkHealthCheck_pingIsHealthy_deadlocksIsUnhealthy() throws JsonProcessingException {
    SortedMap<String,HealthCheck.Result> map = new TreeMap<>();
    map.put("ping", HealthCheck.Result.healthy());
    map.put("deadlocks", HealthCheck.Result.unhealthy("no new threads available"));
    when(healthCheckRegistry.runHealthChecks()).thenReturn(map);
    Response response = resource.healthCheck();
    assertThat(response.getStatus(), is(503));
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    String body = ow.writeValueAsString(response.getEntity());

    JsonAssert.with(body)
            .assertThat("$.*", hasSize(2))
            .assertThat("$.ping.healthy", Is.is(true))
            .assertThat("$.deadlocks.healthy", Is.is(false));
}

@Test
public void addingSerializableField() throws Exception {
  Portability<Serializable> p = new SerializablePortability();

  ClassLoader loaderA = createClassNameRewritingLoader(A_write.class, IncompatibleSerializable_write.class, Serializable_write.class);
  Serializable a = (Serializable) loaderA.loadClass(newClassName(A_write.class)).newInstance();
  ByteBuffer encodedA = p.encode(a);

  pushTccl(createClassNameRewritingLoader(A_read.class, IncompatibleSerializable_read.class));
  try {
    Serializable out = p.decode(encodedA);
    Assert.assertThat(out.getClass().getField("bar").getInt(out), Is.is(4));
  } finally {
    popTccl();
  }
}

@Test
public void addingExternalizableField() throws Exception {
  Portability<Serializable> p = new SerializablePortability();

  ClassLoader loaderA = createClassNameRewritingLoader(B_write.class, Externalizable_write.class);
  Serializable a = (Serializable) loaderA.loadClass(newClassName(B_write.class)).newInstance();
  ByteBuffer encodedA = p.encode(a);

  pushTccl(createClassNameRewritingLoader(B_read.class));
  try {
    Serializable out = p.decode(encodedA);
    Assert.assertThat(out.getClass().getField("bar").getInt(out), Is.is(4));
  } finally {
    popTccl();
  }
}

@Test
public void test() throws Exception {
  Portability<Serializable> p = new SerializablePortability();

  ClassLoader loaderA = createClassNameRewritingLoader(A_old.class);
  Serializable a = (Serializable) loaderA.loadClass(newClassName(A_old.class)).newInstance();
  ByteBuffer encodedA = p.encode(a);

  ClassLoader loaderB = createClassNameRewritingLoader(A_new.class);
  pushTccl(loaderB);
  try {
    Serializable outA = p.decode(encodedA);
    Assert.assertThat(outA.getClass().getField("integer").get(outA), Is.is(42));

    Serializable b = (Serializable) loaderB.loadClass(newClassName(A_new.class)).newInstance();
    Serializable outB = p.decode(p.encode(b));
    Assert.assertThat(outB.getClass().getField("integer").get(outB), Is.is(42));
  } finally {
    popTccl();
  }
}

@Test
public void testRead() {
    ModsDefinition mods = new ModsDefinition();
    mods.getOriginInfo().add(originInfo(Role.PRINTER, "printer[0]", "date0", "place0"));
    mods.getOriginInfo().add(originInfo(Role.PRINTER, "printer[1]", "date1", "place1"));
    mods.getOriginInfo().add(originInfo(Role.OTHER, "unknown[2]", "date2", "place2"));
    mods.getOriginInfo().add(originInfo(Role.PUBLISHER, "publisher[3]", "date3", "place3"));
    mods.getOriginInfo().add(originInfo(Role.OTHER, "unknown[4]", null, null));
    mods.getOriginInfo().add(originInfo(Role.PUBLISHER, "publisher[5]", "date5", "place5"));
    List<OriginInfoItem> expected = Arrays.<OriginInfoItem>asList(
            new PublisherItem(0, Role.PRINTER, "printer[0]", "date0", "place0"),
            new PublisherItem(1, Role.PRINTER, "printer[1]", "date1", "place1"),
            new PublisherItem(2, Role.OTHER, null, null, null),
            new PublisherItem(3, Role.PUBLISHER, "publisher[3]", "date3", "place3"),
            new PublisherItem(4, Role.OTHER, null, null, null),
            new PublisherItem(5, Role.PUBLISHER, "publisher[5]", "date5", "place5")
            );

    OriginInfoMapper instance = new OriginInfoMapper();
    List<OriginInfoItem> result = instance.map(mods);
    assertThat(result, Is.is(expected));
}

@Test
public void testThatItShouldAllowRestApiAccessAfterFormAuthentication() throws IOException, JSONException,
        InterruptedException {

    HttpGet statusRequest =
            new HttpGet(String.format("http://%s:%d/motech-platform-server/module/server/web-api/status", HOST, PORT));

    HttpResponse response = HTTP_CLIENT.execute(statusRequest, HttpStatus.SC_UNAUTHORIZED);
    assertEquals(HttpStatus.SC_UNAUTHORIZED, response.getStatusLine().getStatusCode());

    Header authenticateHeader = response.getFirstHeader(HttpHeaders.WWW_AUTHENTICATE);
    assertNotNull(authenticateHeader);

    String authenticateHeaderValue = authenticateHeader.getValue();
    assertThat(authenticateHeaderValue, Is.is("Basic realm=\"MOTECH\""));

    EntityUtils.consume(response.getEntity());

    login();

    HttpResponse statusResponse = HTTP_CLIENT.execute(statusRequest);
    assertEquals(HttpStatus.SC_OK, statusResponse.getStatusLine().getStatusCode());
}

@Test
    public void testWrite() {
        ModsDefinition mods = new ModsDefinition();
        mods.getLanguage().add(language("cze"));
        mods.getLanguage().add(otherLanguage("other1"));
        mods.getLanguage().add(language("ger"));
        List<LanguageItem> updates = Arrays.asList(
                new LanguageItem(0, "cze-update"), // update
//                new LanguageItem(2, "ger") // delete
                new LanguageItem(null, "eng") // add
                );
        LanguageMapper instance = new LanguageMapper();
        instance.map(mods, updates);
        List<LanguageItem> result = instance.map(mods);
        List<LanguageItem> expect = Arrays.asList(
                new LanguageItem(0, "cze-update"),
                new LanguageItem(1, "eng")
                );
        assertThat(result, Is.is(expect));
    }

@Test
public void testDeserializeInteractionListResponse() throws IOException {
    ClassLoader cl = InteractionListResponseTest.class.getClassLoader();
    File testJsonResponseFile = new File(cl.getResource("json/interaction-list-response.json").getFile());
    FileReader jsonStreamReader = new FileReader(testJsonResponseFile);
    InteractionListResponse response = gson.fromJson(jsonStreamReader, InteractionListResponse.class);
    jsonStreamReader.close();

    assertThat("InteractionDrugResponse is populated", response, Matchers.notNullValue());

    FullInteractionTypeGroup interactionGroup = response.getFullInteractionTypeGroup().get(0);
    assertThat("FullInteractionTypeGroup list is populated", interactionGroup.getFullInteractionType().size(), Matchers.greaterThanOrEqualTo(1));

    FullInteractionType interaction = interactionGroup.getFullInteractionType().get(0);

    assertThat("First drug is Simvastatin 40 MG Oral Tablet [Zocor]", interaction.getMinConcept().get(0).getName(), Is.is("Simvastatin 40 MG Oral Tablet [Zocor]"));
    assertThat("Second drug is bosentan 125 MG Oral Tablet", interaction.getMinConcept().get(1).getName(), Is.is("bosentan 125 MG Oral Tablet"));

}

public static void assertPeriodicalEquals(Periodical expected, Periodical actual) {
    if (expected == null && actual == null) {
        return ;
    }
    assertNotNull(expected);
    assertNotNull(actual);
    assertThat(actual.getIdentifiers(), Is.is(expected.getIdentifiers()));
    assertEquals(expected.getSigla(), actual.getSigla());
    assertThat(actual.getShelfLocators(), Is.is(expected.getShelfLocators()));
    assertThat(actual.getPeriodicities(), Is.is(expected.getPeriodicities()));
    assertThat(actual.getTitles(), Is.is(expected.getTitles()));
    assertThat(actual.getSubtitles(), Is.is(expected.getSubtitles()));
    assertThat(actual.getKeyTitles(), Is.is(expected.getKeyTitles()));
    assertThat(actual.getAlternativeTitles(), Is.is(expected.getAlternativeTitles()));
    assertThat(actual.getIdentifiers(), Is.is(expected.getIdentifiers()));
    assertThat(actual.getAuthors(), Is.is(expected.getAuthors()));
    assertThat(actual.getContributors(), Is.is(expected.getContributors()));
    assertThat(actual.getPrinters(), Is.is(expected.getPrinters()));
    assertThat(actual.getPublishers(), Is.is(expected.getPublishers()));
    assertThat(actual.getLanguages(), Is.is(expected.getLanguages()));
    assertThat(actual.getClassifications(), Is.is(expected.getClassifications()));
    assertThat(actual.getKeywords(), Is.is(expected.getKeywords()));
    assertThat(actual.getPhysicalDescriptions(), Is.is(expected.getPhysicalDescriptions()));
    assertEquals(expected.getRecordOrigin(), actual.getRecordOrigin());
    assertEquals(expected.getNote(), actual.getNote());
}

@Test
public void testGetTitles() {
    ModsDefinition mods = ModsUtils.unmarshal(XML, ModsDefinition.class);
    TitleInfoMapper instance = new TitleInfoMapper(mods);

    List<String> titleResult = instance.getTitles();
    List<String> subtitleResult = instance.getSubtitles();
    List<String> alternativeResult = instance.getAlternativeTitles();
    List<String> keyResult = instance.getKeyTitles();

    List<String> titleExpected = Arrays.asList("MTITLE[1][0]");
    List<String> subtitleExpected = Arrays.asList("STITLE[1][0]");
    List<String> alternativeExpected = Arrays.asList("ATITLE[0][0]", "ATITLE[0][1]");
    List<String> keyExpected = Arrays.asList("KTITLE[2][0]");

    assertThat(titleResult, Is.is(titleExpected));
    assertThat(subtitleResult, Is.is(subtitleExpected));
    assertThat(alternativeResult, Is.is(alternativeExpected));
    assertThat(keyResult, Is.is(keyExpected));
}

@Test
public void testGetEmptyTitles() {
    TitleInfoMapper instance = new TitleInfoMapper(new ModsDefinition());

    List<String> titleResult = instance.getTitles();
    List<String> subtitleResult = instance.getSubtitles();
    List<String> alternativeResult = instance.getAlternativeTitles();
    List<String> keyResult = instance.getKeyTitles();

    List<String> titleExpected = Collections.emptyList();
    List<String> subtitleExpected = Collections.emptyList();
    List<String> alternativeExpected = Collections.emptyList();
    List<String> keyExpected = Collections.emptyList();

    assertThat(titleResult, Is.is(titleExpected));
    assertThat(subtitleResult, Is.is(subtitleExpected));
    assertThat(alternativeResult, Is.is(alternativeExpected));
    assertThat(keyResult, Is.is(keyExpected));
}

@Test
public void testToPairs() {
    List<ArrayItem> items = Arrays.asList(
            new ExtentItem(0, "extent1[0]"),
            new ExtentItem(1, "size1[1]"),
            new UnkownItem(2),
            new ExtentItem(3, "extent2[3]"),
            new ExtentItem(4, "size2[4]"),
            new ExtentItem(5, "extent3[5]")
            );
    List<ExtentPair> expected = Arrays.asList(
            new ExtentPair("extent1[0]", 0, "size1[1]", 1),
            new ExtentPair("extent2[3]", 3, "size2[4]", 4),
            new ExtentPair("extent3[5]", 5, null, null)
            );
    List<ExtentPair> result = PhysicalDescriptionMapper.toPairs(items);
    assertThat(result, Is.is(expected));
}

@Test
public void testReadPairs() {
    ModsDefinition mods = new ModsDefinition();
    mods.getClassification().add(classificationType(Type.DDC.getText(), "ddc[0]"));
    mods.getClassification().add(classificationType(Type.DDC.getText(), "ddc[1]"));
    mods.getClassification().add(classificationType(Type.UDC.getText(), "udc[2]"));
    mods.getClassification().add(classificationType(null, "unknown[3]"));
    mods.getClassification().add(classificationType(Type.UDC.getText(), "udc[4]"));
    ClassificationMapper instance = new ClassificationMapper();
    List<ClassificationPair> expResult = Arrays.asList(
        new ClassificationPair("ddc[0]", 0, null, null),
        new ClassificationPair("ddc[1]", 1, "udc[2]", 2),
        new ClassificationPair(null, null, "udc[4]", 4)
    );
    List<ClassificationPair> result = instance.mapPairs(mods);
    assertThat(result, Is.is(expResult));
}

@Test
public void when_I_kafka_has_topics_and_I_getAllTopics_then_I_get_all_these_topics() {
    List<String> topics = new ArrayList<>();
    topics.add("RTopic-1");
    topics.add("ELaTopic-2");

    Seq<String> topicsFromZK = scala.collection.JavaConversions.asScalaBuffer(topics).seq();
    when(zkUtilsMock.getAllTopics()).thenReturn(topicsFromZK);

    List<String> allTopics = topicService.getAllTopics();
    assertThat("The getAllTopics response must contains only 2 items because the zkUtils returns 2 items", allTopics.size(), Is.is(2));
    assertThat("The getAllTopics response must contains RTopic-1 because the zkUtils returns it", allTopics, hasItem("RTopic-1"));
    assertThat("The getAllTopics response must contains ELaTopic-2 because the zkUtils returns it", allTopics, hasItem("ELaTopic-2"));
}

@Test
public void agent_registered() {
    clusterListener.onAgentRegistration(regMsg);

    RegisteredAgent agent = registry.byKey(AgentUtil.DUMMY_AGENT);
    assertThat(agent.getAgentKey(), Is.is(AgentUtil.DUMMY_AGENT));
    assertThat(agent.getSystemConfig(), is(regMsg.getSystemConfig()));
    assertThat(agent.getCreationTime(), is(regMsg.getCreationTime()));

    verify(clientListener).onAgentRegistration(regMsg);
    verifyNoMoreInteractions(clientListener);
}

@Test
public void list_all() {
    clusterListener.onAgentRegistration(regMsg);

    Set<RegisteredAgent> agents = registry.all();

    assertThat(agents.size(), is(1));

    RegisteredAgent agent = agents.iterator().next();
    assertThat(agent.getAgentKey(), Is.is(AgentUtil.DUMMY_AGENT));
}

@Test
public void actor_registered() {
    clusterListener.onActorCreated(TestActor.DUMMY_ACTOR, AgentUtil.DUMMY_AGENT);
    RegisteredActor actor = registry.byKey(TestActor.DUMMY_ACTOR);

    assertThat(actor.getKey(), Is.is(TestActor.DUMMY_ACTOR));
    assertThat(actor.getAgent(), Is.is(AgentUtil.DUMMY_AGENT));
    assertThat(actor.getState(), is(State.CREATED));

    verify(clientListener).onActorCreated(TestActor.DUMMY_ACTOR, AgentUtil.DUMMY_AGENT);
    verifyNoMoreInteractions(clientListener);
}

@Test
public void actor_created_twice_is_registered_only_once() {
    clusterListener.onActorCreated(TestActor.DUMMY_ACTOR, AgentUtil.DUMMY_AGENT);
    clusterListener.onActorCreated(TestActor.DUMMY_ACTOR, AgentUtil.DUMMY_AGENT);

    RegisteredActor actor = registry.byKey(TestActor.DUMMY_ACTOR);

    assertThat(actor.getKey(), Is.is(TestActor.DUMMY_ACTOR));
    assertThat(actor.getAgent(), Is.is(AgentUtil.DUMMY_AGENT));
    assertThat(actor.getState(), is(State.CREATED));

    verify(clientListener).onActorCreated(TestActor.DUMMY_ACTOR, AgentUtil.DUMMY_AGENT);
    verifyNoMoreInteractions(clientListener);
}

@Test
public void list_all() {
    clusterListener.onActorCreated(TestActor.DUMMY_ACTOR, AgentUtil.DUMMY_AGENT);

    Set<RegisteredActor> actors = registry.all();
    assertThat(actors.size(), is(1));

    RegisteredActor actor = actors.iterator().next();
    assertThat(actor.getKey(), Is.is(TestActor.DUMMY_ACTOR));
    assertThat(actor.getState(), is(State.CREATED));
}

@Test
public void actor_registered_and_initialized() {
    clusterListener.onActorCreated(TestActor.DUMMY_ACTOR, AgentUtil.DUMMY_AGENT);
    clusterListener.onActorInitialized(TestActor.DUMMY_ACTOR, DEPLOY_INFO);

    RegisteredActor actor = registry.byKey(TestActor.DUMMY_ACTOR);

    assertThat(actor.getKey(), Is.is(TestActor.DUMMY_ACTOR));
    assertThat(actor.getAgent(), Is.is(AgentUtil.DUMMY_AGENT));
    assertThat(actor.getState(), is(State.INITIALIZED));

    verify(clientListener).onActorCreated(TestActor.DUMMY_ACTOR, AgentUtil.DUMMY_AGENT);
    verify(clientListener).onActorInitialized(TestActor.DUMMY_ACTOR, DEPLOY_INFO);
    verifyNoMoreInteractions(clientListener);
}

/**
 * This is equal to check
 * @param value the value
 */
public void is(@Nullable T value) {
  if (value == null) {
    isNull();
  } else {
    verifyUsingMatcher(Is.is(value));
  }
}

@Test
void formatToString() {
    assertThat(TimeUtils.formatToString(30, TimeUnit.NANOSECONDS), Is.is("30 ns"));
    assertThat(TimeUtils.formatToString(30, TimeUnit.MICROSECONDS), Is.is("30 \u03bcs"));
    assertThat(TimeUtils.formatToString(30, TimeUnit.MILLISECONDS), Is.is("30 ms"));
    assertThat(TimeUtils.formatToString(30, TimeUnit.SECONDS), Is.is("30 s"));
    assertThat(TimeUtils.formatToString(30, TimeUnit.MINUTES), Is.is("30 min"));
    assertThat(TimeUtils.formatToString(5, TimeUnit.HOURS), Is.is("5 h"));
    assertThat(TimeUtils.formatToString(30, TimeUnit.DAYS), Is.is("30 d"));
}