How to use toPrimitiveBooleanArray method of org.assertj.core.api.AbstractBooleanArrayAssert class

Best Assertj code snippet using org.assertj.core.api.AbstractBooleanArrayAssert.toPrimitiveBooleanArray

Source:AbstractBooleanArrayAssert.java

...217   * @since 3.19.0218   */219  public SELF contains(Boolean[] values) {220    requireNonNullParameter(values, "values");221    arrays.assertContains(info, actual, toPrimitiveBooleanArray(values));222    return myself;223  }224  /**225   * Verifies that the actual array contains only the given values and nothing else, in any order.226   * <p>227   * Example:228   * <pre><code class='java'> // assertions will pass229   * assertThat(new boolean[] { true, false }).containsOnly(true, false);230   * assertThat(new boolean[] { false, true }).containsOnly(true, false);231   * assertThat(new boolean[] { true, true, false }).containsOnly(true, false);232   *233   * // assertions will fail234   * assertThat(new boolean[] { true, false }).containsOnly(false);235   * assertThat(new boolean[] { true }).containsOnly(true, false);</code></pre>236   *237   * @param values the given values.238   * @return {@code this} assertion object.239   * @throws NullPointerException if the given argument is {@code null}.240   * @throws IllegalArgumentException if the given argument is an empty array.241   * @throws AssertionError if the actual array is {@code null}.242   * @throws AssertionError if the actual array does not contain the given values, i.e. the actual array contains some243   *           or none of the given values, or the actual array contains more values than the given ones.244   */245  public SELF containsOnly(boolean... values) {246    arrays.assertContainsOnly(info, actual, values);247    return myself;248  }249  /**250   * Verifies that the actual array contains only the values of the given array and nothing else, in any order.251   * <p>252   * Example:253   * <pre><code class='java'> // assertions will pass254   * assertThat(new boolean[] { true, false }).containsOnly(new Boolean[] { true, false });255   * assertThat(new boolean[] { false, true }).containsOnly(new Boolean[] { true, false });256   * assertThat(new boolean[] { true, true, false }).containsOnly(new Boolean[] { true, false });257   *258   * // assertions will fail259   * assertThat(new boolean[] { true, false }).containsOnly(new Boolean[] { false });260   * assertThat(new boolean[] { true }).containsOnly(new Boolean[] { true, false });</code></pre>261   *262   * @param values the given values.263   * @return {@code this} assertion object.264   * @throws NullPointerException if the given argument is {@code null}.265   * @throws IllegalArgumentException if the given argument is an empty array.266   * @throws AssertionError if the actual array is {@code null}.267   * @throws AssertionError if the actual array does not contain the given values, i.e. the actual array contains some268   *           or none of the given values, or the actual array contains more values than the given ones.269   */270  public SELF containsOnly(Boolean[] values) {271    requireNonNullParameter(values, "values");272    arrays.assertContainsOnly(info, actual, toPrimitiveBooleanArray(values));273    return myself;274  }275  /**276   * Verifies that the actual array contains the given values only once.277   * <p>278   * Examples :279   * <pre><code class='java'> // assertion will pass280   * assertThat(new boolean[] { true, false }).containsOnlyOnce(true, false);281   *282   * // assertions will fail283   * assertThat(new boolean[] { true, false, true }).containsOnlyOnce(true);284   * assertThat(new boolean[] { true }).containsOnlyOnce(false);285   * assertThat(new boolean[] { true }).containsOnlyOnce(true, false);</code></pre>286   *287   * @param values the given values.288   * @return {@code this} assertion object.289   * @throws NullPointerException if the given argument is {@code null}.290   * @throws IllegalArgumentException if the given argument is an empty array.291   * @throws AssertionError if the actual array is {@code null}.292   * @throws AssertionError if the actual group does not contain the given values, i.e. the actual group contains some293   *           or none of the given values, or the actual group contains more than once these values.294   */295  public SELF containsOnlyOnce(boolean... values) {296    arrays.assertContainsOnlyOnce(info, actual, values);297    return myself;298  }299  /**300   * Verifies that the actual array contains the values of the given array only once.301   * <p>302   * Examples :303   * <pre><code class='java'> // assertion will pass304   * assertThat(new boolean[] { true, false }).containsOnlyOnce(new Boolean[] { true, false });305   *306   * // assertions will fail307   * assertThat(new boolean[] { true, false, true }).containsOnlyOnce(new Boolean[] { true });308   * assertThat(new boolean[] { true }).containsOnlyOnce(new Boolean[] { false });309   * assertThat(new boolean[] { true }).containsOnlyOnce(new Boolean[] { true, false });</code></pre>310   *311   * @param values the given values.312   * @return {@code this} assertion object.313   * @throws NullPointerException if the given argument is {@code null}.314   * @throws IllegalArgumentException if the given argument is an empty array.315   * @throws AssertionError if the actual array is {@code null}.316   * @throws AssertionError if the actual group does not contain the given values, i.e. the actual group contains some317   *           or none of the given values, or the actual group contains more than once these values.318   */319  public SELF containsOnlyOnce(Boolean[] values) {320    requireNonNullParameter(values, "values");321    arrays.assertContainsOnlyOnce(info, actual, toPrimitiveBooleanArray(values));322    return myself;323  }324  /**325   * Verifies that the actual array contains the given sequence, without any other values between them.326   * <p>327   * Example:328   * <pre><code class='java'> // assertion will pass329   * assertThat(new boolean[] { true, false }).containsSequence(true, false);330   * assertThat(new boolean[] { true, false, false, true }).containsSequence(false, true);331   *332   * // assertion will fail333   * assertThat(new boolean[] { true, true, false }).containsSequence(false, true);</code></pre>334   *335   * @param sequence the sequence of values to look for.336   * @return myself assertion object.337   * @throws AssertionError if the actual array is {@code null}.338   * @throws AssertionError if the given array is {@code null}.339   * @throws AssertionError if the actual array does not contain the given sequence.340   */341  public SELF containsSequence(boolean... sequence) {342    arrays.assertContainsSequence(info, actual, sequence);343    return myself;344  }345  /**346   * Verifies that the actual array contains the given sequence, without any other values between them.347   * <p>348   * Example:349   * <pre><code class='java'> // assertion will pass350   * assertThat(new boolean[] { true, false }).containsSequence(new Boolean[] { true, false });351   * assertThat(new boolean[] { true, false, false, true }).containsSequence(new Boolean[] { false, true });352   *353   * // assertion will fail354   * assertThat(new boolean[] { true, true, false }).containsSequence(new Boolean[] { false, true });</code></pre>355   *356   * @param sequence the sequence of values to look for.357   * @return myself assertion object.358   * @throws AssertionError if the actual array is {@code null}.359   * @throws AssertionError if the given array is {@code null}.360   * @throws AssertionError if the actual array does not contain the given sequence.361   */362  public SELF containsSequence(Boolean[] sequence) {363    requireNonNullParameter(sequence, "sequence");364    arrays.assertContainsSequence(info, actual, toPrimitiveBooleanArray(sequence));365    return myself;366  }367  /**368   * Verifies that the actual array contains the given subsequence (possibly with other values between them).369   * <p>370   * Example:371   * <pre><code class='java'> // assertion will pass372   * assertThat(new boolean[] { true, false }).containsSubsequence(true, false);373   * assertThat(new boolean[] { true, false, false, true }).containsSubsequence(true, true);374   *375   * // assertion will fail376   * assertThat(new boolean[] { true, true, false }).containsSubsequence(false, true);</code></pre>377   *378   * @param subsequence the subsequence of values to look for.379   * @return myself assertion object.380   * @throws AssertionError if the actual array is {@code null}.381   * @throws AssertionError if the given array is {@code null}.382   * @throws AssertionError if the actual array does not contain the given subsequence.383   */384  public SELF containsSubsequence(boolean... subsequence) {385    arrays.assertContainsSubsequence(info, actual, subsequence);386    return myself;387  }388  /**389   * Verifies that the actual array contains the given subsequence (possibly with other values between them).390   * <p>391   * Example:392   * <pre><code class='java'> // assertion will pass393   * assertThat(new boolean[] { true, false }).containsSubsequence(new Boolean[] { true, false });394   * assertThat(new boolean[] { true, false, false, true }).containsSubsequence(new Boolean[] { true, true });395   *396   * // assertion will fail397   * assertThat(new boolean[] { true, true, false }).containsSubsequence(new Boolean[] { false, true });</code></pre>398   *399   * @param subsequence the subsequence of values to look for.400   * @return myself assertion object.401   * @throws AssertionError if the actual array is {@code null}.402   * @throws AssertionError if the given array is {@code null}.403   * @throws AssertionError if the actual array does not contain the given subsequence.404   */405  public SELF containsSubsequence(Boolean[] subsequence) {406    requireNonNullParameter(subsequence, "subsequence");407    arrays.assertContainsSubsequence(info, actual, toPrimitiveBooleanArray(subsequence));408    return myself;409  }410  /**411   * Verifies that the actual array contains the given value at the given index.412   * <p>413   * Example:414   * <pre><code class='java'> // assertion will pass415   * assertThat(new boolean[] { true, false }).contains(true, atIndex(O));416   * assertThat(new boolean[] { true, false }).contains(false, atIndex(1));417   *418   * // assertion will fail419   * assertThat(new boolean[] { true, false }).contains(false, atIndex(0));420   * assertThat(new boolean[] { true, false }).contains(true, atIndex(1));</code></pre>421   *422   * @param value the value to look for.423   * @param index the index where the value should be stored in the actual array.424   * @return myself assertion object.425   * @throws AssertionError if the actual array is {@code null} or empty.426   * @throws NullPointerException if the given {@code Index} is {@code null}.427   * @throws IndexOutOfBoundsException if the value of the given {@code Index} is equal to or greater than the size of428   *           the actual array.429   * @throws AssertionError if the actual array does not contain the given value at the given index.430   */431  public SELF contains(boolean value, Index index) {432    arrays.assertContains(info, actual, value, index);433    return myself;434  }435  /**436   * Verifies that the actual array does not contain the given values.437   * <p>438   * Example:439   * <pre><code class='java'> // assertion will pass440   * assertThat(new boolean[] { true, true }).doesNotContain(false);441   *442   * // assertion will fail443   * assertThat(new boolean[] { true, true, false }).doesNotContain(false);</code></pre>444   *445   * @param values the given values.446   * @return {@code this} assertion object.447   * @throws NullPointerException if the given argument is {@code null}.448   * @throws IllegalArgumentException if the given argument is an empty array.449   * @throws AssertionError if the actual array is {@code null}.450   * @throws AssertionError if the actual array contains any of the given values.451   */452  public SELF doesNotContain(boolean... values) {453    arrays.assertDoesNotContain(info, actual, values);454    return myself;455  }456  /**457   * Verifies that the actual array does not contain the values of the given array.458   * <p>459   * Example:460   * <pre><code class='java'> // assertion will pass461   * assertThat(new boolean[] { true, true }).doesNotContain(new Boolean[] { false });462   *463   * // assertion will fail464   * assertThat(new boolean[] { true, true, false }).doesNotContain(new Boolean[] { false });</code></pre>465   *466   * @param values the given values.467   * @return {@code this} assertion object.468   * @throws NullPointerException if the given argument is {@code null}.469   * @throws IllegalArgumentException if the given argument is an empty array.470   * @throws AssertionError if the actual array is {@code null}.471   * @throws AssertionError if the actual array contains any of the given values.472   */473  public SELF doesNotContain(Boolean[] values) {474    requireNonNullParameter(values, "values");475    arrays.assertDoesNotContain(info, actual, toPrimitiveBooleanArray(values));476    return myself;477  }478  /**479   * Verifies that the actual array does not contain the given value at the given index.480   * <p>481   * Example:482   * <pre><code class='java'> // assertion will pass483   * assertThat(new boolean[] { true, false }).doesNotContain(true, atIndex(1));484   * assertThat(new boolean[] { true, false }).doesNotContain(false, atIndex(0));485   *486   * // assertion will fail487   * assertThat(new boolean[] { true, false }).doesNotContain(false, atIndex(1));488   * assertThat(new boolean[] { true, false }).doesNotContain(true, atIndex(0));</code></pre>489   *490   * @param value the value to look for.491   * @param index the index where the value should be stored in the actual array.492   * @return myself assertion object.493   * @throws AssertionError if the actual array is {@code null}.494   * @throws NullPointerException if the given {@code Index} is {@code null}.495   * @throws AssertionError if the actual array contains the given value at the given index.496   */497  public SELF doesNotContain(boolean value, Index index) {498    arrays.assertDoesNotContain(info, actual, value, index);499    return myself;500  }501  /**502   * Verifies that the actual array does not contain duplicates.503   * <p>504   * Example:505   * <pre><code class='java'> // assertion will pass506   * assertThat(new boolean[] { true, false }).doesNotHaveDuplicates();507   *508   * // assertion will fail509   * assertThat(new boolean[] { true, true, false }).doesNotHaveDuplicates();</code></pre>510   *511   * @return {@code this} assertion object.512   * @throws AssertionError if the actual array is {@code null}.513   * @throws AssertionError if the actual array contains duplicates.514   */515  public SELF doesNotHaveDuplicates() {516    arrays.assertDoesNotHaveDuplicates(info, actual);517    return myself;518  }519  /**520   * Verifies that the actual array starts with the given sequence of values, without any other values between them.521   * Similar to <code>{@link #containsSequence(boolean...)}</code>, but it also verifies that the first element in the522   * sequence is also first element of the actual array.523   * <p>524   * Example:525   * <pre><code class='java'> // assertion will pass526   * assertThat(new boolean[] { true, false, false, true }).startsWith(true, false);527   *528   * // assertion will fail529   * assertThat(new boolean[] { true, false, false, true }).startsWith(false, false, true);</code></pre>530   *531   * @param sequence the sequence of values to look for.532   * @return myself assertion object.533   * @throws NullPointerException if the given argument is {@code null}.534   * @throws IllegalArgumentException if the given argument is an empty array.535   * @throws AssertionError if the actual array is {@code null}.536   * @throws AssertionError if the actual array does not start with the given sequence.537   */538  public SELF startsWith(boolean... sequence) {539    arrays.assertStartsWith(info, actual, sequence);540    return myself;541  }542  /**543   * Verifies that the actual array starts with the given sequence of values, without any other values between them.544   * Similar to <code>{@link #containsSequence(boolean...)}</code>, but it also verifies that the first element in the545   * sequence is also first element of the actual array.546   * <p>547   * Example:548   * <pre><code class='java'> // assertion will pass549   * assertThat(new boolean[] { true, false, false, true }).startsWith(new Boolean[] { true, false });550   *551   * // assertion will fail552   * assertThat(new boolean[] { true, false, false, true }).startsWith(new Boolean[] { false, false, true });</code></pre>553   *554   * @param sequence the sequence of values to look for.555   * @return myself assertion object.556   * @throws NullPointerException if the given argument is {@code null}.557   * @throws IllegalArgumentException if the given argument is an empty array.558   * @throws AssertionError if the actual array is {@code null}.559   * @throws AssertionError if the actual array does not start with the given sequence.560   */561  public SELF startsWith(Boolean[] sequence) {562    requireNonNullParameter(sequence, "sequence");563    arrays.assertStartsWith(info, actual, toPrimitiveBooleanArray(sequence));564    return myself;565  }566  /**567   * Verifies that the actual array ends with the given sequence of values, without any other values between them.568   * Similar to <code>{@link #containsSequence(boolean...)}</code>, but it also verifies that the last element in the569   * sequence is also last element of the actual array.570   * <p>571   * Example:572   * <pre><code class='java'> // assertion will pass573   * assertThat(new boolean[] { true, false, false, true }).endsWith(false, false, true);574   *575   * // assertion will fail576   * assertThat(new boolean[] { true, false, false, true }).endsWith(true, false);</code></pre>577   *578   * @param sequence the sequence of values to look for.579   * @return myself assertion object.580   * @throws NullPointerException if the given argument is {@code null}.581   * @throws IllegalArgumentException if the given argument is an empty array.582   * @throws AssertionError if the actual array is {@code null}.583   * @throws AssertionError if the actual array does not end with the given sequence.584   */585  public SELF endsWith(boolean... sequence) {586    arrays.assertEndsWith(info, actual, sequence);587    return myself;588  }589  /**590   * Verifies that the actual array ends with the given sequence of values, without any other values between them.591   * Similar to <code>{@link #containsSequence(boolean...)}</code>, but it also verifies that the last element in the592   * sequence is also last element of the actual array.593   * <p>594   * Example:595   * <pre><code class='java'> // assertion will pass596   * assertThat(new boolean[] { true, false, false, true }).endsWith(new Boolean[] { false, false, true });597   *598   * // assertion will fail599   * assertThat(new boolean[] { true, false, false, true }).endsWith(new Boolean[] { true, false });</code></pre>600   *601   * @param sequence the sequence of values to look for.602   * @return myself assertion object.603   * @throws NullPointerException if the given argument is {@code null}.604   * @throws IllegalArgumentException if the given argument is an empty array.605   * @throws AssertionError if the actual array is {@code null}.606   * @throws AssertionError if the actual array does not end with the given sequence.607   */608  public SELF endsWith(Boolean[] sequence) {609    requireNonNullParameter(sequence, "sequence");610    arrays.assertEndsWith(info, actual, toPrimitiveBooleanArray(sequence));611    return myself;612  }613  /** {@inheritDoc} */614  @Override615  public SELF isSorted() {616    arrays.assertIsSorted(info, actual);617    return myself;618  }619  /** {@inheritDoc} */620  @Override621  public SELF isSortedAccordingTo(Comparator<? super Boolean> comparator) {622    arrays.assertIsSortedAccordingToComparator(info, actual, comparator);623    return myself;624  }625  /**626   * Do not use this method.627   *628   * @deprecated Custom element Comparator is not supported for Boolean array comparison.629   * @throws UnsupportedOperationException if this method is called.630   */631  @Override632  @Deprecated633  public final SELF usingElementComparator(Comparator<? super Boolean> customComparator) {634    throw new UnsupportedOperationException("custom element Comparator is not supported for Boolean array comparison");635  }636  /**637   * Do not use this method.638   *639   * @deprecated Custom element Comparator is not supported for Boolean array comparison.640   * @throws UnsupportedOperationException if this method is called.641   */642  @Override643  @Deprecated644  public final SELF usingDefaultElementComparator() {645    throw new UnsupportedOperationException("custom element Comparator is not supported for Boolean array comparison");646  }647  /**648   * Verifies that the actual group contains only the given values and nothing else, <b>in order</b>.649   * <p>650   * Example :651   * <pre><code class='java'> // assertion will pass652   * assertThat(new boolean[] { true, false, true }).containsExactly(true, false, true);653   *654   * // assertion will fail as actual and expected order differ655   * assertThat(new boolean[] { true, false, true }).containsExactly(false, true, true);</code></pre>656   *657   * @param values the given values.658   * @return {@code this} assertion object.659   * @throws NullPointerException if the given argument is {@code null}.660   * @throws AssertionError if the actual group is {@code null}.661   * @throws AssertionError if the actual group does not contain the given values with same order, i.e. the actual group662   *           contains some or none of the given values, or the actual group contains more values than the given ones663   *           or values are the same but the order is not.664   */665  public SELF containsExactly(boolean... values) {666    arrays.assertContainsExactly(info, actual, values);667    return myself;668  }669  /**670   * Verifies that the actual group contains only the values of the given array and nothing else, <b>in order</b>.671   * <p>672   * Example :673   * <pre><code class='java'> // assertion will pass674   * assertThat(new boolean[] { true, false, true }).containsExactly(new Boolean[] { true, false, true });675   *676   * // assertion will fail as actual and expected order differ677   * assertThat(new boolean[] { true, false, true }).containsExactly(new Boolean[] { false, true, true });</code></pre>678   *679   * @param values the given values.680   * @return {@code this} assertion object.681   * @throws NullPointerException if the given argument is {@code null}.682   * @throws AssertionError if the actual group is {@code null}.683   * @throws AssertionError if the actual group does not contain the given values with same order, i.e. the actual group684   *           contains some or none of the given values, or the actual group contains more values than the given ones685   *           or values are the same but the order is not.686   * @since 3.19.0687   */688  public SELF containsExactly(Boolean[] values) {689    requireNonNullParameter(values, "values");690    arrays.assertContainsExactly(info, actual, toPrimitiveBooleanArray(values));691    return myself;692  }693  /**694   * Verifies that the actual group contains exactly the given values and nothing else, <b>in any order</b>.<br>695   * <p>696   * Example :697   * <pre><code class='java'> // assertions will pass698   * assertThat(new boolean[] { true, false }).containsExactlyInAnyOrder(false, true);699   * assertThat(new boolean[] { true, false, true }).containsExactlyInAnyOrder(true, true, false);700   *701   * // assertions will fail702   * assertThat(new boolean[] { true, false }).containsExactlyInAnyOrder(true);703   * assertThat(new boolean[] { true }).containsExactlyInAnyOrder(false, true);704   * assertThat(new boolean[] { true, true, false }).containsExactlyInAnyOrder(false, true);</code></pre>705   *706   * @param values the given values.707   * @return {@code this} assertion object.708   * @throws NullPointerException if the given argument is {@code null}.709   * @throws AssertionError if the actual group is {@code null}.710   * @throws AssertionError if the actual group does not contain the given values, i.e. the actual group711   *           contains some or none of the given values, or the actual group contains more values than the given ones.712   * @since 2.6.0 / 3.6.0713   */714  public SELF containsExactlyInAnyOrder(boolean... values) {715    arrays.assertContainsExactlyInAnyOrder(info, actual, values);716    return myself;717  }718  /**719   * Verifies that the actual group contains exactly the values of the given array and nothing else, <b>in any order</b>.<br>720   * <p>721   * Example :722   * <pre><code class='java'> // assertions will pass723   * assertThat(new boolean[] { true, false }).containsExactlyInAnyOrder(new Boolean[] { false, true });724   * assertThat(new boolean[] { true, false, true }).containsExactlyInAnyOrder(new Boolean[] { true, true, false });725   *726   * // assertions will fail727   * assertThat(new boolean[] { true, false }).containsExactlyInAnyOrder(new Boolean[] { true });728   * assertThat(new boolean[] { true }).containsExactlyInAnyOrder(new Boolean[] { false, true });729   * assertThat(new boolean[] { true, true, false }).containsExactlyInAnyOrder(new Boolean[] { false, true });</code></pre>730   *731   * @param values the given values.732   * @return {@code this} assertion object.733   * @throws NullPointerException if the given argument is {@code null}.734   * @throws AssertionError if the actual group is {@code null}.735   * @throws AssertionError if the actual group does not contain the given values, i.e. the actual group736   *           contains some or none of the given values, or the actual group contains more values than the given ones.737   * @since 3.19.0738   */739  public SELF containsExactlyInAnyOrder(Boolean[] values) {740    requireNonNullParameter(values, "values");741    arrays.assertContainsExactlyInAnyOrder(info, actual, toPrimitiveBooleanArray(values));742    return myself;743  }744  /**745   * Verifies that the actual array contains at least one of the given values.746   * <p>747   * Example :748   * <pre><code class='java'> boolean[] soTrue = { true, true, true };749   *750   * // assertions will pass751   * assertThat(soTrue).containsAnyOf(true)752   *                   .containsAnyOf(false, false, false, true);753   *754   * // assertions will fail755   * assertThat(oneTwoThree).containsAnyOf(false);756   * assertThat(oneTwoThree).containsAnyOf(false, false, false);</code></pre>757   *758   * @param values the values whose at least one which is expected to be in the array under test.759   * @return {@code this} assertion object.760   * @throws NullPointerException if the array of values is {@code null}.761   * @throws IllegalArgumentException if the array of values is empty and the array under test is not empty.762   * @throws AssertionError if the array under test is {@code null}.763   * @throws AssertionError if the array under test does not contain any of the given {@code values}.764   * @since 2.9.0 / 3.9.0765   */766  public SELF containsAnyOf(boolean... values) {767    arrays.assertContainsAnyOf(info, actual, values);768    return myself;769  }770  /**771   * Verifies that the actual array contains at least one of the values of the given array.772   * <p>773   * Example :774   * <pre><code class='java'> boolean[] soTrue = { true, true, true };775   *776   * // assertions will pass777   * assertThat(soTrue).containsAnyOf(new Boolean[] { true })778   *                   .containsAnyOf(new Boolean[] { false, false, false, true });779   *780   * // assertions will fail781   * assertThat(oneTwoThree).containsAnyOf(new Boolean[] { false });782   * assertThat(oneTwoThree).containsAnyOf(new Boolean[] { false, false, false });</code></pre>783   *784   * @param values the values whose at least one which is expected to be in the array under test.785   * @return {@code this} assertion object.786   * @throws NullPointerException if the array of values is {@code null}.787   * @throws IllegalArgumentException if the array of values is empty and the array under test is not empty.788   * @throws AssertionError if the array under test is {@code null}.789   * @throws AssertionError if the array under test does not contain any of the given {@code values}.790   * @since 3.19.0791   */792  public SELF containsAnyOf(Boolean[] values) {793    requireNonNullParameter(values, "values");794    arrays.assertContainsAnyOf(info, actual, toPrimitiveBooleanArray(values));795    return myself;796  }797  private static boolean[] toPrimitiveBooleanArray(Boolean[] values) {798    boolean[] booleans = new boolean[values.length];799    range(0, values.length).forEach(i -> booleans[i] = values[i]);800    return booleans;801  }802}...

toPrimitiveBooleanArray

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2public class BooleanArrayToBooleanArray {3    public static void main(String[] args) {4        boolean[] booleanArray = {true, false, true};5        Boolean[] booleanArrayToBooleanArray = assertThat(booleanArray).toPrimitiveBooleanArray();6        System.out.println("booleanArrayToBooleanArray = " + booleanArrayToBooleanArray);7    }8}9import static org.assertj.core.api.Assertions.assertThat;10public class BooleanArrayToBooleanArray {11    public static void main(String[] args) {12        boolean[] booleanArray = {true, false, true};13        Boolean[] booleanArrayToBooleanArray = assertThat(booleanArray).toPrimitiveBooleanArray();14        System.out.println("booleanArrayToBooleanArray = " + booleanArrayToBooleanArray);15    }16}17import static org.assertj.core.api.Assertions.assertThat;18public class BooleanArrayToBooleanArray {19    public static void main(String[] args) {20        boolean[] booleanArray = {true, false, true};21        Boolean[] booleanArrayToBooleanArray = assertThat(booleanArray).toPrimitiveBooleanArray();22        System.out.println("booleanArrayToBooleanArray = " + booleanArrayToBooleanArray);23    }24}25import static org.assertj.core.api.Assertions.assertThat;26public class BooleanArrayToBooleanArray {27    public static void main(String[] args) {28        boolean[] booleanArray = {true, false, true};29        Boolean[] booleanArrayToBooleanArray = assertThat(booleanArray).toPrimitiveBooleanArray();30        System.out.println("booleanArrayToBooleanArray = " + booleanArrayToBooleanArray);31    }32}

toPrimitiveBooleanArray

Using AI Code Generation

1import org.assertj.core.api.AbstractBooleanArrayAssert;2public class BooleanArrayAssert_primitiveBooleanArray_Test {3  public static void main(String[] args) {4    AbstractBooleanArrayAssert<?> assertions = org.assertj.core.api.Assertions.assertThat(new boolean[] {true, false});5    boolean[] primitiveBooleanArray = assertions.primitiveBooleanArray();6    System.out.println(primitiveBooleanArray);7  }8}9boolean[] org.assertj.core.api.AbstractBooleanArrayAssert.toPrimitiveBooleanArray()

toPrimitiveBooleanArray

Using AI Code Generation

1import org.assertj.core.api.Assertions;2import org.junit.Test;3public class BooleanArrayAssert_toPrimitiveBooleanArray_Test {4  public void test_toPrimitiveBooleanArray() {5    boolean[] booleans = Assertions.assertThat(new Boolean[] { true, false, true }).toPrimitiveBooleanArray();6    Assertions.assertThat(booleans).containsExactly(true, false, true);7  }8}9boolean[] booleans = Assertions.assertThat(new Boolean[] { true, false, true }).toPrimitiveBooleanArray();10boolean[] booleans = Assertions.assertThat(new Boolean[] { true, false, true }).toPrimitiveBooleanArray();11boolean[] booleans = Assertions.assertThat(new Boolean[] { true, false, true }).toPrimitiveBooleanArray();

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.