Class StreamSubject

java.lang.Object
com.google.common.truth.Subject
com.google.common.truth.StreamSubject
public final class StreamSubject extends Subject
A subject for Stream values.

Note: When you perform an assertion based on the contents of the stream, or when any assertion fails, the wrapped stream will be drained immediately into a private collection to provide more readable failure messages. This consumes the stream. Take care if you intend to leave the stream un-consumed or if the stream is very large or infinite.

If you intend to make multiple assertions on the contents of the same stream, you should instead first collect the contents of the stream into a collection and then assert directly on that. For example: 


 List<Integer> list = makeStream().map(...).filter(...).collect(toImmutableList());
 assertThat(list).contains(5);
 assertThat(list).doesNotContain(2);

For very large or infinite streams, you may want to first limit the stream before asserting on it.

Since:
1.3.0 (previously part of truth-java8-extension)

  • Method Details

    • actualCustomStringRepresentation

      protected String actualCustomStringRepresentation()
      Description copied from class: Subject
      Returns a string representation of the actual value for inclusion in failure messages.

      Subjects should override this with care.

      By default, this method returns String.valueOf(getActualValue()) for most types. It does have some special logic for a few cases, like arrays.

      Overrides:
      actualCustomStringRepresentation in class Subject

    • streams

      @Deprecated public static Subject.Factory<StreamSubject, Stream<?>> streams()
      Deprecated.
      Instead of about(streams()).that(...), use just that(...). Similarly, instead of assertAbout(streams()).that(...), use just assertThat(...).
      Obsolete factory instance. This factory was previously necessary for assertions like assertWithMessage(...).about(streams()).that(stream)..... Now, you can perform assertions like that without the about(...) call.

    • isEmpty

      public void isEmpty()
      Checks that the actual stream is empty.

    • isNotEmpty

      public void isNotEmpty()
      Checks that the actual stream is not empty.

    • hasSize

      public void hasSize(int size)
      Checks that the actual stream has the given size.

      If you'd like to check that your stream contains more than Integer.MAX_VALUE elements, use assertThat(stream.count()).isEqualTo(...).

    • contains

      public void contains(@Nullable Object element)
      Checks that the actual stream contains the given element.

    • doesNotContain

      public void doesNotContain(@Nullable Object element)
      Checks that the actual stream does not contain the given element.

    • containsNoDuplicates

      public void containsNoDuplicates()
      Checks that the actual stream does not contain duplicate elements.

    • containsAnyOf

      public void containsAnyOf(@Nullable Object first, @Nullable Object second, @Nullable Object @Nullable ... rest)
      Checks that the actual stream contains at least one of the given elements.

    • containsAnyIn

      public void containsAnyIn(@Nullable Iterable<?> expected)
      Checks that the actual stream contains at least one of the given elements.

    • containsAtLeast

      @CanIgnoreReturnValue public Ordered containsAtLeast(@Nullable Object first, @Nullable Object second, @Nullable Object @Nullable ... rest)
      Checks that the actual stream contains all of the given elements. If an element appears more than once in the given elements, then it must appear at least that number of times in the actual elements.

      To also test that the contents appear in the given order, make a call to inOrder() on the object returned by this method. The expected elements must appear in the given order within the actual elements, but they are not required to be consecutive.

    • containsAtLeastElementsIn

      @CanIgnoreReturnValue public Ordered containsAtLeastElementsIn(@Nullable Iterable<?> expected)
      Checks that the actual stream contains all of the given elements. If an element appears more than once in the given elements, then it must appear at least that number of times in the actual elements.

      To also test that the contents appear in the given order, make a call to inOrder() on the object returned by this method. The expected elements must appear in the given order within the actual elements, but they are not required to be consecutive.

    • containsExactly

      @CanIgnoreReturnValue public Ordered containsExactly(@Nullable Object @Nullable ... expected)
      Checks that the actual stream contains exactly the given elements.

      Multiplicity is respected. For example, an object duplicated exactly 3 times in the parameters asserts that the object must likewise be duplicated exactly 3 times in the actual stream.

      To also test that the contents appear in the given order, make a call to inOrder() on the object returned by this method.

    • containsExactlyElementsIn

      @CanIgnoreReturnValue public Ordered containsExactlyElementsIn(@Nullable Iterable<?> expected)
      Checks that the actual stream contains exactly the given elements.

      Multiplicity is respected. For example, an object duplicated exactly 3 times in the parameters asserts that the object must likewise be duplicated exactly 3 times in the actual stream.

      To also test that the contents appear in the given order, make a call to inOrder() on the object returned by this method.

    • containsNoneOf

      public void containsNoneOf(@Nullable Object first, @Nullable Object second, @Nullable Object @Nullable ... rest)
      Checks that the actual stream does not contain any of the given elements.

    • containsNoneIn

      public void containsNoneIn(@Nullable Iterable<?> excluded)
      Checks that the actual stream does not contain any of the given elements.

    • isInStrictOrder

      public void isInStrictOrder()
      Checks that the actual stream is strictly ordered, according to the natural ordering of its elements. Strictly ordered means that each element in the stream is strictly greater than the element that preceded it.
      Throws:
      ClassCastException - if any pair of elements is not mutually Comparable
      NullPointerException - if any element is null

    • isInStrictOrder

      public void isInStrictOrder(Comparator<?> comparator)
      Checks that the actual stream is strictly ordered, according to the given comparator. Strictly ordered means that each element in the stream is strictly greater than the element that preceded it.
      Throws:
      ClassCastException - if any pair of elements is not mutually Comparable

    • isInOrder

      public void isInOrder()
      Checks that the actual stream is ordered, according to the natural ordering of its elements. Ordered means that each element in the stream is greater than or equal to the element that preceded it.
      Throws:
      ClassCastException - if any pair of elements is not mutually Comparable
      NullPointerException - if any element is null

    • isInOrder

      public void isInOrder(Comparator<?> comparator)
      Checks that the actual stream is ordered, according to the given comparator. Ordered means that each element in the stream is greater than or equal to the element that preceded it.
      Throws:
      ClassCastException - if any pair of elements is not mutually Comparable

    • isEqualTo

      @Deprecated public void isEqualTo(@Nullable Object expected)
      Deprecated.
      streamA.isEqualTo(streamB) always fails, except when passed the exact same stream reference. If you really want to test object identity, you can eliminate this deprecation warning by using Subject.isSameInstanceAs(java.lang.Object). If you instead want to test the contents of the stream, use containsExactly(java.lang.Object...) or similar methods.
      Description copied from class: Subject
      Checks that the value under test is equal to the given object. For the purposes of this comparison, two objects are equal if any of the following is true:

      Note: This method does not test the Object.equals(java.lang.Object) implementation itself; it assumes that method is functioning correctly according to its contract. Testing an equals implementation requires a utility such as guava-testlib's EqualsTester.

      In some cases, this method might not even call equals. It may instead perform other tests that will return the same result as long as equals is implemented according to the contract for its type.

      Overrides:
      isEqualTo in class Subject

    • isNotEqualTo

      @Deprecated public void isNotEqualTo(@Nullable Object other)
      Deprecated.
      streamA.isNotEqualTo(streamB) always passes, except when passed the exact same stream reference. If you really want to test object identity, you can eliminate this deprecation warning by using Subject.isNotSameInstanceAs(java.lang.Object). If you instead want to test the contents of the stream, collect both streams to lists and perform assertions like Subject.isNotEqualTo(java.lang.Object) on them. In some cases, you may be able to use StreamSubject assertions like doesNotContain(java.lang.Object).
      Description copied from class: Subject
      Checks that the value under test is not equal to the given object. The meaning of equality is the same as for the Subject.isEqualTo(java.lang.Object) method.
      Overrides:
      isNotEqualTo in class Subject