From 657d99f784d215f0638ad4906567a1fd369a33f2 Mon Sep 17 00:00:00 2001 From: Paul Ferraro Date: Thu, 30 Nov 2017 12:36:42 -0500 Subject: [PATCH] Move externalizer tester to wildfly-clustering-marshalling-api test-jar. --- clustering/marshalling/api/pom.xml | 16 +++++ .../marshalling/EnumExternalizerTester.java | 48 +++++++++++++ .../marshalling/ExternalizerTester.java} | 33 ++++----- clustering/marshalling/spi/pom.xml | 7 ++ .../spi/net/NetExternalizerTestCase.java | 6 +- .../spi/time/TimeExternalizerTestCase.java | 29 ++++---- .../spi/util/AtomicExternalizerTestCase.java | 10 +-- .../util/CollectionExternalizerTestCase.java | 68 ++++++++----------- .../spi/util/DateExternalizerTestCase.java | 19 +++--- .../util/MapEntryExternalizerTestCase.java | 6 +- .../spi/util/MapExternalizerTestCase.java | 36 +++++----- .../spi/util/UtilExternalizerTestCase.java | 21 +++--- 12 files changed, 180 insertions(+), 119 deletions(-) create mode 100644 clustering/marshalling/api/src/test/java/org/wildfly/clustering/marshalling/EnumExternalizerTester.java rename clustering/marshalling/{spi/src/test/java/org/wildfly/clustering/marshalling/spi/ExternalizerTestUtil.java => api/src/test/java/org/wildfly/clustering/marshalling/ExternalizerTester.java} (68%) diff --git a/clustering/marshalling/api/pom.xml b/clustering/marshalling/api/pom.xml index a95769200ecb..3eef84a320f4 100644 --- a/clustering/marshalling/api/pom.xml +++ b/clustering/marshalling/api/pom.xml @@ -37,4 +37,20 @@ WildFly: Clustering marshalling API + + + + org.apache.maven.plugins + maven-jar-plugin + + + + test-jar + + + + + + + diff --git a/clustering/marshalling/api/src/test/java/org/wildfly/clustering/marshalling/EnumExternalizerTester.java b/clustering/marshalling/api/src/test/java/org/wildfly/clustering/marshalling/EnumExternalizerTester.java new file mode 100644 index 000000000000..9563fa8c652b --- /dev/null +++ b/clustering/marshalling/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> extends ExternalizerTester { + + private final Class targetClass; + + public EnumExternalizerTester(Externalizer 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/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/ExternalizerTestUtil.java b/clustering/marshalling/api/src/test/java/org/wildfly/clustering/marshalling/ExternalizerTester.java similarity index 68% rename from clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/ExternalizerTestUtil.java rename to clustering/marshalling/api/src/test/java/org/wildfly/clustering/marshalling/ExternalizerTester.java index cfb24060511c..7b659f08324e 100644 --- a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/ExternalizerTestUtil.java +++ b/clustering/marshalling/api/src/test/java/org/wildfly/clustering/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 { - public static > void test(Externalizer externalizer) throws IOException, ClassNotFoundException { - for (E value : EnumSet.allOf(externalizer.getTargetClass())) { - test(externalizer, value); - } + private final Externalizer externalizer; + private final BiConsumer assertion; + + public ExternalizerTester(Externalizer externalizer) { + this(externalizer, Assert::assertEquals); } - public static void test(Externalizer externalizer, T subject) throws IOException, ClassNotFoundException { - test(externalizer, subject, Assert::assertEquals); + public ExternalizerTester(Externalizer externalizer, BiConsumer assertion) { + this.externalizer = externalizer; + this.assertion = assertion; } - public static void test(Externalizer externalizer, T subject, BiConsumer 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 index c4b6266dcb4b..6beedf88727d 100644 --- a/clustering/marshalling/spi/pom.xml +++ b/clustering/marshalling/spi/pom.xml @@ -46,6 +46,13 @@ org.wildfly.security wildfly-elytron + + org.wildfly + wildfly-clustering-marshalling-api + ${project.version} + test + tests + diff --git a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/net/NetExternalizerTestCase.java b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/net/NetExternalizerTestCase.java index 225ae84cc3f5..78523e28d65b 100644 --- a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/net/NetExternalizerTestCase.java +++ b/clustering/marshalling/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/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/time/TimeExternalizerTestCase.java b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/time/TimeExternalizerTestCase.java index 5fe69322ce07..6a2810fc2f72 100644 --- a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/time/TimeExternalizerTestCase.java +++ b/clustering/marshalling/spi/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/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/AtomicExternalizerTestCase.java b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/AtomicExternalizerTestCase.java index fe6d139023f7..6b82ecfbcbf0 100644 --- a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/AtomicExternalizerTestCase.java +++ b/clustering/marshalling/spi/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(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(Boolean.TRUE)); } } diff --git a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/CollectionExternalizerTestCase.java b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/CollectionExternalizerTestCase.java index 4e227d2594ab..a917a7033ceb 100644 --- a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/CollectionExternalizerTestCase.java +++ b/clustering/marshalling/spi/src/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 basis = Arrays.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 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 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 > void test(Externalizer externalizer, T collection) throws ClassNotFoundException, IOException { - BiConsumer assertSize = (expected, actual) -> assertEquals(expected.size(), actual.size()); - BiConsumer 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 > void test(Externalizer 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 > void test(Externalizer externalizer, T iterator) throws ClassNotFoundException, IOException { - ExternalizerTestUtil.test(externalizer, iterator, (expected, actual) -> assertFalse(actual.hasNext())); + static > void assertCollectionEquals(T expected, T actual) { + Assert.assertEquals(expected.size(), actual.size()); + Assert.assertTrue(expected.containsAll(actual)); } } diff --git a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/DateExternalizerTestCase.java b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/DateExternalizerTestCase.java index 0b8d2ed8fe06..aa6813304840 100644 --- a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/DateExternalizerTestCase.java +++ b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/DateExternalizerTestCase.java @@ -33,7 +33,7 @@ import java.util.TimeZone; import org.junit.Test; -import org.wildfly.clustering.marshalling.spi.ExternalizerTestUtil; +import org.wildfly.clustering.marshalling.ExternalizerTester; import org.wildfly.clustering.marshalling.spi.DefaultExternalizer; /** @@ -44,18 +44,19 @@ public class DateExternalizerTestCase { @Test public void test() throws ClassNotFoundException, IOException { - ExternalizerTestUtil.test(DefaultExternalizer.DATE.cast(Date.class), Date.from(Instant.now())); - ExternalizerTestUtil.test(DefaultExternalizer.SQL_DATE.cast(java.sql.Date.class), java.sql.Date.valueOf(LocalDate.now())); - ExternalizerTestUtil.test(DefaultExternalizer.SQL_TIME.cast(java.sql.Time.class), java.sql.Time.valueOf(LocalTime.now())); - ExternalizerTestUtil.test(DefaultExternalizer.SQL_TIMESTAMP.cast(java.sql.Timestamp.class), java.sql.Timestamp.valueOf(LocalDateTime.now())); + new ExternalizerTester<>(DefaultExternalizer.DATE.cast(Date.class)).test(Date.from(Instant.now())); + new ExternalizerTester<>(DefaultExternalizer.SQL_DATE.cast(java.sql.Date.class)).test(java.sql.Date.valueOf(LocalDate.now())); + new ExternalizerTester<>(DefaultExternalizer.SQL_TIME.cast(java.sql.Time.class)).test(java.sql.Time.valueOf(LocalTime.now())); + new ExternalizerTester<>(DefaultExternalizer.SQL_TIMESTAMP.cast(java.sql.Timestamp.class)).test(java.sql.Timestamp.valueOf(LocalDateTime.now())); + ExternalizerTester calendarTester = new ExternalizerTester<>(DefaultExternalizer.CALENDAR.cast(Calendar.class)); // Validate default calendar - ExternalizerTestUtil.test(DefaultExternalizer.CALENDAR.cast(Calendar.class), Calendar.getInstance()); + calendarTester.test(Calendar.getInstance()); // Validate Gregorian calendar w/locale - ExternalizerTestUtil.test(DefaultExternalizer.CALENDAR.cast(Calendar.class), new Calendar.Builder().setLenient(false).setLocale(Locale.FRANCE).build()); + calendarTester.test(new Calendar.Builder().setLenient(false).setLocale(Locale.FRANCE).build()); // Validate Japanese Imperial calendar - ExternalizerTestUtil.test(DefaultExternalizer.CALENDAR.cast(Calendar.class), Calendar.getInstance(TimeZone.getTimeZone("Asia/Tokyo"), Locale.JAPAN)); + calendarTester.test(Calendar.getInstance(TimeZone.getTimeZone("Asia/Tokyo"), Locale.JAPAN)); // Validate Buddhist calendar - ExternalizerTestUtil.test(DefaultExternalizer.CALENDAR.cast(Calendar.class), Calendar.getInstance(TimeZone.getTimeZone("Asia/Bangkok"), Locale.forLanguageTag("th_TH"))); + calendarTester.test(Calendar.getInstance(TimeZone.getTimeZone("Asia/Bangkok"), Locale.forLanguageTag("th_TH"))); } } diff --git a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/MapEntryExternalizerTestCase.java b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/MapEntryExternalizerTestCase.java index d86afbd39ad1..214cce721b03 100644 --- a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/MapEntryExternalizerTestCase.java +++ b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/MapEntryExternalizerTestCase.java @@ -26,7 +26,7 @@ import java.util.AbstractMap; import org.junit.Test; -import org.wildfly.clustering.marshalling.spi.ExternalizerTestUtil; +import org.wildfly.clustering.marshalling.ExternalizerTester; import org.wildfly.clustering.marshalling.spi.DefaultExternalizer; /** @@ -39,7 +39,7 @@ public class MapEntryExternalizerTestCase { public void test() throws ClassNotFoundException, IOException { Object key = "key"; Object value = "value"; - ExternalizerTestUtil.test(DefaultExternalizer.SIMPLE_ENTRY.cast(AbstractMap.SimpleEntry.class), new AbstractMap.SimpleEntry<>(key, value)); - ExternalizerTestUtil.test(DefaultExternalizer.SIMPLE_IMMUTABLE_ENTRY.cast(AbstractMap.SimpleImmutableEntry.class), new AbstractMap.SimpleImmutableEntry<>(key, value)); + new ExternalizerTester<>(DefaultExternalizer.SIMPLE_ENTRY.cast(AbstractMap.SimpleEntry.class)).test(new AbstractMap.SimpleEntry<>(key, value)); + new ExternalizerTester<>(DefaultExternalizer.SIMPLE_IMMUTABLE_ENTRY.cast(AbstractMap.SimpleImmutableEntry.class)).test(new AbstractMap.SimpleImmutableEntry<>(key, value)); } } diff --git a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/MapExternalizerTestCase.java b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/MapExternalizerTestCase.java index 9663e66e6ea7..e049dccc19e8 100644 --- a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/MapExternalizerTestCase.java +++ b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/MapExternalizerTestCase.java @@ -22,9 +22,6 @@ package org.wildfly.clustering.marshalling.spi.util; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - import java.io.IOException; import java.util.Collections; import java.util.HashMap; @@ -35,13 +32,12 @@ import java.util.TreeMap; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentSkipListMap; -import java.util.function.BiConsumer; import java.util.stream.Collectors; import java.util.stream.Stream; +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; /** @@ -54,23 +50,25 @@ public class MapExternalizerTestCase { @Test public void test() throws ClassNotFoundException, IOException { Map basis = Stream.of(1, 2, 3, 4, 5).collect(Collectors.toMap(i -> i, i -> Integer.toString(i))); - test(DefaultExternalizer.CONCURRENT_HASH_MAP.cast(ConcurrentHashMap.class), new ConcurrentHashMap<>(basis)); - test(DefaultExternalizer.HASH_MAP.cast(HashMap.class), new HashMap<>(basis)); - test(DefaultExternalizer.LINKED_HASH_MAP.cast(LinkedHashMap.class), new LinkedHashMap<>(basis)); + new ExternalizerTester<>(DefaultExternalizer.CONCURRENT_HASH_MAP.cast(ConcurrentHashMap.class), MapExternalizerTestCase::assertMapEquals).test(new ConcurrentHashMap<>(basis)); + new ExternalizerTester<>(DefaultExternalizer.HASH_MAP.cast(HashMap.class), MapExternalizerTestCase::assertMapEquals).test(new HashMap<>(basis)); + new ExternalizerTester<>(DefaultExternalizer.LINKED_HASH_MAP.cast(LinkedHashMap.class), MapExternalizerTestCase::assertMapEquals).test(new LinkedHashMap<>(basis)); - test(DefaultExternalizer.EMPTY_MAP.cast(Map.class), Collections.emptyMap()); - test(DefaultExternalizer.EMPTY_NAVIGABLE_MAP.cast(NavigableMap.class), Collections.emptyNavigableMap()); - test(DefaultExternalizer.EMPTY_SORTED_MAP.cast(SortedMap.class), Collections.emptySortedMap()); + new ExternalizerTester<>(DefaultExternalizer.EMPTY_MAP.cast(Map.class), Assert::assertSame).test(Collections.emptyMap()); + new ExternalizerTester<>(DefaultExternalizer.EMPTY_NAVIGABLE_MAP.cast(NavigableMap.class), Assert::assertSame).test(Collections.emptyNavigableMap()); + new ExternalizerTester<>(DefaultExternalizer.EMPTY_SORTED_MAP.cast(SortedMap.class), Assert::assertSame).test(Collections.emptySortedMap()); - test(DefaultExternalizer.SINGLETON_MAP.cast(Map.class), Collections.singletonMap(1, 2)); + new ExternalizerTester<>(DefaultExternalizer.SINGLETON_MAP.cast(Map.class), MapExternalizerTestCase::assertMapEquals).test(Collections.singletonMap(1, 2)); - test(DefaultExternalizer.CONCURRENT_SKIP_LIST_MAP.cast(ConcurrentSkipListMap.class), new ConcurrentSkipListMap<>(basis)); - test(DefaultExternalizer.TREE_MAP.cast(TreeMap.class), new TreeMap<>(basis)); + new ExternalizerTester<>(DefaultExternalizer.CONCURRENT_SKIP_LIST_MAP.cast(ConcurrentSkipListMap.class), MapExternalizerTestCase::assertMapEquals).test(new ConcurrentSkipListMap<>(basis)); + new ExternalizerTester<>(DefaultExternalizer.TREE_MAP.cast(TreeMap.class), MapExternalizerTestCase::assertMapEquals).test(new TreeMap<>(basis)); } - public static > void test(Externalizer externalizer, T collection) throws ClassNotFoundException, IOException { - BiConsumer assertSize = (expected, actual) -> assertEquals(expected.size(), actual.size()); - BiConsumer assertContents = (expected, actual) -> assertTrue(actual.keySet().containsAll(expected.keySet())); - ExternalizerTestUtil.test(externalizer, collection, assertSize.andThen(assertContents)); + static > void assertMapEquals(T expected, T actual) { + Assert.assertEquals(expected.size(), actual.size()); + Assert.assertTrue(expected.keySet().containsAll(actual.keySet())); + for (Map.Entry entry : expected.entrySet()) { + Assert.assertEquals(entry.getValue(), actual.get(entry.getKey())); + } } } diff --git a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/UtilExternalizerTestCase.java b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/UtilExternalizerTestCase.java index 770534aabcf8..7a0092e6caa0 100644 --- a/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/UtilExternalizerTestCase.java +++ b/clustering/marshalling/spi/src/test/java/org/wildfly/clustering/marshalling/spi/util/UtilExternalizerTestCase.java @@ -32,7 +32,8 @@ import java.util.concurrent.TimeUnit; 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; /** @@ -43,14 +44,14 @@ public class UtilExternalizerTestCase { @Test public void test() throws ClassNotFoundException, IOException { - ExternalizerTestUtil.test(DefaultExternalizer.CURRENCY.cast(Currency.class), Currency.getInstance(Locale.US)); - ExternalizerTestUtil.test(DefaultExternalizer.LOCALE.cast(Locale.class), Locale.US); - ExternalizerTestUtil.test(DefaultExternalizer.NATURAL_ORDER_COMPARATOR.cast(Comparator.class), Comparator.naturalOrder()); - ExternalizerTestUtil.test(DefaultExternalizer.OPTIONAL.cast(Optional.class), Optional.empty()); - ExternalizerTestUtil.test(DefaultExternalizer.REVERSE_ORDER_COMPARATOR.cast(Comparator.class), Comparator.reverseOrder()); - ExternalizerTestUtil.test(DefaultExternalizer.TIME_UNIT.cast(TimeUnit.class)); - ExternalizerTestUtil.test(DefaultExternalizer.TIME_ZONE.cast(TimeZone.class), TimeZone.getDefault()); - ExternalizerTestUtil.test(DefaultExternalizer.TIME_ZONE.cast(TimeZone.class), TimeZone.getTimeZone("America/New_York")); - ExternalizerTestUtil.test(DefaultExternalizer.UUID.cast(UUID.class), UUID.randomUUID()); + new ExternalizerTester<>(DefaultExternalizer.CURRENCY.cast(Currency.class)).test(Currency.getInstance(Locale.US)); + new ExternalizerTester<>(DefaultExternalizer.LOCALE.cast(Locale.class)).test(Locale.US); + new ExternalizerTester<>(DefaultExternalizer.NATURAL_ORDER_COMPARATOR.cast(Comparator.class)).test(Comparator.naturalOrder()); + new ExternalizerTester<>(DefaultExternalizer.OPTIONAL.cast(Optional.class)).test(Optional.empty()); + new ExternalizerTester<>(DefaultExternalizer.REVERSE_ORDER_COMPARATOR.cast(Comparator.class)).test(Comparator.reverseOrder()); + new EnumExternalizerTester<>(DefaultExternalizer.TIME_UNIT.cast(TimeUnit.class)).test(); + new ExternalizerTester<>(DefaultExternalizer.TIME_ZONE.cast(TimeZone.class)).test(TimeZone.getDefault()); + new ExternalizerTester<>(DefaultExternalizer.TIME_ZONE.cast(TimeZone.class)).test(TimeZone.getTimeZone("America/New_York")); + new ExternalizerTester<>(DefaultExternalizer.UUID.cast(UUID.class)).test(UUID.randomUUID()); } }