/** * Verifies that the actual array contains the given values, in any order. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).contains(true, false); * assertThat(new boolean[] { false, true }).contains(true, false); * assertThat(new boolean[] { true, false }).contains(true); * * // assertion will fail * assertThat(new boolean[] { true, true }).contains(false);</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 does not contain the given values. */ public SELF contains(boolean... values) { arrays.assertContains(info, actual, values); return myself; }
/** * Verifies that the actual array contains only the given values and nothing else, in any order. * <p> * Example: * <pre><code class='java'> // assertions will pass * assertThat(new boolean[] { true, false }).containsOnly(true, false); * assertThat(new boolean[] { false, true }).containsOnly(true, false); * assertThat(new boolean[] { true, true, false }).containsOnly(true, false); * * // assertions will fail * assertThat(new boolean[] { true, false }).containsOnly(false); * assertThat(new boolean[] { true }).containsOnly(true, false);</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 does not contain the given values, i.e. the actual array contains some * or none of the given values, or the actual array contains more values than the given ones. */ public SELF containsOnly(boolean... values) { arrays.assertContainsOnly(info, actual, values); return myself; }
/** * Verifies that the actual array contains the given values only once. * <p> * Examples : * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).containsOnlyOnce(true, false); * * // assertions will fail * assertThat(new boolean[] { true, false, true }).containsOnlyOnce(true); * assertThat(new boolean[] { true }).containsOnlyOnce(false); * assertThat(new boolean[] { true }).containsOnlyOnce(true, false);</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 group does not contain the given values, i.e. the actual group contains some * or none of the given values, or the actual group contains more than once these values. */ public SELF containsOnlyOnce(boolean... values) { arrays.assertContainsOnlyOnce(info, actual, values); return myself; }
/** * Verifies that the actual array does not contain the given value at the given index. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).doesNotContain(true, atIndex(1)); * assertThat(new boolean[] { true, false }).doesNotContain(false, atIndex(0)); * * // assertion will fail * assertThat(new boolean[] { true, false }).doesNotContain(false, atIndex(1)); * assertThat(new boolean[] { true, false }).doesNotContain(true, atIndex(0));</code></pre> * * @param value the value to look for. * @param index the index where the value should be stored in the actual array. * @return myself 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 value at the given index. */ public SELF doesNotContain(boolean value, Index index) { arrays.assertDoesNotContain(info, actual, value, index); return myself; }
/** {@inheritDoc} */ @Override public void isEmpty() { arrays.assertEmpty(info, actual); }
/** * Verifies that the actual group has the same size as given {@link Iterable}. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).hasSameSizeAs(Arrays.asList(1, 2)); * * // assertion will fail * assertThat(new boolean[] { true, false }).hasSameSizeAs(Arrays.asList(1, 2, 3));</code></pre> */ @Override public SELF hasSameSizeAs(Iterable<?> other) { arrays.assertHasSameSizeAs(info, actual, other); return myself; }
/** * Verifies that the actual array does not contain duplicates. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).doesNotHaveDuplicates(); * * // assertion will fail * assertThat(new boolean[] { true, true, false }).doesNotHaveDuplicates();</code></pre> * * @return {@code this} assertion object. * @throws AssertionError if the actual array is {@code null}. * @throws AssertionError if the actual array contains duplicates. */ public SELF doesNotHaveDuplicates() { arrays.assertDoesNotHaveDuplicates(info, actual); return myself; }
/** * Verifies that the actual array contains the given sequence, without any other values between them. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).containsSequence(true, false); * assertThat(new boolean[] { true, false, false, true }).containsSequence(false, true); * * // assertion will fail * assertThat(new boolean[] { true, true, false }).containsSequence(false, true);</code></pre> * * @param sequence the sequence of values to look for. * @return myself assertion object. * @throws AssertionError if the actual array is {@code null}. * @throws AssertionError if the given array is {@code null}. * @throws AssertionError if the actual array does not contain the given sequence. */ public SELF containsSequence(boolean... sequence) { arrays.assertContainsSequence(info, actual, sequence); return myself; }
/** * Verifies that the actual array contains the given subsequence (possibly with other values between them). * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).containsSubsequence(true, false); * assertThat(new boolean[] { true, false, false, true }).containsSubsequence(true, true); * * // assertion will fail * assertThat(new boolean[] { true, true, false }).containsSubsequence(false, true);</code></pre> * * @param subsequence the subsequence of values to look for. * @return myself assertion object. * @throws AssertionError if the actual array is {@code null}. * @throws AssertionError if the given array is {@code null}. * @throws AssertionError if the actual array does not contain the given subsequence. */ public SELF containsSubsequence(boolean... subsequence) { arrays.assertContainsSubsequence(info, actual, subsequence); return myself; }
/** * Verifies that the actual array ends with the given sequence of values, without any other values between them. * Similar to <code>{@link #containsSequence(boolean...)}</code>, but it also verifies that the last element in the * sequence is also last element of the actual array. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false, false, true }).endsWith(false, false, true); * * // assertion will fail * assertThat(new boolean[] { true, false, false, true }).endsWith(true, false);</code></pre> * * @param sequence the sequence of values to look for. * @return myself 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 does not end with the given sequence. */ public SELF endsWith(boolean... sequence) { arrays.assertEndsWith(info, actual, sequence); return myself; }
/** * Verifies that the actual array does not contain the given values. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, true }).doesNotContain(false); * * // assertion will fail * assertThat(new boolean[] { true, true, false }).doesNotContain(false);</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. */ public SELF doesNotContain(boolean... values) { arrays.assertDoesNotContain(info, actual, values); return myself; }
/** {@inheritDoc} */ @Override public void isEmpty() { arrays.assertEmpty(info, actual); }
/** * Verifies that the actual group has the same size as given {@link Iterable}. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).hasSameSizeAs(Arrays.asList(1, 2)); * * // assertion will fail * assertThat(new boolean[] { true, false }).hasSameSizeAs(Arrays.asList(1, 2, 3));</code></pre> */ @Override public SELF hasSameSizeAs(Iterable<?> other) { arrays.assertHasSameSizeAs(info, actual, other); return myself; }
/** * Verifies that the actual array does not contain duplicates. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).doesNotHaveDuplicates(); * * // assertion will fail * assertThat(new boolean[] { true, true, false }).doesNotHaveDuplicates();</code></pre> * * @return {@code this} assertion object. * @throws AssertionError if the actual array is {@code null}. * @throws AssertionError if the actual array contains duplicates. */ public SELF doesNotHaveDuplicates() { arrays.assertDoesNotHaveDuplicates(info, actual); return myself; }
/** * Verifies that the actual array contains the given sequence, without any other values between them. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).containsSequence(true, false); * assertThat(new boolean[] { true, false, false, true }).containsSequence(false, true); * * // assertion will fail * assertThat(new boolean[] { true, true, false }).containsSequence(false, true);</code></pre> * * @param sequence the sequence of values to look for. * @return myself assertion object. * @throws AssertionError if the actual array is {@code null}. * @throws AssertionError if the given array is {@code null}. * @throws AssertionError if the actual array does not contain the given sequence. */ public SELF containsSequence(boolean... sequence) { arrays.assertContainsSequence(info, actual, sequence); return myself; }
/** * Verifies that the actual array contains the given subsequence (possibly with other values between them). * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).containsSubsequence(true, false); * assertThat(new boolean[] { true, false, false, true }).containsSubsequence(true, true); * * // assertion will fail * assertThat(new boolean[] { true, true, false }).containsSubsequence(false, true);</code></pre> * * @param subsequence the subsequence of values to look for. * @return myself assertion object. * @throws AssertionError if the actual array is {@code null}. * @throws AssertionError if the given array is {@code null}. * @throws AssertionError if the actual array does not contain the given subsequence. */ public SELF containsSubsequence(boolean... subsequence) { arrays.assertContainsSubsequence(info, actual, subsequence); return myself; }
/** * Verifies that the actual array ends with the given sequence of values, without any other values between them. * Similar to <code>{@link #containsSequence(boolean...)}</code>, but it also verifies that the last element in the * sequence is also last element of the actual array. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false, false, true }).endsWith(false, false, true); * * // assertion will fail * assertThat(new boolean[] { true, false, false, true }).endsWith(true, false);</code></pre> * * @param sequence the sequence of values to look for. * @return myself 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 does not end with the given sequence. */ public SELF endsWith(boolean... sequence) { arrays.assertEndsWith(info, actual, sequence); return myself; }
/** * Verifies that the actual array does not contain the given values. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, true }).doesNotContain(false); * * // assertion will fail * assertThat(new boolean[] { true, true, false }).doesNotContain(false);</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. */ public SELF doesNotContain(boolean... values) { arrays.assertDoesNotContain(info, actual, values); return myself; }
/** * Verifies that the actual array contains the given value at the given index. * <p> * Example: * <pre><code class='java'> // assertion will pass * assertThat(new boolean[] { true, false }).contains(true, atIndex(O)); * assertThat(new boolean[] { true, false }).contains(false, atIndex(1)); * * // assertion will fail * assertThat(new boolean[] { true, false }).contains(false, atIndex(0)); * assertThat(new boolean[] { true, false }).contains(true, atIndex(1));</code></pre> * * @param value the value to look for. * @param index the index where the value should be stored in the actual array. * @return myself assertion object. * @throws AssertionError if the actual array is {@code null} or empty. * @throws NullPointerException if the given {@code Index} is {@code null}. * @throws IndexOutOfBoundsException if the value of the given {@code Index} is equal to or greater than the size of * the actual array. * @throws AssertionError if the actual array does not contain the given value at the given index. */ public SELF contains(boolean value, Index index) { arrays.assertContains(info, actual, value, index); return myself; }
/** {@inheritDoc} */ @Override public void isEmpty() { arrays.assertEmpty(info, actual); }