From dfe25d28341c3e7517b92b08f2cc80587fb4b90d Mon Sep 17 00:00:00 2001 From: gokareless Date: Sun, 6 Sep 2020 01:41:30 +0300 Subject: [PATCH 1/2] - Adjusted API to work with embedded arrays --- .../IsIterableContainingInAnyOrder.java | 11 ++++++-- .../IsIterableContainingInOrder.java | 5 ++++ .../test/java/org/hamcrest/MatchersTest.java | 28 +++++++++++++++++++ .../core/IsIterableContainingTest.java | 22 +++++++++++++++ 4 files changed, 64 insertions(+), 2 deletions(-) create mode 100644 hamcrest/src/test/java/org/hamcrest/MatchersTest.java diff --git a/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java index d6a9a33d..5756c278 100644 --- a/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java @@ -124,10 +124,17 @@ public static Matcher> containsInAnyOrder(Matcher Matcher> containsInAnyOrder(T... items) { List> matchers = new ArrayList<>(); - for (T item : items) { + if (items.length == 1 && items[0].getClass().isArray()) { + @SuppressWarnings("unchecked") + T[] realItems = (T[]) items[0]; + for (T item : realItems) { matchers.add(equalTo(item)); + } + } else { + for (T item : items) { + matchers.add(equalTo(item)); + } } - return new IsIterableContainingInAnyOrder<>(matchers); } diff --git a/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java index ed62aa29..fb433df7 100644 --- a/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java @@ -94,6 +94,11 @@ private void describeMismatch(Matcher matcher, F item) { */ @SafeVarargs public static Matcher> contains(E... items) { + if (items.length == 1 && items[0].getClass().isArray()) { + @SuppressWarnings("unchecked") + E[] realItems = (E[]) items[0]; + return contains(asEqualMatchers(realItems)); + } return contains(asEqualMatchers(items)); } diff --git a/hamcrest/src/test/java/org/hamcrest/MatchersTest.java b/hamcrest/src/test/java/org/hamcrest/MatchersTest.java new file mode 100644 index 00000000..e2395e6f --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/MatchersTest.java @@ -0,0 +1,28 @@ +package org.hamcrest; + +import java.util.Arrays; +import org.hamcrest.core.AnyOf; +import org.junit.Test; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.contains; +import static org.hamcrest.Matchers.containsInAnyOrder; + +public class MatchersTest { + + @Test + public void matchersContainsInAnyOrderCastTest() { + String[] truth = new String[] { "1", "2" }; + assertThat("doesn't contain elements", Arrays.asList("1", "2"), containsInAnyOrder(truth)); + Object otherTruth = truth; + assertThat("doesn't contain elements", Arrays.asList("1", "2"), containsInAnyOrder(otherTruth)); + } + + @Test + public void matchersContainsCastTest() { + String[] truth = new String[] { "1", "2" }; + assertThat("doesn't contain elements", Arrays.asList("1", "2"), contains(truth)); + Object otherTruth = truth; + assertThat("doesn't contain elements", Arrays.asList("1", "2"), contains(otherTruth)); + } +} diff --git a/hamcrest/src/test/java/org/hamcrest/core/IsIterableContainingTest.java b/hamcrest/src/test/java/org/hamcrest/core/IsIterableContainingTest.java index 02148b81..86787dfa 100644 --- a/hamcrest/src/test/java/org/hamcrest/core/IsIterableContainingTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/IsIterableContainingTest.java @@ -6,6 +6,7 @@ import org.junit.Test; import java.util.ArrayList; +import java.util.Arrays; import java.util.HashSet; import java.util.Set; @@ -13,6 +14,8 @@ import static org.hamcrest.AbstractMatcherTest.*; import static org.hamcrest.core.IsIterableContaining.hasItem; import static org.hamcrest.core.IsIterableContaining.hasItems; +import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder; +import static org.hamcrest.collection.IsIterableContainingInOrder.contains; import static org.hamcrest.core.IsEqual.equalTo; public final class IsIterableContainingTest { @@ -86,6 +89,25 @@ public final class IsIterableContainingTest { matcher, asList(1, 2, 3)); } + @Test public void + isIterableContainingAnyOrderCast() { + String[] array = new String[]{"1", "2"}; + Object object = array; + Iterable real = Arrays.asList("1", "2"); + final Matcher> matcher = containsInAnyOrder(object); + assertTrue("does not match the same object", matcher.matches(real)); + } + + @Test + public void + isIterableContainingCast() { + String[] array = new String[]{"1", "2"}; + Object object = array; + Iterable real = Arrays.asList("1", "2"); + final Matcher> matcher = contains(object); + assertTrue("does not match the same object", matcher.matches(real)); + } + private static Matcher mismatchable(final String string) { return new TypeSafeDiagnosingMatcher() { @Override From b3e19ceea3b959f244ad983d659cdc63ef133e2b Mon Sep 17 00:00:00 2001 From: gokareless Date: Tue, 15 Feb 2022 11:39:28 +0200 Subject: [PATCH 2/2] - Resolved conflicts --- .../IsIterableContainingInAnyOrder.java | 11 ++++++-- .../IsIterableContainingInOrder.java | 5 ++++ .../test/java/org/hamcrest/MatchersTest.java | 28 +++++++++++++++++++ .../core/IsIterableContainingTest.java | 22 +++++++++++++++ 4 files changed, 64 insertions(+), 2 deletions(-) create mode 100644 hamcrest/src/test/java/org/hamcrest/MatchersTest.java diff --git a/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java index 262a1263..4c3e44df 100644 --- a/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInAnyOrder.java @@ -131,10 +131,17 @@ public static Matcher> containsInAnyOrder(Matcher Matcher> containsInAnyOrder(T... items) { List> matchers = new ArrayList<>(); - for (T item : items) { + if (items.length == 1 && items[0].getClass().isArray()) { + @SuppressWarnings("unchecked") + T[] realItems = (T[]) items[0]; + for (T item : realItems) { matchers.add(equalTo(item)); + } + } else { + for (T item : items) { + matchers.add(equalTo(item)); + } } - return new IsIterableContainingInAnyOrder<>(matchers); } diff --git a/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java index 00b89ea7..dd75cccf 100644 --- a/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java +++ b/hamcrest/src/main/java/org/hamcrest/collection/IsIterableContainingInOrder.java @@ -98,6 +98,11 @@ private void describeMismatch(Matcher matcher, F item) { */ @SafeVarargs public static Matcher> contains(E... items) { + if (items.length == 1 && items[0].getClass().isArray()) { + @SuppressWarnings("unchecked") + E[] realItems = (E[]) items[0]; + return contains(asEqualMatchers(realItems)); + } return contains(asEqualMatchers(items)); } diff --git a/hamcrest/src/test/java/org/hamcrest/MatchersTest.java b/hamcrest/src/test/java/org/hamcrest/MatchersTest.java new file mode 100644 index 00000000..e2395e6f --- /dev/null +++ b/hamcrest/src/test/java/org/hamcrest/MatchersTest.java @@ -0,0 +1,28 @@ +package org.hamcrest; + +import java.util.Arrays; +import org.hamcrest.core.AnyOf; +import org.junit.Test; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.contains; +import static org.hamcrest.Matchers.containsInAnyOrder; + +public class MatchersTest { + + @Test + public void matchersContainsInAnyOrderCastTest() { + String[] truth = new String[] { "1", "2" }; + assertThat("doesn't contain elements", Arrays.asList("1", "2"), containsInAnyOrder(truth)); + Object otherTruth = truth; + assertThat("doesn't contain elements", Arrays.asList("1", "2"), containsInAnyOrder(otherTruth)); + } + + @Test + public void matchersContainsCastTest() { + String[] truth = new String[] { "1", "2" }; + assertThat("doesn't contain elements", Arrays.asList("1", "2"), contains(truth)); + Object otherTruth = truth; + assertThat("doesn't contain elements", Arrays.asList("1", "2"), contains(otherTruth)); + } +} diff --git a/hamcrest/src/test/java/org/hamcrest/core/IsIterableContainingTest.java b/hamcrest/src/test/java/org/hamcrest/core/IsIterableContainingTest.java index b20942be..3a0e6436 100644 --- a/hamcrest/src/test/java/org/hamcrest/core/IsIterableContainingTest.java +++ b/hamcrest/src/test/java/org/hamcrest/core/IsIterableContainingTest.java @@ -6,6 +6,7 @@ import org.junit.Test; import java.util.ArrayList; +import java.util.Arrays; import java.util.HashSet; import java.util.Set; @@ -13,6 +14,8 @@ import static org.hamcrest.AbstractMatcherTest.*; import static org.hamcrest.core.IsIterableContaining.hasItem; import static org.hamcrest.core.IsIterableContaining.hasItems; +import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder; +import static org.hamcrest.collection.IsIterableContainingInOrder.contains; import static org.hamcrest.core.IsEqual.equalTo; public final class IsIterableContainingTest { @@ -86,6 +89,25 @@ public final class IsIterableContainingTest { matcher, asList(1, 2, 3)); } + @Test public void + isIterableContainingAnyOrderCast() { + String[] array = new String[]{"1", "2"}; + Object object = array; + Iterable real = Arrays.asList("1", "2"); + final Matcher> matcher = containsInAnyOrder(object); + assertTrue("does not match the same object", matcher.matches(real)); + } + + @Test + public void + isIterableContainingCast() { + String[] array = new String[]{"1", "2"}; + Object object = array; + Iterable real = Arrays.asList("1", "2"); + final Matcher> matcher = contains(object); + assertTrue("does not match the same object", matcher.matches(real)); + } + private static Matcher mismatchable(final String string) { return new TypeSafeDiagnosingMatcher() { @Override