/** * Verifies that the actual AtomicReferenceArray does not contain the given values. * <p> * Example : * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"}); * * // assertion will pass * assertThat(abc).doesNotContain("d", "e"); * * // assertions will fail * assertThat(abc).doesNotContain("a"); * assertThat(abc).doesNotContain("a", "b", "c"); * assertThat(abc).doesNotContain("a", "x");</code></pre> * * @param values the given values. * @return {@code this} assertion object. * @throws NullPointerException if the given argument is {@code null}. * @throws IllegalArgumentException if the given argument is an empty array. * @throws AssertionError if the actual AtomicReferenceArray is {@code null}. * @throws AssertionError if the actual AtomicReferenceArray contains any of the given values. */ @Override public AtomicReferenceArrayAssert<T> doesNotContain(@SuppressWarnings("unchecked") T... values) { arrays.assertDoesNotContain(info, array, values); return myself; }
/** * Verifies that the actual AtomicReferenceArray does not contain the given object at the given index. * <p> * Example: * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya}); * * // assertions will pass * assertThat(elvesRings).doesNotContain(vilya, atIndex(1)) * .doesNotContain(nenya, atIndex(2)) * .doesNotContain(narya, atIndex(0)); * * // assertions will fail * assertThat(elvesRings).doesNotContain(vilya, atIndex(0)); * assertThat(elvesRings).doesNotContain(nenya, atIndex(1)); * assertThat(elvesRings).doesNotContain(narya, atIndex(2));</code></pre> * * @param value the object to look for. * @param index the index where the object should not be stored in the actual AtomicReferenceArray. * @return this assertion object. * @throws AssertionError if the actual AtomicReferenceArray is {@code null}. * @throws NullPointerException if the given {@code Index} is {@code null}. * @throws AssertionError if the actual AtomicReferenceArray contains the given object at the given index. */ @Override public AtomicReferenceArrayAssert<T> doesNotContain(T value, Index index) { arrays.assertDoesNotContain(info, array, value, index); return myself; }
/** * Verifies that the actual array does not contain the given object at the given index. * <p> * Example: * <pre><code class='java'> Ring[] elvesRings = {vilya, nenya, narya}; * * // assertions will pass * assertThat(elvesRings).doesNotContain(vilya, atIndex(1)); * assertThat(elvesRings).doesNotContain(nenya, atIndex(2)); * assertThat(elvesRings).doesNotContain(narya, atIndex(0)); * * // assertions will fail * assertThat(elvesRings).doesNotContain(vilya, atIndex(0)); * assertThat(elvesRings).doesNotContain(nenya, atIndex(1)); * assertThat(elvesRings).doesNotContain(narya, atIndex(2));</code></pre> * * @param value the object to look for. * @param index the index where the object should not be stored in the actual group. * @return this assertion object. * @throws AssertionError if the actual group is {@code null}. * @throws NullPointerException if the given {@code Index} is {@code null}. * @throws AssertionError if the actual group contains the given object at the given index. */ @Override public SELF doesNotContain(ELEMENT value, Index index) { arrays.assertDoesNotContain(info, actual, value, index); return myself; }
/** * Verifies that the actual array does not contain the given values. * <p> * Example : * <pre><code class='java'> String[] abc = {"a", "b", "c"}; * * // assertion will pass * assertThat(abc).doesNotContain("d", "e"); * * // assertions will fail * assertThat(abc).doesNotContain("a"); * assertThat(abc).doesNotContain("a", "b", "c"); * assertThat(abc).doesNotContain("a", "x");</code></pre> * * @param values the given values. * @return {@code this} assertion object. * @throws NullPointerException if the given argument is {@code null}. * @throws IllegalArgumentException if the given argument is an empty array. * @throws AssertionError if the actual group is {@code null}. * @throws AssertionError if the actual group contains any of the given values. */ @Override public SELF doesNotContain(@SuppressWarnings("unchecked") ELEMENT... values) { arrays.assertDoesNotContain(info, actual, values); return myself; }
/** * Verifies that the actual array does not contain the given values. * <p> * Example : * <pre><code class='java'> String[] abc = {"a", "b", "c"}; * * // assertion will pass * assertThat(abc).doesNotContain("d", "e"); * * // assertions will fail * assertThat(abc).doesNotContain("a"); * assertThat(abc).doesNotContain("a", "b", "c"); * assertThat(abc).doesNotContain("a", "x");</code></pre> * * @param values the given values. * @return {@code this} assertion object. * @throws NullPointerException if the given argument is {@code null}. * @throws IllegalArgumentException if the given argument is an empty array. * @throws AssertionError if the actual array is {@code null}. * @throws AssertionError if the actual array contains any of the given values. */ @Override public SELF doesNotContain(@SuppressWarnings("unchecked") ELEMENT... values) { arrays.assertDoesNotContain(info, actual, values); return myself; }
/** * Verifies that the actual AtomicReferenceArray does not contain the given values. * <p> * Example : * <pre><code class='java'> AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"}); * * // assertion will pass * assertThat(abc).doesNotContain("d", "e"); * * // assertions will fail * assertThat(abc).doesNotContain("a"); * assertThat(abc).doesNotContain("a", "b", "c"); * assertThat(abc).doesNotContain("a", "x");</code></pre> * * @param values the given values. * @return {@code this} assertion object. * @throws NullPointerException if the given argument is {@code null}. * @throws IllegalArgumentException if the given argument is an empty array. * @throws AssertionError if the actual AtomicReferenceArray is {@code null}. * @throws AssertionError if the actual AtomicReferenceArray contains any of the given values. */ @Override public AtomicReferenceArrayAssert<T> doesNotContain(@SuppressWarnings("unchecked") T... values) { arrays.assertDoesNotContain(info, array, values); return myself; }
/** * Verifies that the actual array does not contain the given object at the given index. * <p> * Example: * <pre><code class='java'> Ring[] elvesRings = {vilya, nenya, narya}; * * // assertions will pass * assertThat(elvesRings).doesNotContain(vilya, atIndex(1)); * assertThat(elvesRings).doesNotContain(nenya, atIndex(2)); * assertThat(elvesRings).doesNotContain(narya, atIndex(0)); * * // assertions will fail * assertThat(elvesRings).doesNotContain(vilya, atIndex(0)); * assertThat(elvesRings).doesNotContain(nenya, atIndex(1)); * assertThat(elvesRings).doesNotContain(narya, atIndex(2));</code></pre> * * @param value the object to look for. * @param index the index where the object should not be stored in the actual array. * @return this assertion object. * @throws AssertionError if the actual array is {@code null}. * @throws NullPointerException if the given {@code Index} is {@code null}. * @throws AssertionError if the actual array contains the given object at the given index. */ @Override public SELF doesNotContain(ELEMENT value, Index index) { arrays.assertDoesNotContain(info, actual, value, index); return myself; }
/** * Verifies that the actual AtomicReferenceArray does not contain the given object at the given index. * <p> * Example: * <pre><code class='java'> AtomicReferenceArray<Ring> elvesRings = new AtomicReferenceArray<>(new Ring[]{vilya, nenya, narya}); * * // assertions will pass * assertThat(elvesRings).doesNotContain(vilya, atIndex(1)) * .doesNotContain(nenya, atIndex(2)) * .doesNotContain(narya, atIndex(0)); * * // assertions will fail * assertThat(elvesRings).doesNotContain(vilya, atIndex(0)); * assertThat(elvesRings).doesNotContain(nenya, atIndex(1)); * assertThat(elvesRings).doesNotContain(narya, atIndex(2));</code></pre> * * @param value the object to look for. * @param index the index where the object should not be stored in the actual AtomicReferenceArray. * @return this assertion object. * @throws AssertionError if the actual AtomicReferenceArray is {@code null}. * @throws NullPointerException if the given {@code Index} is {@code null}. * @throws AssertionError if the actual AtomicReferenceArray contains the given object at the given index. */ @Override public AtomicReferenceArrayAssert<T> doesNotContain(T value, Index index) { arrays.assertDoesNotContain(info, array, value, index); return myself; }
public <T> void assertDoesNotContainAnyElementsOf(AssertionInfo info, Object[] actual, Iterable<? extends T> iterable) { checkIsNotNullAndNotEmpty(iterable); List<T> values = newArrayList(iterable); assertDoesNotContain(info, actual, values.toArray()); }
public <T> void assertDoesNotContainAnyElementsOf(AssertionInfo info, Object[] actual, Iterable<? extends T> iterable) { checkIsNotNullAndNotEmpty(iterable); List<T> values = newArrayList(iterable); assertDoesNotContain(info, actual, values.toArray()); }
/** {@inheritDoc} */ @Override public S doesNotContain(T value, Index index) { arrays.assertDoesNotContain(info, actual, value, index); return myself; }
/** {@inheritDoc} */ @Override public S doesNotContain(@SuppressWarnings("unchecked")T... values) { arrays.assertDoesNotContain(info, actual, values); return myself; }