/** * Fails if the iterable is not strictly ordered, according to the natural ordering of its * elements. Strictly ordered means that each element in the iterable is <i>strictly</i> greater * than the element that preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable * @throws NullPointerException if any element is null */ public final void isStrictlyOrdered() { isStrictlyOrdered(Ordering.natural()); }
/** * Fails if the iterable is not strictly ordered, according to the given comparator. Strictly * ordered means that each element in the iterable is <i>strictly</i> greater than the element * that preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable */ public void isStrictlyOrdered(Comparator<?> comparator) { delegate().isStrictlyOrdered(comparator); }
/** * Fails if the subject is not strictly ordered, according to the given comparator. Strictly * ordered means that each element in the stream is <i>strictly</i> greater than the element that * preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder(Comparator<?> comparator) { check().that(actualList).isStrictlyOrdered(comparator); }
/** * Fails if the subject is not strictly ordered, according to the natural ordering of its * elements. Strictly ordered means that each element in the stream is <i>strictly</i> greater * than the element that preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable * @throws NullPointerException if any element is null */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder() { check().that(actualList).isStrictlyOrdered(); }
/** * Fails if the subject is not strictly ordered, according to the given comparator. Strictly * ordered means that each element in the stream is <i>strictly</i> greater than the element that * preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder(Comparator<?> comparator) { check().that(actualList).isStrictlyOrdered(comparator); }
/** * Fails if the subject is not strictly ordered, according to the given comparator. Strictly * ordered means that each element in the stream is <i>strictly</i> greater than the element that * preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder(Comparator<?> comparator) { check().that(actualList).isStrictlyOrdered(comparator); }
/** * Fails if the subject is not strictly ordered, according to the natural ordering of its * elements. Strictly ordered means that each element in the stream is <i>strictly</i> greater * than the element that preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable * @throws NullPointerException if any element is null */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder() { check().that(actualList).isStrictlyOrdered(); }
/** * Fails if the subject is not strictly ordered, according to the natural ordering of its * elements. Strictly ordered means that each element in the stream is <i>strictly</i> greater * than the element that preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable * @throws NullPointerException if any element is null */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder() { check().that(actualList).isStrictlyOrdered(); }
/** * Fails if the iterable is not strictly ordered, according to the given comparator. Strictly * ordered means that each element in the iterable is <i>strictly</i> greater than the element * that preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable */ public void isStrictlyOrdered(Comparator<?> comparator) { delegate().isStrictlyOrdered(comparator); }
/** * Fails if the subject is not strictly ordered, according to the natural ordering of its * elements. Strictly ordered means that each element in the stream is <i>strictly</i> greater * than the element that preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable * @throws NullPointerException if any element is null */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder() { check().that(actualList).isStrictlyOrdered(); }
/** * Fails if the subject is not strictly ordered, according to the natural ordering of its * elements. Strictly ordered means that each element in the stream is <i>strictly</i> greater * than the element that preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable * @throws NullPointerException if any element is null */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder() { check().that(actualList).isStrictlyOrdered(); }
/** * Fails if the subject is not strictly ordered, according to the given comparator. Strictly * ordered means that each element in the stream is <i>strictly</i> greater than the element that * preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder(Comparator<?> comparator) { check().that(actualList).isStrictlyOrdered(comparator); }
/** * Fails if the subject is not strictly ordered, according to the given comparator. Strictly * ordered means that each element in the stream is <i>strictly</i> greater than the element that * preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder(Comparator<?> comparator) { check().that(actualList).isStrictlyOrdered(comparator); }
/** * Fails if the subject is not strictly ordered, according to the given comparator. Strictly * ordered means that each element in the stream is <i>strictly</i> greater than the element that * preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder(Comparator<?> comparator) { check().that(actualList).isStrictlyOrdered(comparator); }
/** * Fails if the subject is not strictly ordered, according to the natural ordering of its * elements. Strictly ordered means that each element in the stream is <i>strictly</i> greater * than the element that preceded it. * * @throws ClassCastException if any pair of elements is not mutually Comparable * @throws NullPointerException if any element is null */ // TODO(kak): Make this public once go/truth-stream-isinorder is decided private void isInStrictOrder() { check().that(actualList).isStrictlyOrdered(); }