Add tests for assertContains for the generic Arrays class

src/main/java/org/assertj/core/internal/Arrays.java

@@ -155,7 +155,8 @@ public void assertHasSameSizeAs(AssertionInfo info, Object array, Object other)
     hasSameSizeAsCheck(info, array, other, sizeOf(array));
   }
 
-  void assertContains(AssertionInfo info, Failures failures, Object actual, Object values) {
+  @VisibleForTesting
+  public void assertContains(AssertionInfo info, Failures failures, Object actual, Object values) {
     if (commonChecks(info, actual, values)) return;
     Set<Object> notFound = new LinkedHashSet<>();
     int valueCount = sizeOf(values);
@@ -295,7 +296,7 @@ void assertContainsSequence(AssertionInfo info, Failures failures, Object actual
   }
 
   void assertDoesNotContainSequence(AssertionInfo info, Failures failures, Object actual, Object sequence) {
-    if(commonChecks(info, actual, sequence)) return;
+    if (commonChecks(info, actual, sequence)) return;
 
     // look for given sequence, stop check when there are not enough elements remaining in actual to contain sequence
     int lastIndexWhereSequenceCanBeFound = sizeOf(actual) - sizeOf(sequence);
@@ -346,7 +347,7 @@ void assertContainsSubsequence(AssertionInfo info, Failures failures, Object act
     if (subsequenceIndex < sizeOfSubsequence)
       throw failures.failure(info, shouldContainSubsequence(actual, subsequence, comparisonStrategy));
   }
- 
+
   void assertHasOnlyElementsOfTypes(AssertionInfo info, Failures failures, Object actual, Class<?>[] expectedTypes) {
     checkIsNotNull(expectedTypes);
     assertNotNull(info, actual);
@@ -359,7 +360,7 @@ void assertHasOnlyElementsOfTypes(AssertionInfo info, Failures failures, Object
       }
       if (!matching) nonMatchingElements.add(value);
     }
-    
+
     if (!nonMatchingElements.isEmpty()) {
       throw failures.failure(info, shouldOnlyHaveElementsOfTypes(actual, expectedTypes, nonMatchingElements));
     }
@@ -389,7 +390,8 @@ void assertDoesNotContainSubsequence(AssertionInfo info, Failures failures, Obje
       actualIndex++;
 
       if (subsequenceIndex == sizeOfSubsequence) {
-        throw failures.failure(info, shouldNotContainSubsequence(actual, subsequence, comparisonStrategy, subsequenceStartIndex));
+        throw failures.failure(info, shouldNotContainSubsequence(actual, subsequence, comparisonStrategy,
+                                                                 subsequenceStartIndex));
       }
     }
   }

src/main/java/org/assertj/core/internal/BooleanArrays.java

@@ -195,13 +195,13 @@ public void assertContainsOnly(AssertionInfo info, boolean[] actual, boolean[] v
   }
 
   public void assertContainsExactly(AssertionInfo info, boolean[] actual, boolean[] values) {
-	arrays.assertContainsExactly(info, failures, actual, values);
+    arrays.assertContainsExactly(info, failures, actual, values);
   }
 
   public void assertContainsExactlyInAnyOrder(AssertionInfo info, boolean[] actual, boolean[] values) {
     arrays.assertContainsExactlyInAnyOrder(info, failures, actual, values);
   }
-  
+
   /**
    * Asserts that the given array contains only once the given values.
    * 
@@ -329,7 +329,7 @@ public void assertIsSorted(AssertionInfo info, boolean[] actual) {
    * @param comparator the {@link Comparator} used to compare array elements
    */
   public void assertIsSortedAccordingToComparator(AssertionInfo info, boolean[] actual,
-      Comparator<? super Boolean> comparator) {
+                                                  Comparator<? super Boolean> comparator) {
     Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
   }
 

src/main/java/org/assertj/core/internal/ByteArrays.java

@@ -19,7 +19,6 @@
 import org.assertj.core.data.Index;
 import org.assertj.core.util.VisibleForTesting;
 
-
 /**
  * Reusable assertions for arrays of {@code byte}s.
  * 
@@ -239,7 +238,7 @@ public void assertContainsOnly(AssertionInfo info, byte[] actual, int[] values)
   }
 
   public void assertContainsExactly(AssertionInfo info, byte[] actual, byte[] values) {
-	arrays.assertContainsExactly(info, failures, actual, values);
+    arrays.assertContainsExactly(info, failures, actual, values);
   }
 
   public void assertContainsExactly(AssertionInfo info, byte[] actual, int[] values) {
@@ -466,7 +465,8 @@ public void assertIsSorted(AssertionInfo info, byte[] actual) {
    * @param actual the given array.
    * @param comparator the {@link Comparator} used to compare array elements
    */
-  public void assertIsSortedAccordingToComparator(AssertionInfo info, byte[] actual, Comparator<? super Byte> comparator) {
+  public void assertIsSortedAccordingToComparator(AssertionInfo info, byte[] actual,
+                                                  Comparator<? super Byte> comparator) {
     Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
   }
 

src/main/java/org/assertj/core/internal/CharArrays.java

@@ -204,13 +204,13 @@ public void assertContainsOnly(AssertionInfo info, char[] actual, char[] values)
   }
 
   public void assertContainsExactly(AssertionInfo info, char[] actual, char[] values) {
-	arrays.assertContainsExactly(info, failures, actual, values);
+    arrays.assertContainsExactly(info, failures, actual, values);
   }
 
   public void assertContainsExactlyInAnyOrder(AssertionInfo info, char[] actual, char[] values) {
     arrays.assertContainsExactlyInAnyOrder(info, failures, actual, values);
   }
-  
+
   /**
    * Asserts that the given array contains only once the given values.
    * 
@@ -338,7 +338,7 @@ public void assertIsSorted(AssertionInfo info, char[] actual) {
    * @param comparator the {@link Comparator} used to compare array elements
    */
   public void assertIsSortedAccordingToComparator(AssertionInfo info, char[] actual,
-      Comparator<? super Character> comparator) {
+                                                  Comparator<? super Character> comparator) {
     Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
   }
 

src/main/java/org/assertj/core/internal/FloatArrays.java

@@ -19,7 +19,6 @@
 import org.assertj.core.data.Index;
 import org.assertj.core.util.VisibleForTesting;
 
-
 /**
  * Reusable assertions for arrays of {@code float}s.
  * 
@@ -193,13 +192,13 @@ public void assertContainsOnly(AssertionInfo info, float[] actual, float[] value
   }
 
   public void assertContainsExactly(AssertionInfo info, float[] actual, float[] values) {
-	arrays.assertContainsExactly(info, failures, actual, values);
+    arrays.assertContainsExactly(info, failures, actual, values);
   }
 
   public void assertContainsExactlyInAnyOrder(AssertionInfo info, float[] actual, float[] values) {
     arrays.assertContainsExactlyInAnyOrder(info, failures, actual, values);
   }
-  
+
   /**
    * Asserts that the given array contains only once the given values.
    * 
@@ -321,7 +320,8 @@ public void assertIsSorted(AssertionInfo info, float[] actual) {
    * @param actual the given array.
    * @param comparator the {@link Comparator} used to compare array elements
    */
-  public void assertIsSortedAccordingToComparator(AssertionInfo info, float[] actual, Comparator<? super Float> comparator) {
+  public void assertIsSortedAccordingToComparator(AssertionInfo info, float[] actual,
+                                                  Comparator<? super Float> comparator) {
     Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
   }
 

src/main/java/org/assertj/core/internal/LongArrays.java

@@ -204,13 +204,13 @@ public void assertContainsOnly(AssertionInfo info, long[] actual, long[] values)
   }
 
   public void assertContainsExactly(AssertionInfo info, long[] actual, long[] values) {
-	arrays.assertContainsExactly(info, failures, actual, values);
+    arrays.assertContainsExactly(info, failures, actual, values);
   }
 
   public void assertContainsExactlyInAnyOrder(AssertionInfo info, long[] actual, long[] values) {
     arrays.assertContainsExactlyInAnyOrder(info, failures, actual, values);
   }
-  
+
   /**
    * Asserts that the given array contains only once the given values.
    * 
@@ -337,7 +337,8 @@ public void assertIsSorted(AssertionInfo info, long[] actual) {
    * @param actual the given array.
    * @param comparator the {@link Comparator} used to compare array elements
    */
-  public void assertIsSortedAccordingToComparator(AssertionInfo info, long[] actual, Comparator<? super Long> comparator) {
+  public void assertIsSortedAccordingToComparator(AssertionInfo info, long[] actual,
+                                                  Comparator<? super Long> comparator) {
     Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
   }
 

src/main/java/org/assertj/core/internal/ShortArrays.java

@@ -203,13 +203,13 @@ public void assertContainsOnly(AssertionInfo info, short[] actual, short[] value
   }
 
   public void assertContainsExactly(AssertionInfo info, short[] actual, short[] values) {
-	arrays.assertContainsExactly(info, failures, actual, values);
+    arrays.assertContainsExactly(info, failures, actual, values);
   }
 
   public void assertContainsExactlyInAnyOrder(AssertionInfo info, short[] actual, short[] values) {
     arrays.assertContainsExactlyInAnyOrder(info, failures, actual, values);
   }
-  
+
   /**
    * Asserts that the given array contains only once the given values.
    * 
@@ -337,7 +337,7 @@ public void assertIsSorted(AssertionInfo info, short[] actual) {
    * @param comparator the {@link Comparator} used to compare array elements
    */
   public void assertIsSortedAccordingToComparator(AssertionInfo info, short[] actual,
-      Comparator<? super Short> comparator) {
+                                                  Comparator<? super Short> comparator) {
     Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
   }
 

src/test/java/org/assertj/core/api/booleanarray/BooleanArrayAssert_contains_Test.java

@@ -13,13 +13,11 @@
 package org.assertj.core.api.booleanarray;
 
 import static org.assertj.core.test.BooleanArrays.arrayOf;
+import static org.mockito.Mockito.verify;
 
 import org.assertj.core.api.BooleanArrayAssert;
 import org.assertj.core.api.BooleanArrayAssertBaseTest;
 
-import static org.mockito.Mockito.verify;
-
-
 /**
  * Tests for <code>{@link BooleanArrayAssert#contains(boolean...)}</code>.
  * 

src/test/java/org/assertj/core/internal/Arrays_assertContains_Test.java

@@ -0,0 +1,154 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2017 the original author or authors.
+ */
+package org.assertj.core.internal;
+
+import static org.assertj.core.error.ShouldContain.shouldContain;
+import static org.assertj.core.internal.ErrorMessages.valuesToLookForIsNull;
+import static org.assertj.core.test.IntArrays.emptyArray;
+import static org.assertj.core.test.TestData.someInfo;
+import static org.assertj.core.test.TestFailures.failBecauseExpectedAssertionErrorWasNotThrown;
+import static org.assertj.core.util.Arrays.array;
+import static org.assertj.core.util.FailureMessages.actualIsNull;
+import static org.assertj.core.util.Sets.newLinkedHashSet;
+import static org.mockito.Mockito.verify;
+
+import org.assertj.core.api.AssertionInfo;
+import org.junit.Test;
+
+public class Arrays_assertContains_Test extends BaseArraysTest {
+
+  @Test
+  public void should_pass_if_actual_contains_given_values() {
+    arrays.assertContains(someInfo(), failures, actual, array("Luke"));
+  }
+
+  @Test
+  public void should_pass_if_actual_contains_given_values_in_different_order() {
+    arrays.assertContains(someInfo(), failures, actual, array("Leia", "Yoda"));
+  }
+
+  @Test
+  public void should_pass_if_actual_contains_all_given_values() {
+    arrays.assertContains(someInfo(), failures, actual, array("Luke", "Yoda", "Leia"));
+  }
+
+  @Test
+  public void should_pass_if_actual_contains_given_values_more_than_once() {
+    actual = array("Luke", "Yoda", "Leia", "Luke", "Luke");
+    arrays.assertContains(someInfo(), failures, actual, array("Luke"));
+  }
+
+  @Test
+  public void should_pass_if_actual_contains_given_values_even_if_duplicated() {
+    arrays.assertContains(someInfo(), failures, actual, array("Luke", "Luke"));
+  }
+
+  @Test
+  public void should_pass_if_actual_and_given_values_are_empty() {
+    actual = new String[0];
+    arrays.assertContains(someInfo(), failures, actual, array());
+  }
+
+  @Test
+  public void should_fail_if_array_of_values_to_look_for_is_empty_and_actual_is_not() {
+    thrown.expectAssertionError();
+    arrays.assertContains(someInfo(), failures, actual, emptyArray());
+  }
+
+  @Test
+  public void should_throw_error_if_array_of_values_to_look_for_is_null() {
+    thrown.expectNullPointerException(valuesToLookForIsNull());
+    arrays.assertContains(someInfo(), failures, actual, null);
+  }
+
+  @Test
+  public void should_fail_if_actual_is_null() {
+    thrown.expectAssertionError(actualIsNull());
+    arrays.assertContains(someInfo(), failures, null, array("Yoda"));
+  }
+
+  @Test
+  public void should_fail_if_actual_does_not_contain_values() {
+    AssertionInfo info = someInfo();
+    Object[] expected = { "Leia", "Yoda", "John" };
+    try {
+      arrays.assertContains(info, failures, actual, expected);
+    } catch (AssertionError e) {
+      verify(failures).failure(info, shouldContain(actual, expected, newLinkedHashSet("John")));
+      return;
+    }
+    failBecauseExpectedAssertionErrorWasNotThrown();
+  }
+
+  // ------------------------------------------------------------------------------------------------------------------
+  // tests using a custom comparison strategy
+  // ------------------------------------------------------------------------------------------------------------------
+
+  @Test
+  public void should_pass_if_actual_contains_given_values_according_to_custom_comparison_strategy() {
+    arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, array("LUKE"));
+  }
+
+  @Test
+  public void should_pass_if_actual_contains_given_values_in_different_order_according_to_custom_comparison_strategy() {
+    arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, array("LEIA", "yODa"));
+  }
+
+  @Test
+  public void should_pass_if_actual_contains_all_given_values_according_to_custom_comparison_strategy() {
+    arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, array("luke", "YODA", "leia"));
+  }
+
+  @Test
+  public void should_pass_if_actual_contains_given_values_more_than_once_according_to_custom_comparison_strategy() {
+    actual = array("Luke", "Yoda", "Leia", "Luke", "Luke");
+    arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, array("LUke"));
+  }
+
+  @Test
+  public void should_pass_if_actual_contains_given_values_even_if_duplicated_according_to_custom_comparison_strategy() {
+    arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, array("LUke", "LuKe"));
+  }
+
+  @Test
+  public void should_fail_if_array_of_values_to_look_for_is_empty_and_actual_is_not_whatever_custom_comparison_strategy_is() {
+    thrown.expectAssertionError();
+    arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, emptyArray());
+  }
+
+  @Test
+  public void should_throw_error_if_array_of_values_to_look_for_is_null_whatever_custom_comparison_strategy_is() {
+    thrown.expectNullPointerException(valuesToLookForIsNull());
+    arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, null);
+  }
+
+  @Test
+  public void should_fail_if_actual_is_null_whatever_custom_comparison_strategy_is() {
+    thrown.expectAssertionError(actualIsNull());
+    arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, null, array("LUke"));
+  }
+
+  @Test
+  public void should_fail_if_actual_does_not_contain_values_according_to_custom_comparison_strategy() {
+    AssertionInfo info = someInfo();
+    Object[] expected = { "LeiA", "YODA", "JOhN" };
+    try {
+      arraysWithCustomComparisonStrategy.assertContains(info, failures, actual, expected);
+    } catch (AssertionError e) {
+      verify(failures).failure(info, shouldContain(actual, expected, newLinkedHashSet("JOhN"),
+                                                   caseInsensitiveStringComparisonStrategy));
+      return;
+    }
+    failBecauseExpectedAssertionErrorWasNotThrown();
+  }
+}