Java Index类代码示例

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void allowEmptyConstructorToBuildDefaultClock() {
    testAppender.clearEvents();

    HttpContext context = new BasicHttpContext();
    context.setAttribute(HTTP_TARGET_HOST, "http://www.google.com");

    OutboundRequestLoggingInterceptor interceptor = new OutboundRequestLoggingInterceptor();

    interceptor.process(new BasicHttpRequest("GET", "/something"), context);
    interceptor.process(new BasicHttpResponse(new BasicStatusLine(ANY_PROTOCOL, 200, "any")), context);

    assertThat(testAppender.getEvents()).extracting("message")
        .contains("Outbound request start", Index.atIndex(0))
        .contains("Outbound request finish", Index.atIndex(1));
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void dataSupplierListenerShouldCollectMetaData() {
    run(DataProviderTransformer.class.getName(),
            ArraysDataSupplierTests.class,
            CollectionsDataSupplierTests.class,
            StreamsDataSupplierTests.class,
            SingleObjectsDataSupplierTests.class,
            TupleDataSupplierTests.class,
            DataSupplierWithCustomNamesTests.class,
            InjectedArgsDataSupplierTests.class,
            ParallelDataSupplierTests.class,
            InternalFactoryTests.class
    );

    final List<DataSupplierInterceptor> interceptors = getInterceptors();

    assertThat(interceptors).hasSize(2);

    assertThat(StreamEx.of(interceptors)
                       .map(DataSupplierInterceptor::getMetaData)
                       .flatMap(StreamEx::of)
                       .toList())
            .extracting(DataSupplierMetaData::getDataSupplierMethod)
            .extracting(Method::getName)
            .hasSize(55)
            .contains("getConstructorData", Index.atIndex(10));
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_contains_value_at_index_according_to_custom_comparison_strategy() {
  AssertionInfo info = someInfo();
  Index index = atIndex(0);
  try {
    arraysWithCustomComparisonStrategy.assertDoesNotContain(info, actual, 'A', index);
  } catch (AssertionError e) {
    verify(failures).failure(info, shouldNotContainAtIndex(actual, 'A', index, caseInsensitiveComparisonStrategy));
    return;
  }
  failBecauseExpectedAssertionErrorWasNotThrown();
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_does_not_contain_value_at_index() {
  AssertionInfo info = someInfo();
  short value = 6;
  Index index = atIndex(1);
  try {
    arrays.assertContains(info, actual, value, index);
  } catch (AssertionError e) {
    short found = 8;
    verify(failures).failure(info, shouldContainAtIndex(actual, value, index, found));
    return;
  }
  failBecauseExpectedAssertionErrorWasNotThrown();
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_contains_value_at_index_according_to_custom_comparison_strategy() {
  AssertionInfo info = someInfo();
  byte value = 6;
  Index index = atIndex(0);
  try {
    arraysWithCustomComparisonStrategy.assertDoesNotContain(info, actual, value, index);
  } catch (AssertionError e) {
    verify(failures).failure(info, shouldNotContainAtIndex(actual, value, index, absValueComparisonStrategy));
    return;
  }
  failBecauseExpectedAssertionErrorWasNotThrown();
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_does_not_satisfy_condition_at_index() {
  condition.shouldMatch(false);
  AssertionInfo info = someInfo();
  Index index = atIndex(1);
  try {
    lists.assertIs(info, actual, condition, index);
  } catch (AssertionError e) {
    verify(failures).failure(info, shouldBeAtIndex(actual, condition, index, "Luke"));
    return;
  }
  failBecauseExpectedAssertionErrorWasNotThrown();
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_contains_value_at_index() {
  AssertionInfo info = someInfo();
  Index index = atIndex(0);
  try {
    arrays.assertDoesNotContain(info, actual, 6, index);
  } catch (AssertionError e) {
    verify(failures).failure(info, shouldNotContainAtIndex(actual, (byte) 6, index));
    return;
  }
  failBecauseExpectedAssertionErrorWasNotThrown();
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_contains_value_at_index_according_to_custom_comparison_strategy() {
  AssertionInfo info = someInfo();
  short value = 6;
  Index index = atIndex(0);
  try {
    arraysWithCustomComparisonStrategy.assertDoesNotContain(info, actual, value, index);
  } catch (AssertionError e) {
    verify(failures).failure(info, shouldNotContainAtIndex(actual, value, index, absValueComparisonStrategy));
    return;
  }
  failBecauseExpectedAssertionErrorWasNotThrown();
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_does_not_contain_value_at_index() {
  double value = 6;
  Index index = atIndex(1);
  thrown.expectAssertionError(shouldContainAtIndex(actual, value, index, 8d));
  arrays.assertContains(someInfo(), actual, value, index);
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_does_not_contain_value_at_index() {
  AssertionInfo info = someInfo();
  Index index = atIndex(1);
  try {
    arrays.assertContains(info, actual, 6, index);
  } catch (AssertionError e) {
    byte found = 8;
    verify(failures).failure(info, shouldContainAtIndex(actual, (byte) 6, index, found));
    return;
  }
  failBecauseExpectedAssertionErrorWasNotThrown();
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_contains_value_at_index() {
  AssertionInfo info = someInfo();
  byte value = 6;
  Index index = atIndex(0);
  try {
    arrays.assertDoesNotContain(info, actual, value, index);
  } catch (AssertionError e) {
    verify(failures).failure(info, shouldNotContainAtIndex(actual, value, index));
    return;
  }
  failBecauseExpectedAssertionErrorWasNotThrown();
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_does_not_contain_value_at_index() {
  AssertionInfo info = someInfo();
  Index index = atIndex(1);
  try {
    lists.assertContains(info, actual, "Han", index);
  } catch (AssertionError e) {
    verify(failures).failure(info, shouldContainAtIndex(actual, "Han", index, "Luke"));
    return;
  }
  failBecauseExpectedAssertionErrorWasNotThrown();
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_contains_value_at_index() {
  AssertionInfo info = someInfo();
  Index index = atIndex(0);
  try {
    lists.assertDoesNotContain(info, actual, "Yoda", index);
  } catch (AssertionError e) {
    verify(failures).failure(info, shouldNotContainAtIndex(actual, "Yoda", index));
    return;
  }
  failBecauseExpectedAssertionErrorWasNotThrown();
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
private <T> boolean conditionIsMetAtIndex(AssertionInfo info, List<T> actual, Condition<? super T> condition, Index index) {
  assertNotNull(info, actual);
  assertNotNull(condition);
  Iterables.instance().assertNotEmpty(info, actual);
  checkIndexValueIsValid(index, actual.size() - 1);
  return condition.matches(actual.get(index.value));
}
 

import org.assertj.core.data.Index; //导入依赖的package包/类
@Test
public void should_fail_if_actual_does_not_contain_value_at_index_according_to_custom_comparison_strategy() {
  AssertionInfo info = someInfo();
  Index index = atIndex(1);
  try {
    listsWithCaseInsensitiveComparisonStrategy.assertContains(info, actual, "Han", index);
  } catch (AssertionError e) {
    verify(failures).failure(info, shouldContainAtIndex(actual, "Han", index, "Luke", comparisonStrategy));
    return;
  }
  failBecauseExpectedAssertionErrorWasNotThrown();
}