Rewrite list mirroring function and add test

2 files changed, 52 insertions, 31 deletions

diff --git a/src/ch/epfl/xblast/Lists.java b/src/ch/epfl/xblast/Lists.java
index f468788..51e76b0 100644
--- a/src/ch/epfl/xblast/Lists.java
+++ b/src/ch/epfl/xblast/Lists.java
@@ -3,6 +3,8 @@ package ch.epfl.xblast;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Lists utility class providing common operations on lists.
@@ -13,30 +15,33 @@ import java.util.List;
 public final class Lists {
 
     /**
-     * Return a symmetric version of the list.
+     * Returns a reversed copy of the given list, leaving the original one unmodified.
      *
-     * @param l the input list
-     * @return mirroredList the mirrored list
+     * @param l   the list to reverse
+     * @param <T> the type of the list's elements
+     * @return a reversed copy of the list.
+     */
+    public static <T> List<T> reversed(List<T> l) {
+        List<T> r = new ArrayList<>(l);
+        Collections.reverse(r);
+        return r;
+    }
+
+    /**
+     * Returns a symmetric version of the list, without repeating the last element of the input list.
+     * For instance, mirrored([kay]) will return [kayak].
+     *
+     * @param l   the input list
+     * @param <T> the type of the list's elements
+     * @return the mirrored list
      * @throws IllegalArgumentException if the given list is empty
      */
     public static <T> List<T> mirrored(List<T> l) {
-        if (l.size() == 0) {
-            throw new IllegalArgumentException();
-        }
-
-        List<T> mirroredList = new ArrayList<T>();
-        List<T> rightSide = new ArrayList<T>();
-
-        for (int i = 0; i < l.size() - 1; i++) {
-            rightSide.add(l.get(i));
-        }
-
-        Collections.reverse(rightSide);
-
-        mirroredList.addAll(l);
-        mirroredList.addAll(rightSide);
+        if (l == null || l.size() == 0) throw new IllegalArgumentException();
 
-        return mirroredList;
+        return Stream
+                .concat(l.stream(), Lists.reversed(l).stream().skip(1))
+                .collect(Collectors.toList());
     }
 
 }
diff --git a/test/ch/epfl/xblast/ListsTest.java b/test/ch/epfl/xblast/ListsTest.java
index 42b317f..0a2f5f9 100644
--- a/test/ch/epfl/xblast/ListsTest.java
+++ b/test/ch/epfl/xblast/ListsTest.java
@@ -1,26 +1,42 @@
 package ch.epfl.xblast;
 
-import java.util.List;
-import java.util.Arrays;
-import static org.junit.Assert.*;
 import org.junit.Test;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import static org.junit.Assert.assertEquals;
+
 /**
-* @author Pacien TRAN-GIRARD (261948)
-* @author Timothée FLOURE (257420)
-*/
+ * @author Pacien TRAN-GIRARD (261948)
+ * @author Timothée FLOURE (257420)
+ */
 public class ListsTest {
-    @Test(expected=IllegalArgumentException.class)
+
+    @Test(expected = IllegalArgumentException.class)
     public void isEmptyListThrowingException() {
-        List<Integer> sampleList = Arrays.asList();
-        Lists.<Integer>mirrored(sampleList);
+        List<Integer> emptyList = new ArrayList<>();
+        Lists.mirrored(emptyList);
     }
 
     @Test
     public void isListMirrored() {
-        List<Integer> sampleList = Arrays.asList(1,2,3,4,5);
-        List<Integer> expected = Arrays.asList(1,2,3,4,5,4,3,2,1);
+        List<Integer> sampleList = Arrays.asList(1, 2, 3, 4, 5);
+        List<Integer> expected = Arrays.asList(1, 2, 3, 4, 5, 4, 3, 2, 1);
+
+        assertEquals(expected, Lists.mirrored(sampleList));
+    }
 
-        assertEquals(expected, Lists.<Integer>mirrored(sampleList));
+    @Test
+    public void mirrorElementsAreEqual() {
+        List<Integer> sampleList = IntStream.range(0, 10).boxed().collect(Collectors.toList());
+        List<Integer> mirrored = Lists.mirrored(sampleList);
+
+        for (int i = 0; i < mirrored.size() / 2; ++i)
+            assertEquals(mirrored.get(i), mirrored.get(mirrored.size() - 1 - i));
     }
+
 }