Move externalizer tester to wildfly-clustering-marshalling-api test-jar.

wildfly · Dec 4, 2017 · 657d99f · 657d99f
1 parent 1669312
commit 657d99f
Show file tree

Hide file tree

Showing 12 changed files with 180 additions and 119 deletions.
diff --git a/clustering/marshalling/api/pom.xml b/clustering/marshalling/api/pom.xml
@@ -37,4 +37,20 @@
 
     <name>WildFly: Clustering marshalling API</name>
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>test-jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
 </project>
diff --git a/...shalling/api/src/test/java/org/wildfly/clustering/marshalling/EnumExternalizerTester.java b/...shalling/api/src/test/java/org/wildfly/clustering/marshalling/EnumExternalizerTester.java
@@ -0,0 +1,48 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2017, Red Hat, Inc., and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.wildfly.clustering.marshalling;
+
+import java.io.IOException;
+import java.util.EnumSet;
+
+import org.junit.Assert;
+
+/**
+ * Tester for an {@link Externalizer} of an enum.
+ * @author Paul Ferraro
+ */
+public class EnumExternalizerTester<E extends Enum<E>> extends ExternalizerTester<E> {
+
+    private final Class<E> targetClass;
+
+    public EnumExternalizerTester(Externalizer<E> externalizer) {
+        super(externalizer, Assert::assertSame);
+        this.targetClass = externalizer.getTargetClass();
+    }
+
+    public void test() throws ClassNotFoundException, IOException {
+        for (E value : EnumSet.allOf(this.targetClass)) {
+            this.test(value);
+        }
+    }
+}
diff --git a/...marshalling/spi/ExternalizerTestUtil.java → ...ering/marshalling/ExternalizerTester.java b/...marshalling/spi/ExternalizerTestUtil.java → ...ering/marshalling/ExternalizerTester.java
@@ -20,7 +20,7 @@
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 
-package org.wildfly.clustering.marshalling.spi;
+package org.wildfly.clustering.marshalling;
 
 import static org.junit.Assert.*;
 
@@ -29,41 +29,42 @@
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
-import java.util.EnumSet;
 import java.util.function.BiConsumer;
 
 import org.junit.Assert;
-import org.wildfly.clustering.marshalling.Externalizer;
 
 /**
+ * Tester for an {@link Externalizer}.
  * @author Paul Ferraro
  */
-public class ExternalizerTestUtil {
+public class ExternalizerTester<T> {
 
-    public static <E extends Enum<E>> void test(Externalizer<E> externalizer) throws IOException, ClassNotFoundException {
-        for (E value : EnumSet.allOf(externalizer.getTargetClass())) {
-            test(externalizer, value);
-        }
+    private final Externalizer<T> externalizer;
+    private final BiConsumer<T, T> assertion;
+
+    public ExternalizerTester(Externalizer<T> externalizer) {
+        this(externalizer, Assert::assertEquals);
     }
 
-    public static <T> void test(Externalizer<T> externalizer, T subject) throws IOException, ClassNotFoundException {
-        test(externalizer, subject, Assert::assertEquals);
+    public ExternalizerTester(Externalizer<T> externalizer, BiConsumer<T, T> assertion) {
+        this.externalizer = externalizer;
+        this.assertion = assertion;
     }
 
-    public static <T> void test(Externalizer<T> externalizer, T subject, BiConsumer<T, T> assertion) throws IOException, ClassNotFoundException {
-        assertTrue(externalizer.getTargetClass().isInstance(subject));
+    public void test(T subject) throws IOException, ClassNotFoundException {
+        assertTrue(this.externalizer.getTargetClass().isInstance(subject));
 
         ByteArrayOutputStream externalizedOutput = new ByteArrayOutputStream();
         try (ObjectOutputStream output = new ObjectOutputStream(externalizedOutput)) {
-            externalizer.writeObject(output, subject);
+            this.externalizer.writeObject(output, subject);
         }
 
         byte[] externalizedBytes = externalizedOutput.toByteArray();
 
         try (ObjectInputStream input = new ObjectInputStream(new ByteArrayInputStream(externalizedBytes))) {
-            T result = externalizer.readObject(input);
-            assertion.accept(subject, result);
-            assertTrue(externalizer.getTargetClass().isInstance(result));
+            T result = this.externalizer.readObject(input);
+            assertTrue(this.externalizer.getTargetClass().isInstance(result));
+            this.assertion.accept(subject, result);
         }
 
         // If object is serializable, make sure we've actually improved upon default serialization size

diff --git a/clustering/marshalling/spi/pom.xml b/clustering/marshalling/spi/pom.xml
@@ -46,6 +46,13 @@
             <groupId>org.wildfly.security</groupId>
             <artifactId>wildfly-elytron</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.wildfly</groupId>
+            <artifactId>wildfly-clustering-marshalling-api</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+            <classifier>tests</classifier>
+        </dependency>
     </dependencies>
 
 </project>
diff --git a/...spi/src/test/java/org/wildfly/clustering/marshalling/spi/net/NetExternalizerTestCase.java b/...spi/src/test/java/org/wildfly/clustering/marshalling/spi/net/NetExternalizerTestCase.java
@@ -27,7 +27,7 @@
 import java.net.URL;
 
 import org.junit.Test;
-import org.wildfly.clustering.marshalling.spi.ExternalizerTestUtil;
+import org.wildfly.clustering.marshalling.ExternalizerTester;
 import org.wildfly.clustering.marshalling.spi.DefaultExternalizer;
 
 /**
@@ -38,7 +38,7 @@ public class NetExternalizerTestCase {
 
     @Test
     public void test() throws ClassNotFoundException, IOException {
-        ExternalizerTestUtil.test(DefaultExternalizer.URI.cast(URI.class), URI.create("http://wildfly.org/news/"));
-        ExternalizerTestUtil.test(DefaultExternalizer.URL.cast(URL.class), new URL("http://wildfly.org/news/"));
+        new ExternalizerTester<>(DefaultExternalizer.URI.cast(URI.class)).test(URI.create("http://wildfly.org/news/"));
+        new ExternalizerTester<>(DefaultExternalizer.URL.cast(URL.class)).test(new URL("http://wildfly.org/news/"));
     }
 }
diff --git a/...i/src/test/java/org/wildfly/clustering/marshalling/spi/time/TimeExternalizerTestCase.java b/...i/src/test/java/org/wildfly/clustering/marshalling/spi/time/TimeExternalizerTestCase.java
@@ -38,7 +38,8 @@
 import java.time.ZoneOffset;
 
 import org.junit.Test;
-import org.wildfly.clustering.marshalling.spi.ExternalizerTestUtil;
+import org.wildfly.clustering.marshalling.EnumExternalizerTester;
+import org.wildfly.clustering.marshalling.ExternalizerTester;
 import org.wildfly.clustering.marshalling.spi.DefaultExternalizer;
 
 /**
@@ -50,19 +51,19 @@ public class TimeExternalizerTestCase {
     @Test
     public void test() throws ClassNotFoundException, IOException {
 
-        ExternalizerTestUtil.test(DefaultExternalizer.DAY_OF_WEEK.cast(DayOfWeek.class));
-        ExternalizerTestUtil.test(DefaultExternalizer.MONTH.cast(Month.class));
+        new EnumExternalizerTester<>(DefaultExternalizer.DAY_OF_WEEK.cast(DayOfWeek.class)).test();
+        new EnumExternalizerTester<>(DefaultExternalizer.MONTH.cast(Month.class)).test();
 
-        ExternalizerTestUtil.test(DefaultExternalizer.DURATION.cast(Duration.class), Duration.between(Instant.EPOCH, Instant.now()));
-        ExternalizerTestUtil.test(DefaultExternalizer.INSTANT.cast(Instant.class), Instant.now());
-        ExternalizerTestUtil.test(DefaultExternalizer.LOCAL_DATE.cast(LocalDate.class), LocalDate.now());
-        ExternalizerTestUtil.test(DefaultExternalizer.LOCAL_DATE_TIME.cast(LocalDateTime.class), LocalDateTime.now());
-        ExternalizerTestUtil.test(DefaultExternalizer.LOCAL_TIME.cast(LocalTime.class), LocalTime.now());
-        ExternalizerTestUtil.test(DefaultExternalizer.MONTH_DAY.cast(MonthDay.class), MonthDay.now());
-        ExternalizerTestUtil.test(DefaultExternalizer.PERIOD.cast(Period.class), Period.between(LocalDate.ofEpochDay(0), LocalDate.now()));
-        ExternalizerTestUtil.test(DefaultExternalizer.YEAR.cast(Year.class), Year.now());
-        ExternalizerTestUtil.test(DefaultExternalizer.YEAR_MONTH.cast(YearMonth.class), YearMonth.now());
-        ExternalizerTestUtil.test(DefaultExternalizer.ZONE_OFFSET.cast(ZoneOffset.class), ZoneOffset.UTC);
-        ExternalizerTestUtil.test(DefaultExternalizer.ZONE_ID, ZoneId.of("America/New_York"));
+        new ExternalizerTester<>(DefaultExternalizer.DURATION.cast(Duration.class)).test(Duration.between(Instant.EPOCH, Instant.now()));
+        new ExternalizerTester<>(DefaultExternalizer.INSTANT.cast(Instant.class)).test(Instant.now());
+        new ExternalizerTester<>(DefaultExternalizer.LOCAL_DATE.cast(LocalDate.class)).test(LocalDate.now());
+        new ExternalizerTester<>(DefaultExternalizer.LOCAL_DATE_TIME.cast(LocalDateTime.class)).test(LocalDateTime.now());
+        new ExternalizerTester<>(DefaultExternalizer.LOCAL_TIME.cast(LocalTime.class)).test(LocalTime.now());
+        new ExternalizerTester<>(DefaultExternalizer.MONTH_DAY.cast(MonthDay.class)).test(MonthDay.now());
+        new ExternalizerTester<>(DefaultExternalizer.PERIOD.cast(Period.class)).test(Period.between(LocalDate.ofEpochDay(0), LocalDate.now()));
+        new ExternalizerTester<>(DefaultExternalizer.YEAR.cast(Year.class)).test(Year.now());
+        new ExternalizerTester<>(DefaultExternalizer.YEAR_MONTH.cast(YearMonth.class)).test(YearMonth.now());
+        new ExternalizerTester<>(DefaultExternalizer.ZONE_OFFSET.cast(ZoneOffset.class)).test(ZoneOffset.UTC);
+        new ExternalizerTester<>(DefaultExternalizer.ZONE_ID.cast(ZoneId.class)).test(ZoneId.of("America/New_York"));
     }
 }
diff --git a/...src/test/java/org/wildfly/clustering/marshalling/spi/util/AtomicExternalizerTestCase.java b/...src/test/java/org/wildfly/clustering/marshalling/spi/util/AtomicExternalizerTestCase.java
@@ -31,7 +31,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.Test;
-import org.wildfly.clustering.marshalling.spi.ExternalizerTestUtil;
+import org.wildfly.clustering.marshalling.ExternalizerTester;
 import org.wildfly.clustering.marshalling.spi.DefaultExternalizer;
 
 /**
@@ -42,9 +42,9 @@ public class AtomicExternalizerTestCase {
 
     @Test
     public void test() throws ClassNotFoundException, IOException {
-        ExternalizerTestUtil.test(DefaultExternalizer.ATOMIC_BOOLEAN.cast(AtomicBoolean.class), new AtomicBoolean(Boolean.TRUE), (expected, actual) -> assertEquals(expected.get(), actual.get()));
-        ExternalizerTestUtil.test(DefaultExternalizer.ATOMIC_INTEGER.cast(AtomicInteger.class), new AtomicInteger(Integer.MAX_VALUE), (expected, actual) -> assertEquals(expected.get(), actual.get()));
-        ExternalizerTestUtil.test(DefaultExternalizer.ATOMIC_LONG.cast(AtomicLong.class), new AtomicLong(Long.MAX_VALUE), (expected, actual) -> assertEquals(expected.get(), actual.get()));
-        ExternalizerTestUtil.test(DefaultExternalizer.ATOMIC_REFERENCE.cast(AtomicReference.class), new AtomicReference<Object>(Boolean.TRUE), (expected, actual) -> assertEquals(expected.get(), actual.get()));
+        new ExternalizerTester<>(DefaultExternalizer.ATOMIC_BOOLEAN.cast(AtomicBoolean.class), (expected, actual) -> assertEquals(expected.get(), actual.get())).test(new AtomicBoolean(true));
+        new ExternalizerTester<>(DefaultExternalizer.ATOMIC_INTEGER.cast(AtomicInteger.class), (expected, actual) -> assertEquals(expected.get(), actual.get())).test(new AtomicInteger(Integer.MAX_VALUE));
+        new ExternalizerTester<>(DefaultExternalizer.ATOMIC_LONG.cast(AtomicLong.class), (expected, actual) -> assertEquals(expected.get(), actual.get())).test(new AtomicLong(Long.MAX_VALUE));
+        new ExternalizerTester<>(DefaultExternalizer.ATOMIC_REFERENCE.cast(AtomicReference.class), (expected, actual) -> assertEquals(expected.get(), actual.get())).test(new AtomicReference<Object>(Boolean.TRUE));
     }
 }
diff --git a/...test/java/org/wildfly/clustering/marshalling/spi/util/CollectionExternalizerTestCase.java b/...test/java/org/wildfly/clustering/marshalling/spi/util/CollectionExternalizerTestCase.java
@@ -22,10 +22,6 @@
 
 package org.wildfly.clustering.marshalling.spi.util;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
 import java.io.IOException;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
@@ -49,11 +45,10 @@
 import java.util.concurrent.ConcurrentSkipListSet;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CopyOnWriteArraySet;
-import java.util.function.BiConsumer;
 
+import org.junit.Assert;
 import org.junit.Test;
-import org.wildfly.clustering.marshalling.Externalizer;
-import org.wildfly.clustering.marshalling.spi.ExternalizerTestUtil;
+import org.wildfly.clustering.marshalling.ExternalizerTester;
 import org.wildfly.clustering.marshalling.spi.DefaultExternalizer;
 
 /**
@@ -66,46 +61,39 @@ public class CollectionExternalizerTestCase {
     @Test
     public void test() throws ClassNotFoundException, IOException {
         Collection<Object> basis = Arrays.<Object>asList(1, 2, 3, 4, 5);
-        test(DefaultExternalizer.ARRAY_DEQUE.cast(ArrayDeque.class), new ArrayDeque<>(basis));
-        test(DefaultExternalizer.ARRAY_LIST.cast(ArrayList.class), new ArrayList<>(basis));
-        test(DefaultExternalizer.CONCURRENT_LINKED_DEQUE.cast(ConcurrentLinkedDeque.class), new ConcurrentLinkedDeque<>(basis));
-        test(DefaultExternalizer.CONCURRENT_LINKED_QUEUE.cast(ConcurrentLinkedQueue.class), new ConcurrentLinkedQueue<>(basis));
-        test(DefaultExternalizer.HASH_SET.cast(HashSet.class), new HashSet<>(basis));
-        test(DefaultExternalizer.LINKED_HASH_SET.cast(LinkedHashSet.class), new LinkedHashSet<>(basis));
-        test(DefaultExternalizer.LINKED_LIST.cast(LinkedList.class), new LinkedList<>(basis));
-        ConcurrentHashMap.KeySetView<Object, Boolean> keySetView = ConcurrentHashMap.newKeySet();
-        keySetView.addAll(basis);
-        test(DefaultExternalizer.CONCURRENT_HASH_SET.cast(ConcurrentHashMap.KeySetView.class), keySetView);
 
-        test(DefaultExternalizer.COPY_ON_WRITE_ARRAY_LIST.cast(CopyOnWriteArrayList.class), new CopyOnWriteArrayList<>(basis));
-        test(DefaultExternalizer.COPY_ON_WRITE_ARRAY_SET.cast(CopyOnWriteArraySet.class), new CopyOnWriteArraySet<>(basis));
+        new ExternalizerTester<>(DefaultExternalizer.ARRAY_DEQUE.cast(ArrayDeque.class), CollectionExternalizerTestCase::assertCollectionEquals).test(new ArrayDeque<>(basis));
+        new ExternalizerTester<>(DefaultExternalizer.ARRAY_LIST.cast(ArrayList.class), CollectionExternalizerTestCase::assertCollectionEquals).test(new ArrayList<>(basis));
+        new ExternalizerTester<>(DefaultExternalizer.CONCURRENT_LINKED_DEQUE.cast(ConcurrentLinkedDeque.class), CollectionExternalizerTestCase::assertCollectionEquals).test(new ConcurrentLinkedDeque<>(basis));
+        new ExternalizerTester<>(DefaultExternalizer.CONCURRENT_LINKED_QUEUE.cast(ConcurrentLinkedQueue.class), CollectionExternalizerTestCase::assertCollectionEquals).test(new ConcurrentLinkedQueue<>(basis));
+        new ExternalizerTester<>(DefaultExternalizer.HASH_SET.cast(HashSet.class), CollectionExternalizerTestCase::assertCollectionEquals).test(new HashSet<>(basis));
+        new ExternalizerTester<>(DefaultExternalizer.LINKED_HASH_SET.cast(LinkedHashSet.class), CollectionExternalizerTestCase::assertCollectionEquals).test(new LinkedHashSet<>(basis));
+        new ExternalizerTester<>(DefaultExternalizer.LINKED_LIST.cast(LinkedList.class), CollectionExternalizerTestCase::assertCollectionEquals).test(new LinkedList<>(basis));
 
-        test(DefaultExternalizer.EMPTY_ENUMERATION.cast(Enumeration.class), Collections.emptyEnumeration());
-        test(DefaultExternalizer.EMPTY_ITERATOR.cast(Iterator.class), Collections.emptyIterator());
-        test(DefaultExternalizer.EMPTY_LIST.cast(List.class), Collections.emptyList());
-        test(DefaultExternalizer.EMPTY_LIST_ITERATOR.cast(ListIterator.class), Collections.emptyListIterator());
-        test(DefaultExternalizer.EMPTY_NAVIGABLE_SET.cast(NavigableSet.class), Collections.emptyNavigableSet());
-        test(DefaultExternalizer.EMPTY_SET.cast(Set.class), Collections.emptySet());
-        test(DefaultExternalizer.EMPTY_SORTED_SET.cast(SortedSet.class), Collections.emptySortedSet());
+        ConcurrentHashMap.KeySetView<Object, Boolean> keySetView = ConcurrentHashMap.newKeySet();
+        keySetView.addAll(basis);
+        new ExternalizerTester<>(DefaultExternalizer.CONCURRENT_HASH_SET.cast(ConcurrentHashMap.KeySetView.class), CollectionExternalizerTestCase::assertCollectionEquals).test(keySetView);
 
-        test(DefaultExternalizer.SINGLETON_LIST.cast(List.class), Collections.singletonList(1));
-        test(DefaultExternalizer.SINGLETON_SET.cast(Set.class), Collections.singleton(1));
+        new ExternalizerTester<>(DefaultExternalizer.COPY_ON_WRITE_ARRAY_LIST.cast(CopyOnWriteArrayList.class), CollectionExternalizerTestCase::assertCollectionEquals).test(new CopyOnWriteArrayList<>(basis));
+        new ExternalizerTester<>(DefaultExternalizer.COPY_ON_WRITE_ARRAY_SET.cast(CopyOnWriteArraySet.class), CollectionExternalizerTestCase::assertCollectionEquals).test(new CopyOnWriteArraySet<>(basis));
 
-        test(DefaultExternalizer.CONCURRENT_SKIP_LIST_SET.cast(ConcurrentSkipListSet.class), new ConcurrentSkipListSet<>(basis));
-        test(DefaultExternalizer.TREE_SET.cast(TreeSet.class), new TreeSet<>(basis));
-    }
+        new ExternalizerTester<>(DefaultExternalizer.EMPTY_ENUMERATION.cast(Enumeration.class), Assert::assertSame).test(Collections.emptyEnumeration());
+        new ExternalizerTester<>(DefaultExternalizer.EMPTY_ITERATOR.cast(Iterator.class), Assert::assertSame).test(Collections.emptyIterator());
+        new ExternalizerTester<>(DefaultExternalizer.EMPTY_LIST.cast(List.class), Assert::assertSame).test(Collections.emptyList());
+        new ExternalizerTester<>(DefaultExternalizer.EMPTY_LIST_ITERATOR.cast(ListIterator.class), Assert::assertSame).test(Collections.emptyListIterator());
+        new ExternalizerTester<>(DefaultExternalizer.EMPTY_NAVIGABLE_SET.cast(NavigableSet.class), Assert::assertSame).test(Collections.emptyNavigableSet());
+        new ExternalizerTester<>(DefaultExternalizer.EMPTY_SET.cast(Set.class), Assert::assertSame).test(Collections.emptySet());
+        new ExternalizerTester<>(DefaultExternalizer.EMPTY_SORTED_SET.cast(SortedSet.class), Assert::assertSame).test(Collections.emptySortedSet());
 
-    public static <T extends Collection<Object>> void test(Externalizer<T> externalizer, T collection) throws ClassNotFoundException, IOException {
-        BiConsumer<T, T> assertSize = (expected, actual) -> assertEquals(expected.size(), actual.size());
-        BiConsumer<T, T> assertContents = (expected, actual) -> assertTrue(actual.containsAll(expected));
-        ExternalizerTestUtil.test(externalizer, collection, assertSize.andThen(assertContents));
-    }
+        new ExternalizerTester<>(DefaultExternalizer.SINGLETON_LIST.cast(List.class), CollectionExternalizerTestCase::assertCollectionEquals).test(Collections.singletonList(1));
+        new ExternalizerTester<>(DefaultExternalizer.SINGLETON_SET.cast(Set.class), CollectionExternalizerTestCase::assertCollectionEquals).test(Collections.singleton(1));
 
-    public static <T extends Enumeration<Object>> void test(Externalizer<T> externalizer, T enumeration) throws ClassNotFoundException, IOException {
-        ExternalizerTestUtil.test(externalizer, enumeration, (expected, actual) -> assertFalse(actual.hasMoreElements()));
+        new ExternalizerTester<>(DefaultExternalizer.CONCURRENT_SKIP_LIST_SET.cast(ConcurrentSkipListSet.class), CollectionExternalizerTestCase::assertCollectionEquals).test(new ConcurrentSkipListSet<>(basis));
+        new ExternalizerTester<>(DefaultExternalizer.TREE_SET.cast(TreeSet.class), CollectionExternalizerTestCase::assertCollectionEquals).test(new TreeSet<>(basis));
     }
 
-    public static <T extends Iterator<Object>> void test(Externalizer<T> externalizer, T iterator) throws ClassNotFoundException, IOException {
-        ExternalizerTestUtil.test(externalizer, iterator, (expected, actual) -> assertFalse(actual.hasNext()));
+    static <T extends Collection<Object>> void assertCollectionEquals(T expected, T actual) {
+        Assert.assertEquals(expected.size(), actual.size());
+        Assert.assertTrue(expected.containsAll(actual));
     }
 }