Java 类org.assertj.core.api.ListAssert 实例源码

public ChangesTestSubscriber assertChanges(Consumer<ListAssert<Tuple>> consumer) {
    consumer.accept(
            assertThat(values())
                    .extracting(
                            it -> DurationFormatUtils.formatDuration(it.time(MILLISECONDS), "ss:SSS", true),
                            it -> getPathString(it.value()),
                            it -> it.value().getData()
                    ));
    return this;
}

@Test
public void it_should_be_possible_to_get_it_only_in_that_level() {
    this.sut.add(MessageFixturer.EXAMPLE_LEVEL, MessageFixturer.EXAMPLE_TEXT);

    for (final Level level : Level.values()) {
        final ListAssert<Message> assertion = assertThat(this.sut.getMessages(level));

        if (level == MessageFixturer.EXAMPLE_LEVEL) {
            assertion.containsExactly(MESSAGE_DEFAULT_EXAMPLE);
        } else {
            assertion.doesNotContain(MESSAGE_DEFAULT_EXAMPLE);
        }
    }
}

public ListAssert<Exclusion> exclusions() {
    isNotNull();
    return Assertions.assertThat(actual.getExclusions());
}

public static <$Element> ListAssert<$Element> resultOf(CheckedListSupplier<$Element> whenStep) {
    return assertThat(result(whenStep));
}

public ListAssert<Entry> entries() {
    return new ListAssert<>(actual.getEntries());
}

private ListAssert<String> assertThatFileList(Path path) throws IOException {
    return (ListAssert) assertThat(Files.list(path))
            .extracting(Path::getFileName)
            .extracting(Object::toString);
}

public ListAssert<Annotation> getAnnotations(Class<? extends Annotation> annotationClass) {
    ListAssert<Annotation> assertThat = assertThat(getAnnotationList(annotationClass));
    return assertThat;
}

@Override
protected ListAssert<String> invoke_api_method() {
  return assertions.isSortedAccordingTo(comparator);
}

@Override
 protected ListAssert<String> invoke_api_method() {
return assertions.usingComparator(comparator);
 }

@Override
protected ListAssert<String> invoke_api_method() {
  return assertions.usingDefaultComparator();
}

@Override
protected ListAssert<String> invoke_api_method() {
  return assertions.has(condition, index);
}

@Override
protected ListAssert<String> invoke_api_method() {
  return assertions.contains("Yoda", index);
}

@Override
 protected ListAssert<String> invoke_api_method() {
return assertions.usingElementComparatorIgnoringFields("field");
 }

@Override
protected ListAssert<String> invoke_api_method() {
  return assertions.doesNotContain("Yoda", index);
}

@Override
 protected ListAssert<String> invoke_api_method() {
return assertions.usingElementComparatorOnFields("field");
 }

@Override
protected ListAssert<String> invoke_api_method() {
  return assertions.is(condition, index);
}

@Override
 protected ListAssert<String> invoke_api_method() {
return assertions.usingFieldByFieldElementComparator();
 }

@Override
protected ListAssert<String> invoke_api_method() {
  return assertions.isSorted();
}

public static <ELEMENT> ListAssert<ELEMENT> listAssert(List<? extends ELEMENT> actual) {
  return null;
}

public static <T> ListAssert<T> listAssert2(List<? extends T> actual) {
  return null;
}

/**
 * Delegate call to public static <ELEMENT> org.assertj.core.api.ListAssert<ELEMENT> org.assertj.core.api.Assertions.assertThat(java.util.List<? extends ELEMENT>)
 * {@link org.assertj.core.api.Assertions#assertThat(java.util.List)}
 */
default <ELEMENT> ListAssert<ELEMENT> assertThat(List<? extends ELEMENT> actual) {
    return Assertions.assertThat(actual);
}

/**
 * Delegate call to public static <ELEMENT> org.assertj.core.api.ListAssert<ELEMENT> org.assertj.core.api.Assertions.assertThat(java.util.List<? extends ELEMENT>)
 * {@link org.assertj.core.api.Assertions#assertThat(java.util.List)}
 */
default <ELEMENT> ListAssert<ELEMENT> assertThat(List<? extends ELEMENT> actual) {
    return Assertions.assertThat(actual);
}