Skip to content

Commit 022876c

Browse files
brianburtonbrianburton
committed
adds serialization checks to stress testers
1 parent 768b5d5 commit 022876c

12 files changed

+988
-834
lines changed

‎src/main/java/org/javimmutable/collections/common/ExpectedOrderSorter.java‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -79,6 +79,20 @@ public <U, C extends Collection<U>> List<U> sort(@Nonnull C collection,
7979
return sorted;
8080
}
8181

82+
/**
83+
* Creates a new List containing all of the elements of collection sorted based on the Iterator.
84+
*/
85+
public <U> Iterator<U> sort(@Nonnull Iterator<U> iterator,
86+
@Nonnull Function<U, T> mapper)
87+
{
88+
List<U> sorted = new ArrayList<>();
89+
while (iterator.hasNext()) {
90+
sorted.add(iterator.next());
91+
}
92+
sorted.sort(comparator(mapper));
93+
return sorted.iterator();
94+
}
95+
8296
private <U> Comparator<U> comparator(@Nonnull Function<U, T> mapper)
8397
{
8498
return new Comparator<U>()

‎src/test/java/org/javimmutable/collections/common/StandardSerializableTests.java‎

Lines changed: 50 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -54,8 +54,17 @@
5454
public class StandardSerializableTests
5555
extends TestCase
5656
{
57-
public static void verifySerializable(Object source,
58-
String oldSerializedBase64)
57+
/**
58+
* Iterator factory for Iterable objects that just calls iterator() method.
59+
*/
60+
public static final Func1<Object, Iterator> standardIteratorFactory = o -> ((Iterable)o).iterator();
61+
62+
/**
63+
* Intended for unit tests of non-iterable objects. Just performs normal test and
64+
* backwards compatibility test.
65+
*/
66+
public static void verifySerializable(@Nonnull Object source,
67+
@Nonnull String oldSerializedBase64)
5968
throws Exception
6069
{
6170
byte[] bytes = serialize(source);
@@ -76,6 +85,9 @@ public static void verifySerializable(Object source,
7685
assertEquals(source, dest);
7786
}
7887

88+
/**
89+
* Intended for unit tests. Performs iterator and extra tests as well as backwards compatibility test.
90+
*/
7991
public static void verifySerializable(@Nonnull Func1<Object, Iterator> iteratorFactory,
8092
@Nullable BiConsumer extraChecks,
8193
@Nonnull Object source,
@@ -106,6 +118,28 @@ public static void verifySerializable(@Nonnull Func1<Object, Iterator> iteratorF
106118
verifyIterator(iteratorFactory.apply(source), iteratorFactory.apply(dest));
107119
}
108120

121+
/**
122+
* Intended for use by stress tester. Performs extra checks but not a backwards compatibility check.
123+
*/
124+
public static void verifySerializable(@Nullable BiConsumer extraChecks,
125+
@Nonnull Object source)
126+
{
127+
try {
128+
byte[] bytes = serialize(source);
129+
Object dest = deserialize(bytes);
130+
assertEquals(source.getClass().getName(), dest.getClass().getName());
131+
assertEquals(source, dest);
132+
performExtraChecks(extraChecks, source, dest);
133+
134+
dest = deserialize(serialize(dest));
135+
assertEquals(source.getClass().getName(), dest.getClass().getName());
136+
assertEquals(source, dest);
137+
performExtraChecks(extraChecks, source, dest);
138+
} catch (Exception ex) {
139+
throw new RuntimeException(ex);
140+
}
141+
}
142+
109143
@SuppressWarnings("unchecked")
110144
private static void performExtraChecks(@Nullable BiConsumer extraChecks,
111145
@Nonnull Object source,
@@ -134,6 +168,20 @@ private static Object deserialize(byte[] source)
134168
}
135169
}
136170

171+
private static void verifyUnorderedIterator(@Nonnull Func1<Object, Iterator> iteratorFactory,
172+
Object source,
173+
Object dest)
174+
{
175+
ExpectedOrderSorter<Object> sorter = new ExpectedOrderSorter(iteratorFactory.apply(source));
176+
Iterator expected = iteratorFactory.apply(source);
177+
Iterator actual = sorter.sort(iteratorFactory.apply(dest), i -> i);
178+
while (expected.hasNext()) {
179+
assertEquals(expected.hasNext(), actual.hasNext());
180+
assertEquals(expected.next(), actual.next());
181+
}
182+
assertEquals(expected.hasNext(), actual.hasNext());
183+
}
184+
137185
private static void verifyIterator(Iterator expected,
138186
Iterator actual)
139187
{

‎src/test/java/org/javimmutable/collections/listmap/AbstractJImmutableListMapTestCase.java‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -169,23 +169,23 @@ private static void verifyCollector(JImmutableListMap<Integer, Integer> template
169169
{
170170
List<JImmutableMap.Entry<Integer, Integer>> values = IntStream.range(1, 2500).boxed().map(i -> MapEntry.of(i, -i)).collect(Collectors.toList());
171171
switch (ordering) {
172-
case HASH: {
173-
Set<JImmutableMap.Entry<Integer, Integer>> entries = template.deleteAll().insertAll(values).entries().parallelStream().collect(Collectors.toSet());
174-
Set<JImmutableMap.Entry<Integer, Integer>> expected = new HashSet<>(values);
175-
assertEquals(expected, entries);
176-
break;
177-
}
178-
case INORDER: {
179-
List<JImmutableMap.Entry<Integer, Integer>> entries = template.deleteAll().insertAll(values).entries().parallelStream().collect(Collectors.toList());
180-
assertEquals(values, entries);
181-
break;
182-
}
183-
case REVERSED: {
184-
List<JImmutableMap.Entry<Integer, Integer>> entries = template.deleteAll().insertAll(values).entries().parallelStream().collect(Collectors.toList());
185-
Collections.reverse(entries);
186-
assertEquals(values, entries);
187-
break;
188-
}
172+
case HASH: {
173+
Set<JImmutableMap.Entry<Integer, Integer>> entries = template.deleteAll().insertAll(values).entries().parallelStream().collect(Collectors.toSet());
174+
Set<JImmutableMap.Entry<Integer, Integer>> expected = new HashSet<>(values);
175+
assertEquals(expected, entries);
176+
break;
177+
}
178+
case INORDER: {
179+
List<JImmutableMap.Entry<Integer, Integer>> entries = template.deleteAll().insertAll(values).entries().parallelStream().collect(Collectors.toList());
180+
assertEquals(values, entries);
181+
break;
182+
}
183+
case REVERSED: {
184+
List<JImmutableMap.Entry<Integer, Integer>> entries = template.deleteAll().insertAll(values).entries().parallelStream().collect(Collectors.toList());
185+
Collections.reverse(entries);
186+
assertEquals(values, entries);
187+
break;
188+
}
189189
}
190190

191191
JImmutableListMap<Integer, Integer> expected = template.insertAll(values);

‎src/test/java/org/javimmutable/collections/stress_test/AbstractListStressTestable.java‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,8 @@
4242

4343
import java.util.List;
4444

45+
import static org.javimmutable.collections.common.StandardSerializableTests.verifySerializable;
46+
4547
public abstract class AbstractListStressTestable
4648
extends AbstractStressTestable
4749
{
@@ -68,6 +70,7 @@ protected void verifyContents(JImmutableList<String> list,
6870
throw new RuntimeException("method call failed - getList()\n");
6971
}
7072
list.checkInvariants();
73+
verifySerializable(null, list);
7174
}
7275

7376
protected void verifyCursor(JImmutableList<String> list,

‎src/test/java/org/javimmutable/collections/stress_test/JImmutableArrayStressTester.java‎

Lines changed: 62 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,8 @@
5151
import java.util.Random;
5252
import java.util.TreeMap;
5353

54+
import static org.javimmutable.collections.common.StandardSerializableTests.verifySerializable;
55+
5456
/**
5557
* Test program for all implementations of JImmutableArray. Divided into four sections: growing
5658
* (adds new values at random indices), updating (changes the value at existing indices), shrinking
@@ -59,7 +61,7 @@
5961
*/
6062
@SuppressWarnings("Duplicates")
6163
public class JImmutableArrayStressTester
62-
extends AbstractStressTestable
64+
extends AbstractStressTestable
6365
{
6466
private final JImmutableArray<String> array;
6567
private final ArrayIndexRange indexRange;
@@ -95,19 +97,19 @@ public void execute(Random random,
9597
indexList = indexList.insert(index);
9698
String value = RandomKeyManager.makeValue(tokens, random);
9799
switch (random.nextInt(2)) {
98-
case 0: {//assign(int, T)
99-
array = array.assign(index, value);
100-
expected.put(index, value);
101-
break;
102-
}
103-
case 1: { //insert(Entry<Integer, T>)
104-
JImmutableMap.Entry<Integer, String> entry = new MapEntry<>(index, value);
105-
array = (JImmutableArray<String>)array.insert(entry);
106-
expected.put(index, value);
107-
break;
108-
}
109-
default:
110-
throw new RuntimeException();
100+
case 0: {//assign(int, T)
101+
array = array.assign(index, value);
102+
expected.put(index, value);
103+
break;
104+
}
105+
case 1: { //insert(Entry<Integer, T>)
106+
JImmutableMap.Entry<Integer, String> entry = new MapEntry<>(index, value);
107+
array = (JImmutableArray<String>)array.insert(entry);
108+
expected.put(index, value);
109+
break;
110+
}
111+
default:
112+
throw new RuntimeException();
111113
}
112114
}
113115
verifyContents(array, expected);
@@ -118,19 +120,19 @@ public void execute(Random random,
118120
int index = indexList.get(random.nextInt(indexList.size()));
119121
String value = RandomKeyManager.makeValue(tokens, random);
120122
switch (random.nextInt(2)) {
121-
case 0: { //assign(int, T)
122-
array = array.assign(index, value);
123-
expected.put(index, value);
124-
break;
125-
}
126-
case 1: { //insert(Entry<Integer, T>)
127-
JImmutableMap.Entry<Integer, String> entry = new MapEntry<>(index, value);
128-
array = (JImmutableArray<String>)array.insert(entry);
129-
expected.put(index, value);
130-
break;
131-
}
132-
default:
133-
throw new RuntimeException();
123+
case 0: { //assign(int, T)
124+
array = array.assign(index, value);
125+
expected.put(index, value);
126+
break;
127+
}
128+
case 1: { //insert(Entry<Integer, T>)
129+
JImmutableMap.Entry<Integer, String> entry = new MapEntry<>(index, value);
130+
array = (JImmutableArray<String>)array.insert(entry);
131+
expected.put(index, value);
132+
break;
133+
}
134+
default:
135+
throw new RuntimeException();
134136
}
135137
}
136138
verifyContents(array, expected);
@@ -159,43 +161,43 @@ public void execute(Random random,
159161
for (int i = 0; i < size / 12; ++i) {
160162
int index = (random.nextBoolean()) ? indexRange.randomIndex(random) : indexList.get(random.nextInt(indexList.size()));
161163
switch (random.nextInt(4)) {
162-
case 0: { //get(int)
163-
String value = array.get(index);
164-
String expectedValue = expected.getOrDefault(index, null);
165-
if (!((value == null && expectedValue == null) || (expectedValue != null && expectedValue.equals(value)))) {
166-
throw new RuntimeException(String.format("get(index) method call failed for %d - expected %s found %s%n", index, expectedValue, value));
167-
}
168-
break;
164+
case 0: { //get(int)
165+
String value = array.get(index);
166+
String expectedValue = expected.getOrDefault(index, null);
167+
if (!((value == null && expectedValue == null) || (expectedValue != null && expectedValue.equals(value)))) {
168+
throw new RuntimeException(String.format("get(index) method call failed for %d - expected %s found %s%n", index, expectedValue, value));
169+
}
170+
break;
169171

170-
}
171-
case 1: { //getValueOr(int, T)
172-
String value = array.getValueOr(index, "");
173-
String expectedValue = expected.getOrDefault(index, "");
174-
assert value != null;
175-
if (!value.equals(expectedValue)) {
176-
throw new RuntimeException(String.format("getValueOr(index, default) method call failed for %d - expected %s found %s%n", index, expectedValue, value));
177172
}
178-
break;
173+
case 1: { //getValueOr(int, T)
174+
String value = array.getValueOr(index, "");
175+
String expectedValue = expected.getOrDefault(index, "");
176+
assert value != null;
177+
if (!value.equals(expectedValue)) {
178+
throw new RuntimeException(String.format("getValueOr(index, default) method call failed for %d - expected %s found %s%n", index, expectedValue, value));
179+
}
180+
break;
179181

180-
}
181-
case 2: { //find(int)
182-
Holder<String> holder = array.find(index);
183-
Holder<String> expectedHolder = (expected.containsKey(index)) ? Holders.of(expected.get(index)) : Holders.of();
184-
if (!equivalentHolder(holder, expectedHolder)) {
185-
throw new RuntimeException(String.format("find(index) method call failed for %d - expected %s found %s%n", index, expectedHolder, holder));
186182
}
187-
break;
188-
}
189-
case 3: { //findEntry(int)
190-
Holder<JImmutableMap.Entry<Integer, String>> holder = array.findEntry(index);
191-
Holder<JImmutableMap.Entry<Integer, String>> expectedHolder = (expected.containsKey(index)) ? Holders.of(new MapEntry<>(index, expected.get(index))) : Holders.of();
192-
if (!equivalentHolder(holder, expectedHolder)) {
193-
throw new RuntimeException(String.format("findEntry(index) method call failed for %d - expected %s found %s%n", index, expectedHolder, holder));
183+
case 2: { //find(int)
184+
Holder<String> holder = array.find(index);
185+
Holder<String> expectedHolder = (expected.containsKey(index)) ? Holders.of(expected.get(index)) : Holders.of();
186+
if (!equivalentHolder(holder, expectedHolder)) {
187+
throw new RuntimeException(String.format("find(index) method call failed for %d - expected %s found %s%n", index, expectedHolder, holder));
188+
}
189+
break;
194190
}
195-
break;
196-
}
197-
default:
198-
throw new RuntimeException();
191+
case 3: { //findEntry(int)
192+
Holder<JImmutableMap.Entry<Integer, String>> holder = array.findEntry(index);
193+
Holder<JImmutableMap.Entry<Integer, String>> expectedHolder = (expected.containsKey(index)) ? Holders.of(new MapEntry<>(index, expected.get(index))) : Holders.of();
194+
if (!equivalentHolder(holder, expectedHolder)) {
195+
throw new RuntimeException(String.format("findEntry(index) method call failed for %d - expected %s found %s%n", index, expectedHolder, holder));
196+
}
197+
break;
198+
}
199+
default:
200+
throw new RuntimeException();
199201
}
200202
}
201203
verifyCursor(array, expected);
@@ -244,6 +246,7 @@ public void verifyContents(JImmutableArray<String> array,
244246
throw new RuntimeException("method call failed - getMap()\n");
245247
}
246248
array.checkInvariants();
249+
verifySerializable(null, array);
247250
}
248251

249252
private void verifyCursor(JImmutableArray<String> array,

0 commit comments

Comments
 (0)