Remove access to underlying containers inside Graph and Node.

src/test/org/insa/algo/utils/BinaryHeapTest.java

@@ -11,29 +11,68 @@ import org.junit.Test;
 
 public class BinaryHeapTest {
 
-    private int[] data1 = IntStream.range(0, 20).toArray();
-    private int[] data2 = { 8, 1, 6, 3, 4, 5, 9 };
+    class MutableInteger implements Comparable<MutableInteger> {
 
-    private BinaryHeap<Integer> heap1, heap2;
+        // Actual value
+        private int value;
+
+        public MutableInteger(int value) {
+            this.value = value;
+        }
+
+        /**
+         * @return The integer value stored inside this MutableInteger.
+         */
+        public int get() {
+            return this.value;
+        }
+
+        /**
+         * Update the integer value stored inside this MutableInteger.
+         * 
+         * @param value New value to set.
+         */
+        public void set(int value) {
+            this.value = value;
+        }
+
+        @Override
+        public int compareTo(MutableInteger other) {
+            return Integer.compare(this.value, other.value);
+        }
+
+    };
+
+    // Raw data arrays.
+    private MutableInteger[] data1 = IntStream.range(0, 20).mapToObj(MutableInteger::new)
+            .toArray(MutableInteger[]::new);
+    private MutableInteger[] data2 = Arrays.stream(new int[] { 8, 1, 6, 3, 4, 5, 9 })
+            .mapToObj(MutableInteger::new).toArray(MutableInteger[]::new);
+
+    // Actual heap.
+    private BinaryHeap<MutableInteger> heap1, heap2;
 
     @Before
     public void init() {
         // Create the range heap
-        this.heap1 = new BinaryHeap<Integer>();
-        this.heap2 = new BinaryHeap<Integer>();
+        this.heap1 = new BinaryHeap<>();
+        this.heap2 = new BinaryHeap<>();
 
-        for (int v: data1)
-            this.heap1.insert(v);
-        for (int v: data2)
-            this.heap2.insert(v);
+        for (MutableInteger v: data1) {
+            this.heap1.add(v);
+        }
+
+        for (MutableInteger v: data2) {
+            this.heap2.add(v);
+        }
     }
 
     @Test
     public void testInsert() {
-        BinaryHeap<Integer> heap = new BinaryHeap<Integer>();
+        BinaryHeap<MutableInteger> heap = new BinaryHeap<>();
         int size = 0;
-        for (int x: data1) {
-            heap.insert(x);
+        for (MutableInteger x: data1) {
+            heap.add(x);
             size += 1;
             assertEquals(heap.size(), size);
         }
@@ -41,8 +80,8 @@ public class BinaryHeapTest {
 
         heap = new BinaryHeap<>();
         size = 0;
-        for (int x: data2) {
-            heap.insert(x);
+        for (MutableInteger x: data2) {
+            heap.add(x);
             size += 1;
             assertEquals(heap.size(), size);
         }
@@ -52,11 +91,10 @@ public class BinaryHeapTest {
     @Test
     public void testDeleteMin() {
         // range 1 (sorted)
-        int[] range1 = data1;
-        int size = range1.length;
+        int size = data1.length;
         assertEquals(heap1.size(), size);
-        for (int x: range1) {
-            assertEquals(heap1.deleteMin().intValue(), x);
+        for (MutableInteger x: data1) {
+            assertEquals(heap1.deleteMin(), x);
             size -= 1;
             assertEquals(heap1.size(), size);
         }
@@ -64,12 +102,12 @@ public class BinaryHeapTest {
         assertTrue(heap1.isEmpty());
 
         // range 2 (was not sorted)
-        int[] range2 = Arrays.copyOf(data2, data2.length);
+        MutableInteger[] range2 = Arrays.copyOf(data2, data2.length);
         Arrays.sort(range2);
         size = range2.length;
         assertEquals(heap2.size(), size);
-        for (int x: range2) {
-            assertEquals(heap2.deleteMin().intValue(), x);
+        for (MutableInteger x: range2) {
+            assertEquals(heap2.deleteMin().get(), x.get());
             size -= 1;
             assertEquals(heap2.size(), size);
         }
@@ -77,4 +115,12 @@ public class BinaryHeapTest {
         assertTrue(heap2.isEmpty());
     }
 
+    @Test
+    public void testUpdate() {
+        MutableInteger newMin = data2[data2.length - 1];
+        newMin.set(0);
+        heap2.update(newMin);
+        assertEquals(heap2.findMin(), newMin);
+    }
+
 }