Skip to content

Commit 3cca6bf

Browse files
joaodelgadojoel-costigliola
joaodelgado
authored and
joel-costigliola
committed
Add tests for assertContains for the generic Arrays class
1 parent e8c99c3 commit 3cca6bf

20 files changed

+289
-1051
lines changed

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

Lines changed: 7 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -155,7 +155,8 @@ public void assertHasSameSizeAs(AssertionInfo info, Object array, Object other)
155155
hasSameSizeAsCheck(info, array, other, sizeOf(array));
156156
}
157157

158-
void assertContains(AssertionInfo info, Failures failures, Object actual, Object values) {
158+
@VisibleForTesting
159+
public void assertContains(AssertionInfo info, Failures failures, Object actual, Object values) {
159160
if (commonChecks(info, actual, values)) return;
160161
Set<Object> notFound = new LinkedHashSet<>();
161162
int valueCount = sizeOf(values);
@@ -295,7 +296,7 @@ void assertContainsSequence(AssertionInfo info, Failures failures, Object actual
295296
}
296297

297298
void assertDoesNotContainSequence(AssertionInfo info, Failures failures, Object actual, Object sequence) {
298-
if(commonChecks(info, actual, sequence)) return;
299+
if (commonChecks(info, actual, sequence)) return;
299300

300301
// look for given sequence, stop check when there are not enough elements remaining in actual to contain sequence
301302
int lastIndexWhereSequenceCanBeFound = sizeOf(actual) - sizeOf(sequence);
@@ -346,7 +347,7 @@ void assertContainsSubsequence(AssertionInfo info, Failures failures, Object act
346347
if (subsequenceIndex < sizeOfSubsequence)
347348
throw failures.failure(info, shouldContainSubsequence(actual, subsequence, comparisonStrategy));
348349
}
349-
350+
350351
void assertHasOnlyElementsOfTypes(AssertionInfo info, Failures failures, Object actual, Class<?>[] expectedTypes) {
351352
checkIsNotNull(expectedTypes);
352353
assertNotNull(info, actual);
@@ -359,7 +360,7 @@ void assertHasOnlyElementsOfTypes(AssertionInfo info, Failures failures, Object
359360
}
360361
if (!matching) nonMatchingElements.add(value);
361362
}
362-
363+
363364
if (!nonMatchingElements.isEmpty()) {
364365
throw failures.failure(info, shouldOnlyHaveElementsOfTypes(actual, expectedTypes, nonMatchingElements));
365366
}
@@ -389,7 +390,8 @@ void assertDoesNotContainSubsequence(AssertionInfo info, Failures failures, Obje
389390
actualIndex++;
390391

391392
if (subsequenceIndex == sizeOfSubsequence) {
392-
throw failures.failure(info, shouldNotContainSubsequence(actual, subsequence, comparisonStrategy, subsequenceStartIndex));
393+
throw failures.failure(info, shouldNotContainSubsequence(actual, subsequence, comparisonStrategy,
394+
subsequenceStartIndex));
393395
}
394396
}
395397
}

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

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -195,13 +195,13 @@ public void assertContainsOnly(AssertionInfo info, boolean[] actual, boolean[] v
195195
}
196196

197197
public void assertContainsExactly(AssertionInfo info, boolean[] actual, boolean[] values) {
198-
arrays.assertContainsExactly(info, failures, actual, values);
198+
arrays.assertContainsExactly(info, failures, actual, values);
199199
}
200200

201201
public void assertContainsExactlyInAnyOrder(AssertionInfo info, boolean[] actual, boolean[] values) {
202202
arrays.assertContainsExactlyInAnyOrder(info, failures, actual, values);
203203
}
204-
204+
205205
/**
206206
* Asserts that the given array contains only once the given values.
207207
*
@@ -329,7 +329,7 @@ public void assertIsSorted(AssertionInfo info, boolean[] actual) {
329329
* @param comparator the {@link Comparator} used to compare array elements
330330
*/
331331
public void assertIsSortedAccordingToComparator(AssertionInfo info, boolean[] actual,
332-
Comparator<? super Boolean> comparator) {
332+
Comparator<? super Boolean> comparator) {
333333
Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
334334
}
335335

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

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,6 @@
1919
import org.assertj.core.data.Index;
2020
import org.assertj.core.util.VisibleForTesting;
2121

22-
2322
/**
2423
* Reusable assertions for arrays of {@code byte}s.
2524
*
@@ -239,7 +238,7 @@ public void assertContainsOnly(AssertionInfo info, byte[] actual, int[] values)
239238
}
240239

241240
public void assertContainsExactly(AssertionInfo info, byte[] actual, byte[] values) {
242-
arrays.assertContainsExactly(info, failures, actual, values);
241+
arrays.assertContainsExactly(info, failures, actual, values);
243242
}
244243

245244
public void assertContainsExactly(AssertionInfo info, byte[] actual, int[] values) {
@@ -466,7 +465,8 @@ public void assertIsSorted(AssertionInfo info, byte[] actual) {
466465
* @param actual the given array.
467466
* @param comparator the {@link Comparator} used to compare array elements
468467
*/
469-
public void assertIsSortedAccordingToComparator(AssertionInfo info, byte[] actual, Comparator<? super Byte> comparator) {
468+
public void assertIsSortedAccordingToComparator(AssertionInfo info, byte[] actual,
469+
Comparator<? super Byte> comparator) {
470470
Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
471471
}
472472

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

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -204,13 +204,13 @@ public void assertContainsOnly(AssertionInfo info, char[] actual, char[] values)
204204
}
205205

206206
public void assertContainsExactly(AssertionInfo info, char[] actual, char[] values) {
207-
arrays.assertContainsExactly(info, failures, actual, values);
207+
arrays.assertContainsExactly(info, failures, actual, values);
208208
}
209209

210210
public void assertContainsExactlyInAnyOrder(AssertionInfo info, char[] actual, char[] values) {
211211
arrays.assertContainsExactlyInAnyOrder(info, failures, actual, values);
212212
}
213-
213+
214214
/**
215215
* Asserts that the given array contains only once the given values.
216216
*
@@ -338,7 +338,7 @@ public void assertIsSorted(AssertionInfo info, char[] actual) {
338338
* @param comparator the {@link Comparator} used to compare array elements
339339
*/
340340
public void assertIsSortedAccordingToComparator(AssertionInfo info, char[] actual,
341-
Comparator<? super Character> comparator) {
341+
Comparator<? super Character> comparator) {
342342
Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
343343
}
344344

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

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,6 @@
1919
import org.assertj.core.data.Index;
2020
import org.assertj.core.util.VisibleForTesting;
2121

22-
2322
/**
2423
* Reusable assertions for arrays of {@code float}s.
2524
*
@@ -193,13 +192,13 @@ public void assertContainsOnly(AssertionInfo info, float[] actual, float[] value
193192
}
194193

195194
public void assertContainsExactly(AssertionInfo info, float[] actual, float[] values) {
196-
arrays.assertContainsExactly(info, failures, actual, values);
195+
arrays.assertContainsExactly(info, failures, actual, values);
197196
}
198197

199198
public void assertContainsExactlyInAnyOrder(AssertionInfo info, float[] actual, float[] values) {
200199
arrays.assertContainsExactlyInAnyOrder(info, failures, actual, values);
201200
}
202-
201+
203202
/**
204203
* Asserts that the given array contains only once the given values.
205204
*
@@ -321,7 +320,8 @@ public void assertIsSorted(AssertionInfo info, float[] actual) {
321320
* @param actual the given array.
322321
* @param comparator the {@link Comparator} used to compare array elements
323322
*/
324-
public void assertIsSortedAccordingToComparator(AssertionInfo info, float[] actual, Comparator<? super Float> comparator) {
323+
public void assertIsSortedAccordingToComparator(AssertionInfo info, float[] actual,
324+
Comparator<? super Float> comparator) {
325325
Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
326326
}
327327

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

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -204,13 +204,13 @@ public void assertContainsOnly(AssertionInfo info, long[] actual, long[] values)
204204
}
205205

206206
public void assertContainsExactly(AssertionInfo info, long[] actual, long[] values) {
207-
arrays.assertContainsExactly(info, failures, actual, values);
207+
arrays.assertContainsExactly(info, failures, actual, values);
208208
}
209209

210210
public void assertContainsExactlyInAnyOrder(AssertionInfo info, long[] actual, long[] values) {
211211
arrays.assertContainsExactlyInAnyOrder(info, failures, actual, values);
212212
}
213-
213+
214214
/**
215215
* Asserts that the given array contains only once the given values.
216216
*
@@ -337,7 +337,8 @@ public void assertIsSorted(AssertionInfo info, long[] actual) {
337337
* @param actual the given array.
338338
* @param comparator the {@link Comparator} used to compare array elements
339339
*/
340-
public void assertIsSortedAccordingToComparator(AssertionInfo info, long[] actual, Comparator<? super Long> comparator) {
340+
public void assertIsSortedAccordingToComparator(AssertionInfo info, long[] actual,
341+
Comparator<? super Long> comparator) {
341342
Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
342343
}
343344

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

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -203,13 +203,13 @@ public void assertContainsOnly(AssertionInfo info, short[] actual, short[] value
203203
}
204204

205205
public void assertContainsExactly(AssertionInfo info, short[] actual, short[] values) {
206-
arrays.assertContainsExactly(info, failures, actual, values);
206+
arrays.assertContainsExactly(info, failures, actual, values);
207207
}
208208

209209
public void assertContainsExactlyInAnyOrder(AssertionInfo info, short[] actual, short[] values) {
210210
arrays.assertContainsExactlyInAnyOrder(info, failures, actual, values);
211211
}
212-
212+
213213
/**
214214
* Asserts that the given array contains only once the given values.
215215
*
@@ -337,7 +337,7 @@ public void assertIsSorted(AssertionInfo info, short[] actual) {
337337
* @param comparator the {@link Comparator} used to compare array elements
338338
*/
339339
public void assertIsSortedAccordingToComparator(AssertionInfo info, short[] actual,
340-
Comparator<? super Short> comparator) {
340+
Comparator<? super Short> comparator) {
341341
Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
342342
}
343343

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

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -13,13 +13,11 @@
1313
package org.assertj.core.api.booleanarray;
1414

1515
import static org.assertj.core.test.BooleanArrays.arrayOf;
16+
import static org.mockito.Mockito.verify;
1617

1718
import org.assertj.core.api.BooleanArrayAssert;
1819
import org.assertj.core.api.BooleanArrayAssertBaseTest;
1920

20-
import static org.mockito.Mockito.verify;
21-
22-
2321
/**
2422
* Tests for <code>{@link BooleanArrayAssert#contains(boolean...)}</code>.
2523
*

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

Lines changed: 154 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,154 @@
1+
/**
2+
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
3+
* the License. You may obtain a copy of the License at
4+
*
5+
* http://www.apache.org/licenses/LICENSE-2.0
6+
*
7+
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
8+
* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
9+
* specific language governing permissions and limitations under the License.
10+
*
11+
* Copyright 2012-2017 the original author or authors.
12+
*/
13+
package org.assertj.core.internal;
14+
15+
import static org.assertj.core.error.ShouldContain.shouldContain;
16+
import static org.assertj.core.internal.ErrorMessages.valuesToLookForIsNull;
17+
import static org.assertj.core.test.IntArrays.emptyArray;
18+
import static org.assertj.core.test.TestData.someInfo;
19+
import static org.assertj.core.test.TestFailures.failBecauseExpectedAssertionErrorWasNotThrown;
20+
import static org.assertj.core.util.Arrays.array;
21+
import static org.assertj.core.util.FailureMessages.actualIsNull;
22+
import static org.assertj.core.util.Sets.newLinkedHashSet;
23+
import static org.mockito.Mockito.verify;
24+
25+
import org.assertj.core.api.AssertionInfo;
26+
import org.junit.Test;
27+
28+
public class Arrays_assertContains_Test extends BaseArraysTest {
29+
30+
@Test
31+
public void should_pass_if_actual_contains_given_values() {
32+
arrays.assertContains(someInfo(), failures, actual, array("Luke"));
33+
}
34+
35+
@Test
36+
public void should_pass_if_actual_contains_given_values_in_different_order() {
37+
arrays.assertContains(someInfo(), failures, actual, array("Leia", "Yoda"));
38+
}
39+
40+
@Test
41+
public void should_pass_if_actual_contains_all_given_values() {
42+
arrays.assertContains(someInfo(), failures, actual, array("Luke", "Yoda", "Leia"));
43+
}
44+
45+
@Test
46+
public void should_pass_if_actual_contains_given_values_more_than_once() {
47+
actual = array("Luke", "Yoda", "Leia", "Luke", "Luke");
48+
arrays.assertContains(someInfo(), failures, actual, array("Luke"));
49+
}
50+
51+
@Test
52+
public void should_pass_if_actual_contains_given_values_even_if_duplicated() {
53+
arrays.assertContains(someInfo(), failures, actual, array("Luke", "Luke"));
54+
}
55+
56+
@Test
57+
public void should_pass_if_actual_and_given_values_are_empty() {
58+
actual = new String[0];
59+
arrays.assertContains(someInfo(), failures, actual, array());
60+
}
61+
62+
@Test
63+
public void should_fail_if_array_of_values_to_look_for_is_empty_and_actual_is_not() {
64+
thrown.expectAssertionError();
65+
arrays.assertContains(someInfo(), failures, actual, emptyArray());
66+
}
67+
68+
@Test
69+
public void should_throw_error_if_array_of_values_to_look_for_is_null() {
70+
thrown.expectNullPointerException(valuesToLookForIsNull());
71+
arrays.assertContains(someInfo(), failures, actual, null);
72+
}
73+
74+
@Test
75+
public void should_fail_if_actual_is_null() {
76+
thrown.expectAssertionError(actualIsNull());
77+
arrays.assertContains(someInfo(), failures, null, array("Yoda"));
78+
}
79+
80+
@Test
81+
public void should_fail_if_actual_does_not_contain_values() {
82+
AssertionInfo info = someInfo();
83+
Object[] expected = { "Leia", "Yoda", "John" };
84+
try {
85+
arrays.assertContains(info, failures, actual, expected);
86+
} catch (AssertionError e) {
87+
verify(failures).failure(info, shouldContain(actual, expected, newLinkedHashSet("John")));
88+
return;
89+
}
90+
failBecauseExpectedAssertionErrorWasNotThrown();
91+
}
92+
93+
// ------------------------------------------------------------------------------------------------------------------
94+
// tests using a custom comparison strategy
95+
// ------------------------------------------------------------------------------------------------------------------
96+
97+
@Test
98+
public void should_pass_if_actual_contains_given_values_according_to_custom_comparison_strategy() {
99+
arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, array("LUKE"));
100+
}
101+
102+
@Test
103+
public void should_pass_if_actual_contains_given_values_in_different_order_according_to_custom_comparison_strategy() {
104+
arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, array("LEIA", "yODa"));
105+
}
106+
107+
@Test
108+
public void should_pass_if_actual_contains_all_given_values_according_to_custom_comparison_strategy() {
109+
arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, array("luke", "YODA", "leia"));
110+
}
111+
112+
@Test
113+
public void should_pass_if_actual_contains_given_values_more_than_once_according_to_custom_comparison_strategy() {
114+
actual = array("Luke", "Yoda", "Leia", "Luke", "Luke");
115+
arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, array("LUke"));
116+
}
117+
118+
@Test
119+
public void should_pass_if_actual_contains_given_values_even_if_duplicated_according_to_custom_comparison_strategy() {
120+
arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, array("LUke", "LuKe"));
121+
}
122+
123+
@Test
124+
public void should_fail_if_array_of_values_to_look_for_is_empty_and_actual_is_not_whatever_custom_comparison_strategy_is() {
125+
thrown.expectAssertionError();
126+
arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, emptyArray());
127+
}
128+
129+
@Test
130+
public void should_throw_error_if_array_of_values_to_look_for_is_null_whatever_custom_comparison_strategy_is() {
131+
thrown.expectNullPointerException(valuesToLookForIsNull());
132+
arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, actual, null);
133+
}
134+
135+
@Test
136+
public void should_fail_if_actual_is_null_whatever_custom_comparison_strategy_is() {
137+
thrown.expectAssertionError(actualIsNull());
138+
arraysWithCustomComparisonStrategy.assertContains(someInfo(), failures, null, array("LUke"));
139+
}
140+
141+
@Test
142+
public void should_fail_if_actual_does_not_contain_values_according_to_custom_comparison_strategy() {
143+
AssertionInfo info = someInfo();
144+
Object[] expected = { "LeiA", "YODA", "JOhN" };
145+
try {
146+
arraysWithCustomComparisonStrategy.assertContains(info, failures, actual, expected);
147+
} catch (AssertionError e) {
148+
verify(failures).failure(info, shouldContain(actual, expected, newLinkedHashSet("JOhN"),
149+
caseInsensitiveStringComparisonStrategy));
150+
return;
151+
}
152+
failBecauseExpectedAssertionErrorWasNotThrown();
153+
}
154+
}

0 commit comments

Comments
 (0)