Adds unit tests.

Author: brianburton

pom.xml

@@ -218,15 +218,17 @@
                     <classpathScope>test</classpathScope>
                     <arguments>
                         <argument>-classpath</argument>
-                        <classpath />
+                        <classpath/>
                         <argument>-ea</argument>
                         <argument>org.javimmutable.collections.stress_test.RunStressTests</argument>
-<!--
                         <argument>&#45;&#45;test</argument>
-                        <argument>hashmap</argument>
-                        <argument>&#45;&#45;test</argument>
-                        <argument>hashset</argument>
--->
+                        <argument>insertordermap</argument>
+                        <!--
+                                                <argument>&#45;&#45;test</argument>
+                                                <argument>hashmap</argument>
+                                                <argument>&#45;&#45;test</argument>
+                                                <argument>hashset</argument>
+                        -->
                     </arguments>
                 </configuration>
             </plugin>

src/main/java/org/javimmutable/collections/array/TrieLongArrayNode.java

@@ -120,6 +120,23 @@ public GenericIterator.Iterable<JImmutableMap.Entry<Long, T>> entries()
                         nodeIndex -> nodes[nodeIndex].entries());
     }
 
+    public void checkInvariants()
+    {
+        if (bitCount(valuesBitmask) != values.length) {
+            throw new IllegalStateException(String.format("invalid bitmask for values array: bitmask=%s length=%d", Long.toBinaryString(valuesBitmask), values.length));
+        }
+        if (bitCount(nodesBitmask) != nodes.length) {
+            throw new IllegalStateException(String.format("invalid bitmask for nodes array: bitmask=%s length=%d", Long.toBinaryString(nodesBitmask), nodes.length));
+        }
+        if (!checkChildShifts(shiftCount, nodes)) {
+            throw new IllegalStateException("one or more nodes invalid for this branch");
+        }
+        final int computedSize = computeSize(nodes) + values.length;
+        if (computedSize != size) {
+            throw new IllegalStateException(String.format("size mismatch: size=%d computed=%d", size, computedSize));
+        }
+    }
+
     private T getValueOrImpl(int shiftCountForValue,
                              long index,
                              T defaultValue)

src/test/java/org/javimmutable/collections/array/TrieLongArrayNodeTest.java

@@ -2,15 +2,67 @@
 
 import junit.framework.TestCase;
 import org.javimmutable.collections.common.LongArrayMappedTrieMath;
+import org.javimmutable.collections.iterators.StandardIteratorTests;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 import java.util.Random;
+import java.util.TreeMap;
 
 import static java.lang.Long.*;
 import static org.javimmutable.collections.array.TrieLongArrayNode.flip;
 
 public class TrieLongArrayNodeTest
     extends TestCase
 {
+    public void testRandom()
+    {
+        final Random r = new Random(234567);
+        final Map<Long, Integer> known = new TreeMap<>();
+        final List<Long> indexes = new ArrayList<>();
+        final List<Integer> values = new ArrayList<>();
+        TrieLongArrayNode<Integer> array = TrieLongArrayNode.empty();
+        int length = 7;
+        for (int loop = 1; loop <= 5; ++loop) {
+            for (Long index : new ArrayList<>(known.keySet())) {
+                if (r.nextInt(3) == 1) {
+                    known.put(index, r.nextInt());
+                }
+            }
+            for (int i = known.size(); i < length; ++i) {
+                known.put(r.nextLong(), r.nextInt());
+            }
+            indexes.clear();
+            indexes.addAll(known.keySet());
+            for (Long index : indexes) {
+                array = array.assign(index, known.get(index));
+            }
+            values.clear();
+            values.addAll(known.values());
+
+            array.checkInvariants();
+            StandardIteratorTests.listIteratorTest(indexes, array.keys().iterator());
+            StandardIteratorTests.listIteratorTest(values, array.values().iterator());
+            length = 17 * length;
+            values.clear();
+        }
+
+        Collections.shuffle(indexes, r);
+        final int checkInterval = indexes.size() / 7;
+        for (Long index : indexes) {
+            known.remove(index);
+            array = array.delete(index);
+            if (known.size() % checkInterval == 0) {
+                array.checkInvariants();
+                StandardIteratorTests.listIteratorTest(new ArrayList<>(known.keySet()), array.keys().iterator());
+                StandardIteratorTests.listIteratorTest(new ArrayList<>(known.values()), array.values().iterator());
+            }
+        }
+        assertEquals(0, array.size());
+    }
+
     public void testFlip()
     {
         assertEquals(0L, flip(Long.MIN_VALUE));