import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
@Test
public void testDependentEnumIndexing() throws Exception {
    final String carFQN = "com.myteam.repro.Car";
    final Path testedPath = Paths.get(getClass().getResource("cars/src/main/resources/com/myteam/repro/cars.enumeration").toURI());
    final Set<KProperty<?>> properties = indexer.fillIndexBuilder(testedPath).build();
    final ModuleDataModelOracle oracle = indexer.getModuleDataModelOracle(testedPath);
    Assertions.assertThat(oracle.getModuleModelFields().keySet()).contains(carFQN);
    final AbstractListAssert carFields = Assertions.assertThat(properties).filteredOn("name", "ref:field:" + carFQN);
    carFields.filteredOn("value", "price").hasSize(1);
    carFields.filteredOn("value", "color").hasSize(1);
    final AbstractListAssert javaClasses = Assertions.assertThat(properties).filteredOn("name", "ref:java");
    javaClasses.filteredOn("value", carFQN).hasSize(1);
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
private AbstractListAssert<?, List<?>, Object, ObjectAssert<Object>> assertThatDataSourceDecoratingChain(DataSource dataSource) {
    return assertThat(((DecoratedDataSource) dataSource).getDecoratingChain()).extracting("dataSource").extracting("class");
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
/**
 * Delegate call to {@link org.assertj.core.api.Assertions#assertThat(List)}
 */
default <T> AbstractListAssert<?, List<? extends T>, T, ObjectAssert<T>> then(List<? extends T> actual) {
	fluentBdd().verification.recordThen(this);
	return DELEGATE.assertThat(actual);
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
/**
 * Delegate call to {@link org.assertj.core.api.Assertions#assertThat(List)}
 */
default <T> AbstractListAssert<?, List<? extends T>, T, ObjectAssert<T>> and(List<? extends T> actual) {
	fluentBdd().verification.recordThen(this);
	return DELEGATE.assertThat(actual);
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
public AbstractListAssert<?, ?, Object, ObjectAssert<Object>> commandParts() {
  return asCommand().commandParts();
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
@Override
public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object>> commandParts() {
  isNotNull();
  return assertThat(actual.getCommandParts()).as(description("commandParts"));
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
@Test
public void listOfValuesEmittedReturnsValidAssertion() {
    AbstractListAssert<?, ?, ?> listAssert = new BlockingObservableAssert<>(Observable.just("a", "b").toBlocking())
            .listOfValuesEmitted();
    assertThat(listAssert).isNotNull();
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
public static <T> AbstractListAssert<?, List<? extends T>, T, ObjectAssert<T>> complex1(List<? extends T> in) {
  return null;
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
public static <T> AbstractListAssert<?, List<? extends T>, T, ObjectAssert<T>> complex2(List<? extends T> in) {
  return null;
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
/**
 * Extract the array value at the given JSON path for further object assertions.
 * @param expression the {@link JsonPath} expression
 * @param args arguments to parameterize the {@code JsonPath} expression with, using
 * formatting specifiers defined in {@link String#format(String, Object...)}
 * @return a new assertion object whose object under test is the extracted item
 * @throws AssertionError if the path is not valid or does not result in an array
 */
@SuppressWarnings("unchecked")
public AbstractListAssert<?, ?, Object> extractingJsonPathArrayValue(
		CharSequence expression, Object... args) {
	return Assertions.assertThat(
			extractingJsonPathValue(expression, args, List.class, "an array"));
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
/**
 * Delegate call to public static org.assertj.core.api.AbstractListAssert<?, java.util.List<? extends java.lang.Double>, java.lang.Double, org.assertj.core.api.ObjectAssert<java.lang.Double>> org.assertj.core.api.Assertions.assertThat(java.util.stream.DoubleStream)
 * {@link org.assertj.core.api.Assertions#assertThat(java.util.stream.DoubleStream)}
 */
default AbstractListAssert<?, List<? extends Double>, Double, ObjectAssert<Double>> assertThat(DoubleStream actual) {
    return Assertions.assertThat(actual);
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
/**
 * Delegate call to public static <T> org.assertj.core.api.AbstractListAssert<?, ? extends java.util.List<? extends T>, T> org.assertj.core.api.Assertions.assertThat(java.util.List<? extends T>)
 * {@link org.assertj.core.api.Assertions#assertThat(java.util.List)}
 */
default <T> AbstractListAssert<?, ? extends List<? extends T>, T> assertThat(List<? extends T> actual) {
    return Assertions.assertThat(actual);
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
/**
 * Allows performing Assertj assertions over the list of values emitted onNext()
 *
 * @return an instance of @{link ListAssert} initialized with the values received onNext()
 */
public AbstractListAssert<?, ? extends List<? extends T>, T> listOfValuesEmitted() {
    isNotNull();
    return assertThat(getBlockingObservableExecutor().getValuesEmitted());
}
 

import org.assertj.core.api.AbstractListAssert; //导入依赖的package包/类
void assertColumnValues(AbstractListAssert<?, ? extends List<? extends T>, T> columnAssert);