Merge branch 'tests' into 'master'

Update CaesarCipherSolverTests.java

Closes #1, #2, and #3

See merge request !1

tests/edu/caltech/cs2/project01/CaesarCipherSolverTests.java

@@ -2,15 +2,18 @@ package edu.caltech.cs2.project01;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertIterableEquals;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
 
 import edu.caltech.cs2.helpers.Inspection;
 import org.junit.jupiter.api.*;
 import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
 
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
+import java.util.Arrays;
 import java.util.List;
 import java.util.ArrayList;
 
@@ -18,17 +21,29 @@ import java.io.ByteArrayOutputStream;
 import java.io.FileDescriptor;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
+import java.util.stream.Stream;
 
 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 class CaesarCipherSolverTests {
     String STRING_SOURCE = "src/edu/caltech/cs2/project01/CaesarCipherSolver.java";
 
+    static final String DECLARATION = "WHEN IN THE COURSE OF HUMAN EVENTS IT BECOMES NECESSARY FOR ONE PEOPLE TO DISSOLVE THE " +
+            "POLITICAL BANDS WHICH HAVE CONNECTED THEM WITH ANOTHER AND TO ASSUME AMONG THE POWERS OF THE EARTH THE " +
+            "SEPARATE AND EQUAL STATION TO WHICH THE LAWS OF NATURE AND OF NATURES GOD ENTITLE THEM A DECENT RESPECT TO " +
+            "THE OPINIONS OF MANKIND REQUIRES THAT THEY SHOULD DECLARE THE CAUSES WHICH IMPEL THEM TO THE SEPARATION";
+
+    static final String CONSTITUTION = "WE THE PEOPLE OF THE UNITED STATES IN ORDER TO FORM A MORE PERFECT UNION ESTABLISH " +
+            "JUSTICE INSURE DOMESTIC TRANQUILITY PROVIDE FOR THE COMMON DEFENCE PROMOTE THE GENERAL WELFARE AND SECURE " +
+            "THE BLESSINGS OF LIBERTY TO OURSELVES AND OUR POSTERITY DO ORDAIN AND ESTABLISH THIS CONSTITUTION FOR THE " +
+            "UNITED STATES OF AMERICA";
+
     @Order(0)
     @Tag("C")
-    @DisplayName("Test no usage of split(), join(), contains()")
+    @DisplayName("Test no usage of split(), join(), contains(), indexOf()")
     @Test
     public void testNoUsageOfBannedMethods() {
-        List<String> regexps = List.of("\\.split\\(.*?\\)", "\\.join\\(.*?\\)", "\\.contains\\(.*?\\)");
+        List<String> regexps = List.of("\\.split\\(.*?\\)", "\\.join\\(.*?\\)", "\\.contains\\(.*?\\)",
+                "\\.indexOf\\(.*?\\)");
         Inspection.assertNoUsageOf(STRING_SOURCE, regexps);
     }
 
@@ -75,86 +90,98 @@ class CaesarCipherSolverTests {
     @Tag("C")
     @ParameterizedTest
     @DisplayName("Test splitBySpaces(String)")
-    @ValueSource(strings = { "", "HI", "HI THERE", "A B C D E F GGG" })
+    @ValueSource(strings = { "", "HI", "HI THERE", "A B C D E F GGG", "TRUTH IS NOT A DEMOCRACY", DECLARATION})
     public void testSplitBySpaces(String toSplit) {
         List<String> list = CaesarCipherSolver.splitBySpaces(toSplit);
-        assertEquals(toSplit.trim(), String.join(" ", list));
+        assertIterableEquals(Arrays.asList(toSplit.trim().split(" ")), list);
     }
 
     @Order(8)
     @Tag("C")
-    @DisplayName("Test putTogetherWithSpaces([\"ABCD\"])")
-    @Test
-    public void testPutTogetherWithSpacesSingleton() {
+    @ParameterizedTest
+    @DisplayName("Test putTogetherWithSpaces(String)")
+    @ValueSource(strings = {"ABCD", "NEXUS", "RIVIERA"})
+    public void testPutTogetherWithSpacesSingleton(String toPutTogether) {
         List<String> input = new ArrayList<>();
-        input.add("ABCD");
-        Assertions.assertEquals("ABCD", CaesarCipherSolver.putTogetherWithSpaces(input));
+        input.add(toPutTogether);
+        Assertions.assertEquals(toPutTogether, CaesarCipherSolver.putTogetherWithSpaces(input));
+    }
+
+    private static Stream<Arguments> putArgumentsStream() {
+        return Stream.of(
+                Arguments.of((Object) new String[] {"ABCD", "DDDD"}),
+                Arguments.of((Object) new String[] {"ONE", "BY", "LAND", "TWO", "BY", "SEA"}),
+                Arguments.of((Object) CONSTITUTION.split(" "))
+        );
     }
-    
+
     @Order(9)
     @Tag("C")
-    @DisplayName("Test putTogetherWithSpaces([\"ABCD\", \"DDDD\"])")
-    @Test
-    public void testPutTogetherWithSpaces() {
-        List<String> input = new ArrayList<>();
-        input.add("ABCD");
-        input.add("DDDD");
-        Assertions.assertEquals("ABCD DDDD", CaesarCipherSolver.putTogetherWithSpaces(input));
+    @ParameterizedTest
+    @DisplayName("Test putTogetherWithSpaces()")
+    @MethodSource("putArgumentsStream")
+    public void testPutTogetherWithSpaces(String[] strings) {
+        List<String> input = Arrays.asList(strings);
+        Assertions.assertEquals(String.join(" ", input), CaesarCipherSolver.putTogetherWithSpaces(input));
     }
 
-    @Order(10)
-    @Tag("C")
-    @DisplayName("Test howManyWordsIn([\"ABCD\", \"DDDD\"], [])")
-    @Test
-    public void testHowManyWordsInEmpty() {
-        List<String> dictionary = new ArrayList<>();
-        List<String> sentence = new ArrayList<>();
-        sentence.add(new String("ABCD"));
-        sentence.add(new String("DDDD"));
-        Assertions.assertEquals(0, CaesarCipherSolver.howManyWordsIn(sentence, dictionary));
+    private static Stream<Arguments> howArgumentsStream() {
+        return Stream.of(
+                arguments(new String[] {""}, new String[] {"ABCD", "DDDD"}, 0),
+                arguments(new String[] {"ABCD"}, new String[] {"ABCD", "DDDD"}, 1),
+                arguments(new String[] {"ABCD", "EFGH"}, new String[] {"ABCD", "ABCD", "NOT"}, 2),
+                // DECLARATION but with duplicate words removed
+                arguments(new String[] {"WHEN", "IN", "THE", "COURSE", "OF", "HUMAN", "EVENTS", "IT", "BECOMES",
+                                "NECESSARY", "FOR", "ONE", "PEOPLE", "TO", "DISSOLVE", "POLITICAL", "BANDS", "WHICH",
+                                "HAVE", "CONNECTED", "THEM", "WITH", "ANOTHER", "AND", "ASSUME", "AMONG", "POWERS",
+                                "EARTH", "SEPARATE", "EQUAL", "STATION", "LAWS", "NATURE", "NATURES", "GOD", "ENTITLE",
+                                "A", "DECENT", "RESPECT", "OPINIONS", "MANKIND", "REQUIRES", "THAT", "THEY", "SHOULD",
+                                "DECLARE", "CAUSES", "IMPEL", "SEPARATION"},
+                        CONSTITUTION.split(" "), 19)
+        );
     }
 
-    @Order(11)
+    @Order(10)
     @Tag("C")
-    @DisplayName("Test howManyWordsIn([\"ABCD\", \"DDDD\"], [\"ABCD\"])")
-    @Test
-    public void testHowManyWordsInSingleton() {
-        List<String> dictionary = new ArrayList<>();
-        dictionary.add(new String("ABCD"));
-        List<String> sentence = new ArrayList<>();
-        sentence.add(new String("ABCD"));
-        sentence.add(new String("DDDD"));
-        Assertions.assertEquals(1, CaesarCipherSolver.howManyWordsIn(sentence, dictionary));
+    @ParameterizedTest
+    @DisplayName("Test howManyWordsIn")
+    @MethodSource("howArgumentsStream")
+    public void testHowManyWords(String[] dict, String[] sent, int same) {
+        List<String> dictionary = Arrays.asList(dict);
+        List<String> sentence = Arrays.asList(sent);
+        Assertions.assertEquals(same, CaesarCipherSolver.howManyWordsIn(sentence, dictionary));
     }
-    
-    @Order(12)
-    @Tag("C")
-    @DisplayName("Test howManyWordsIn([\"ABCD\", \"ABCD\", \"NOT\"], [\"ABCD\", \"EFGH\"])")
-    @Test
-    public void testHowManyWordsWithDuplicates() {
-        List<String> dictionary = new ArrayList<>();
-        dictionary.add(new String("ABCD"));
-        dictionary.add(new String("EFGH"));
-        List<String> sentence = new ArrayList<>();
-        sentence.add(new String("ABCD"));
-        sentence.add(new String("ABCD"));
-        sentence.add(new String("NOT"));
-        Assertions.assertEquals(2, CaesarCipherSolver.howManyWordsIn(sentence, dictionary));
+
+    private static Stream<Arguments> mainArgumentsStream() {
+        return Stream.of(
+                arguments("HELLO", new String[] {"HELLO"}),
+                arguments("FYYFHP FY IFBS", new String[] {"ATTACK AT DAWN"}),
+                arguments("AI NYUG", new String[] {"GO TEAM"}),
+                arguments("NK", new String[] {"BY", "HE", "IF"}),
+                arguments("EH", new String[] {"OR", "BE"}),
+                arguments("BO", new String[] {"RE", "AN"}),
+                // Stress tests
+                arguments("DOLU PU AOL JVBYZL VM OBTHU LCLUAZ PA ILJVTLZ ULJLZZHYF MVY VUL WLVWSL AV KPZZVSCL AOL " +
+                        "WVSPAPJHS IHUKZ DOPJO OHCL JVUULJALK AOLT DPAO HUVAOLY HUK AV HZZBTL HTVUN AOL WVDLYZ VM AOL " +
+                        "LHYAO AOL ZLWHYHAL HUK LXBHS ZAHAPVU AV DOPJO AOL SHDZ VM UHABYL HUK VM UHABYLZ NVK LUAPASL " +
+                        "AOLT H KLJLUA YLZWLJA AV AOL VWPUPVUZ VM THURPUK YLXBPYLZ AOHA AOLF ZOVBSK KLJSHYL AOL JHBZLZ " +
+                        "DOPJO PTWLS AOLT AV AOL ZLWHYHAPVU", new String[] {DECLARATION}),
+                arguments("RZ OCZ KZJKGZ JA OCZ PIDOZY NOVOZN DI JMYZM OJ AJMH V HJMZ KZMAZXO PIDJI ZNOVWGDNC EPNODXZ " +
+                        "DINPMZ YJHZNODX OMVILPDGDOT KMJQDYZ AJM OCZ XJHHJI YZAZIXZ KMJHJOZ OCZ BZIZMVG RZGAVMZ VIY " +
+                        "NZXPMZ OCZ WGZNNDIBN JA GDWZMOT OJ JPMNZGQZN VIY JPM KJNOZMDOT YJ JMYVDI VIY ZNOVWGDNC OCDN " +
+                        "XJINODOPODJI AJM OCZ PIDOZY NOVOZN JA VHZMDXV", new String[] {CONSTITUTION})
+        );
     }
 
-    @Order(13)
+    @Order(11)
     @Tag("C")
     @ParameterizedTest
     @DisplayName("Test main()")
-    @CsvSource({
-            "HELLO, HELLO",
-            "FYYFHP FY IFBS, ATTACK AT DAWN",
-            "AI NYUG, GO TEAM"
-    })
-    public void testMain(String cipher, String expected) {
+    @MethodSource("mainArgumentsStream")
+    public void testMain(String cipher, String[] expected) {
     	ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
 		System.setOut(new PrintStream(outputStream));
-		
+
         byte[] input = cipher.getBytes();
         InputStream fakeIn = new ByteArrayInputStream(input);
         System.setIn(fakeIn);
@@ -162,6 +189,7 @@ class CaesarCipherSolverTests {
         System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out)));
         String output = outputStream.toString();
         System.out.print(output);
-        assertEquals("Type a sentence to decrypt: " + expected + "\n", output.replaceAll("\r\n", "\n"));
+        assertEquals("Type a sentence to decrypt: " + String.join("\n", expected) +
+                "\n", output.replaceAll("\r\n", "\n"));
     }
 }
\ No newline at end of file