[clean] Apply formatting and add formatter configuration.

be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/BinaryHeapTest.java

@@ -8,7 +8,8 @@ public class BinaryHeapTest extends PriorityQueueTest {
     }
 
     @Override
-    public PriorityQueue<MutableInteger> createQueue(PriorityQueue<MutableInteger> queue) {
+    public PriorityQueue<MutableInteger> createQueue(
+            PriorityQueue<MutableInteger> queue) {
         return new BinaryHeap<>((BinaryHeap<MutableInteger>) queue);
     }
 

be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/BinarySearchTreeTest.java

@@ -8,7 +8,8 @@ public class BinarySearchTreeTest extends PriorityQueueTest {
     }
 
     @Override
-    public PriorityQueue<MutableInteger> createQueue(PriorityQueue<MutableInteger> queue) {
+    public PriorityQueue<MutableInteger> createQueue(
+            PriorityQueue<MutableInteger> queue) {
         return new BinarySearchTree<>((BinarySearchTree<MutableInteger>) queue);
     }
 

be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/PriorityQueueTest.java

@@ -25,7 +25,7 @@ public abstract class PriorityQueueTest {
     /**
      * Needs to be implemented by child class to actually provide priority queue
      * implementation.
-     * 
+     *
      * @return A new instance of a PriorityQueue implementation.
      */
     public abstract PriorityQueue<MutableInteger> createQueue();
@@ -33,12 +33,12 @@ public abstract class PriorityQueueTest {
     /**
      * Needs to be implemented by child class to actually provide priority queue
      * implementation.
-     * 
+     *
      * @param queue Queue to copy.
-     * 
      * @return Copy of the given queue.
      */
-    public abstract PriorityQueue<MutableInteger> createQueue(PriorityQueue<MutableInteger> queue);
+    public abstract PriorityQueue<MutableInteger> createQueue(
+            PriorityQueue<MutableInteger> queue);
 
     protected static class MutableInteger implements Comparable<MutableInteger> {
 
@@ -58,7 +58,7 @@ public abstract class PriorityQueueTest {
 
         /**
          * Update the integer value stored inside this MutableInteger.
-         * 
+         *
          * @param value New value to set.
          */
         public void set(int value) {
@@ -92,7 +92,6 @@ public abstract class PriorityQueueTest {
 
     /**
      * Set of parameters.
-     * 
      */
     @Parameters
     public static Collection<Object> data() {
@@ -102,30 +101,31 @@ public abstract class PriorityQueueTest {
         objects.add(new TestParameters<>(new MutableInteger[0], new int[0]));
 
         // Queue with 50 elements from 0 to 49, inserted in order and deleted in order.
-        objects.add(new TestParameters<>(
-                IntStream.range(0, 50).mapToObj(MutableInteger::new).toArray(MutableInteger[]::new),
-                IntStream.range(0, 50).toArray()));
+        objects.add(
+                new TestParameters<>(
+                        IntStream.range(0, 50).mapToObj(MutableInteger::new)
+                                .toArray(MutableInteger[]::new),
+                        IntStream.range(0, 50).toArray()));
 
         // Queue with 20 elements from 0 to 19, inserted in order, deleted in the given
         // order.
         objects.add(new TestParameters<>(
-                IntStream.range(0, 20).mapToObj(MutableInteger::new).toArray(MutableInteger[]::new),
-                new int[] { 12, 17, 18, 19, 4, 5, 3, 2, 0, 9, 10, 16, 8, 14, 13, 15, 7, 6, 1,
-                        11 }));
+                IntStream.range(0, 20).mapToObj(MutableInteger::new)
+                        .toArray(MutableInteger[]::new),
+                new int[] { 12, 17, 18, 19, 4, 5, 3, 2, 0, 9, 10, 16, 8, 14, 13, 15, 7,
+                        6, 1, 11 }));
 
         // Queue with 7 elements.
-        objects.add(
-                new TestParameters<>(
-                        Arrays.stream(new int[] { 8, 1, 6, 3, 4, 5, 9 })
-                                .mapToObj(MutableInteger::new).toArray(MutableInteger[]::new),
-                        new int[] { 6, 5, 0, 1, 4, 2, 3 }));
+        objects.add(new TestParameters<>(
+                Arrays.stream(new int[] { 8, 1, 6, 3, 4, 5, 9 })
+                        .mapToObj(MutableInteger::new).toArray(MutableInteger[]::new),
+                new int[] { 6, 5, 0, 1, 4, 2, 3 }));
 
         // Queue with 7 elements.
-        objects.add(
-                new TestParameters<>(
-                        Arrays.stream(new int[] { 1, 7, 4, 8, 9, 6, 5 })
-                                .mapToObj(MutableInteger::new).toArray(MutableInteger[]::new),
-                        new int[] { 2, 0, 1, 3, 4, 5, 6 }));
+        objects.add(new TestParameters<>(
+                Arrays.stream(new int[] { 1, 7, 4, 8, 9, 6, 5 })
+                        .mapToObj(MutableInteger::new).toArray(MutableInteger[]::new),
+                new int[] { 2, 0, 1, 3, 4, 5, 6 }));
 
         // Queue with 13 elements.
         objects.add(new TestParameters<>(
@@ -147,7 +147,7 @@ public abstract class PriorityQueueTest {
         // Create the range queue
         this.queue = createQueue();
 
-        for (MutableInteger v: parameters.data) {
+        for (MutableInteger v : parameters.data) {
             this.queue.insert(v);
         }
     }
@@ -166,7 +166,7 @@ public abstract class PriorityQueueTest {
     public void testInsert() {
         PriorityQueue<MutableInteger> queue = createQueue();
         int size = 0;
-        for (MutableInteger x: parameters.data) {
+        for (MutableInteger x : parameters.data) {
             queue.insert(x);
             assertEquals(++size, queue.size());
         }
@@ -174,7 +174,7 @@ public abstract class PriorityQueueTest {
         MutableInteger[] range = Arrays.copyOf(parameters.data, parameters.data.length);
         Arrays.sort(range);
 
-        for (MutableInteger mi: range) {
+        for (MutableInteger mi : range) {
             assertEquals(mi.get(), queue.deleteMin().value);
             assertEquals(--size, queue.size());
         }
@@ -189,7 +189,8 @@ public abstract class PriorityQueueTest {
     @Test
     public void testFindMin() {
         Assume.assumeFalse(queue.isEmpty());
-        assertEquals(Collections.min(Arrays.asList(parameters.data)).get(), queue.findMin().get());
+        assertEquals(Collections.min(Arrays.asList(parameters.data)).get(),
+                queue.findMin().get());
     }
 
     @Test(expected = EmptyPriorityQueueException.class)
@@ -204,7 +205,7 @@ public abstract class PriorityQueueTest {
         assertEquals(size, queue.size());
         MutableInteger[] range = Arrays.copyOf(parameters.data, parameters.data.length);
         Arrays.sort(range);
-        for (MutableInteger x: range) {
+        for (MutableInteger x : range) {
             assertEquals(x, queue.deleteMin());
             size -= 1;
             assertEquals(size, queue.size());
@@ -259,7 +260,7 @@ public abstract class PriorityQueueTest {
     @Test
     public void testRemoveTwice() {
         Assume.assumeFalse(queue.isEmpty());
-        for (MutableInteger data: parameters.data) {
+        for (MutableInteger data : parameters.data) {
             PriorityQueue<MutableInteger> copyQueue = this.createQueue(this.queue);
             copyQueue.remove(data);
             try {
@@ -307,7 +308,7 @@ public abstract class PriorityQueueTest {
     public void testRemoveThenAdd() {
         Assume.assumeFalse(queue.isEmpty());
         int min = Collections.min(Arrays.asList(parameters.data)).get();
-        for (MutableInteger mi: parameters.data) {
+        for (MutableInteger mi : parameters.data) {
             queue.remove(mi);
             assertEquals(parameters.data.length - 1, queue.size());
             mi.set(--min);