Test that a sequence remains "valid" after is has been modified.

test/aud/exam/prep/SequenceProcessorTest.java

@@ -24,6 +24,8 @@ public abstract class SequenceProcessorTest<S> {
     @ArgumentsSource(ListProvider.class)
     void testThat_createAndIterateWork(List<Integer> list) {
         S s = processor.create(list);
+
+        assertTrue(processor.check(s));
         assertIterableEquals(list, processor.iterate(s));
     }
 
@@ -69,6 +71,8 @@ public abstract class SequenceProcessorTest<S> {
         S s = processor.create(list);
         assertFalse(processor.override(s, -1, -5));
         assertFalse(processor.override(s, 999, -5));
+
+        assertTrue(processor.check(s));
         assertIterableEquals(list, processor.iterate(s));
     }
 
@@ -82,6 +86,7 @@ public abstract class SequenceProcessorTest<S> {
             assertTrue(processor.override(s, list.get(i), to));
             list.set(i, to);
 
+            assertTrue(processor.check(s));
             assertIterableEquals(list, processor.iterate(s));
         }
     }
@@ -92,6 +97,8 @@ public abstract class SequenceProcessorTest<S> {
         S s = processor.create(list);
         assertFalse(processor.overrideAll(s, -1, -5));
         assertFalse(processor.overrideAll(s, 999, -5));
+
+        assertTrue(processor.check(s));
         assertIterableEquals(list, processor.iterate(s));
     }
 
@@ -107,6 +114,7 @@ public abstract class SequenceProcessorTest<S> {
             list.replaceAll(k ->
                 Objects.equals(k, from) ? to : k);
 
+            assertTrue(processor.check(s));
             assertIterableEquals(list, processor.iterate(s));
         }
     }
@@ -117,6 +125,8 @@ public abstract class SequenceProcessorTest<S> {
         S s = processor.create(list);
         assertFalse(processor.overrideAt(s, -5, -1));
         assertFalse(processor.overrideAt(s, -5, 999));
+
+        assertTrue(processor.check(s));
         assertIterableEquals(list, processor.iterate(s));
     }
 
@@ -130,6 +140,7 @@ public abstract class SequenceProcessorTest<S> {
             assertTrue(processor.overrideAt(s, to, i));
             list.set(i, to);
 
+            assertTrue(processor.check(s));
             assertIterableEquals(list, processor.iterate(s));
         }
     }
@@ -146,6 +157,7 @@ public abstract class SequenceProcessorTest<S> {
             list.add(i);
             list.sort(cmp);
 
+            assertTrue(processor.check(s));
             assertIterableEquals(list, processor.iterate(s));
         }
     }
@@ -156,6 +168,8 @@ public abstract class SequenceProcessorTest<S> {
         S s = processor.create(list);
         assertFalse(processor.remove(s, -1));
         assertFalse(processor.remove(s, 999));
+
+        assertTrue(processor.check(s));
         assertIterableEquals(list, processor.iterate(s));
     }
 
@@ -170,6 +184,7 @@ public abstract class SequenceProcessorTest<S> {
             list.remove(toRemove);
             assertTrue(processor.remove(s, toRemove));
 
+            assertTrue(processor.check(s));
             assertIterableEquals(list, processor.iterate(s));
         }
     }
@@ -180,6 +195,8 @@ public abstract class SequenceProcessorTest<S> {
         S s = processor.create(list);
         assertFalse(processor.removeAll(s, -1));
         assertFalse(processor.removeAll(s, 999));
+
+        assertTrue(processor.check(s));
         assertIterableEquals(list, processor.iterate(s));
     }
 
@@ -194,6 +211,7 @@ public abstract class SequenceProcessorTest<S> {
             list.removeAll(Collections.singleton(toRemove));
             assertTrue(processor.removeAll(s, toRemove));
 
+            assertTrue(processor.check(s));
             assertIterableEquals(list, processor.iterate(s));
         }
     }
@@ -343,8 +361,8 @@ public abstract class SequenceProcessorTest<S> {
             processor.isLexSmaller(a, b, cmp));
 
         assertEquals(
-                stringB.compareTo(stringA) < 0,
+            stringB.compareTo(stringA) < 0,
-                processor.isLexSmaller(b, a, cmp));
+            processor.isLexSmaller(b, a, cmp));
     }
 
     protected S toSequenceByAscii(String string) {
@@ -367,6 +385,7 @@ public abstract class SequenceProcessorTest<S> {
             .collect(Collectors.toList());
 
         processor.doubleAllKeys(s);
+        assertTrue(processor.check(s));
         assertIterableEquals(list, processor.iterate(s));
     }
 
@@ -382,6 +401,7 @@ public abstract class SequenceProcessorTest<S> {
 
         s = processor.rotateRight(s);
 
+        assertTrue(processor.check(s));
         assertIterableEquals(list, processor.iterate(s));
     }
 
@@ -397,6 +417,7 @@ public abstract class SequenceProcessorTest<S> {
 
         s = processor.rotateLeft(s);
 
+        assertTrue(processor.check(s));
         assertIterableEquals(list, processor.iterate(s));
     }
 
@@ -414,6 +435,7 @@ public abstract class SequenceProcessorTest<S> {
 
         processor.removeDuplicates(s);
 
+        assertTrue(processor.check(s));
         assertIterableEquals(noDuplicatesList, processor.iterate(s));
     }
 }