Commit ba4f6404 authored by Archie Shahidullah's avatar Archie Shahidullah :expressionless:
Browse files

Update CaesarCipherSolverTests.java

parent 81735e4e
1 merge request!1Update CaesarCipherSolverTests.java
Pipeline #36395 failed with stage
in 0 seconds
Showing with 88 additions and 60 deletions
+88 -60
...@@ -2,15 +2,18 @@ package edu.caltech.cs2.project01; ...@@ -2,15 +2,18 @@ package edu.caltech.cs2.project01;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertIterableEquals; import static org.junit.jupiter.api.Assertions.assertIterableEquals;
import static org.junit.jupiter.params.provider.Arguments.arguments;
import edu.caltech.cs2.helpers.Inspection; import edu.caltech.cs2.helpers.Inspection;
import org.junit.jupiter.api.*; import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest; 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 org.junit.jupiter.params.provider.ValueSource;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
import java.io.InputStream; import java.io.InputStream;
import java.util.Arrays;
import java.util.List; import java.util.List;
import java.util.ArrayList; import java.util.ArrayList;
...@@ -18,17 +21,29 @@ import java.io.ByteArrayOutputStream; ...@@ -18,17 +21,29 @@ import java.io.ByteArrayOutputStream;
import java.io.FileDescriptor; import java.io.FileDescriptor;
import java.io.FileOutputStream; import java.io.FileOutputStream;
import java.io.PrintStream; import java.io.PrintStream;
import java.util.stream.Stream;
@TestMethodOrder(MethodOrderer.OrderAnnotation.class) @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class CaesarCipherSolverTests { class CaesarCipherSolverTests {
String STRING_SOURCE = "src/edu/caltech/cs2/project01/CaesarCipherSolver.java"; 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) @Order(0)
@Tag("C") @Tag("C")
@DisplayName("Test no usage of split(), join(), contains()") @DisplayName("Test no usage of split(), join(), contains(), indexOf()")
@Test @Test
public void testNoUsageOfBannedMethods() { 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); Inspection.assertNoUsageOf(STRING_SOURCE, regexps);
} }
...@@ -75,7 +90,7 @@ class CaesarCipherSolverTests { ...@@ -75,7 +90,7 @@ class CaesarCipherSolverTests {
@Tag("C") @Tag("C")
@ParameterizedTest @ParameterizedTest
@DisplayName("Test splitBySpaces(String)") @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) { public void testSplitBySpaces(String toSplit) {
List<String> list = CaesarCipherSolver.splitBySpaces(toSplit); List<String> list = CaesarCipherSolver.splitBySpaces(toSplit);
assertEquals(toSplit.trim(), String.join(" ", list)); assertEquals(toSplit.trim(), String.join(" ", list));
...@@ -83,78 +98,90 @@ class CaesarCipherSolverTests { ...@@ -83,78 +98,90 @@ class CaesarCipherSolverTests {
@Order(8) @Order(8)
@Tag("C") @Tag("C")
@DisplayName("Test putTogetherWithSpaces([\"ABCD\"])") @ParameterizedTest
@Test @DisplayName("Test putTogetherWithSpaces(String)")
public void testPutTogetherWithSpacesSingleton() { @ValueSource(strings = {"ABCD", "NEXUS", "RIVIERA"})
public void testPutTogetherWithSpacesSingleton(String toPutTogether) {
List<String> input = new ArrayList<>(); List<String> input = new ArrayList<>();
input.add("ABCD"); input.add(toPutTogether);
Assertions.assertEquals("ABCD", CaesarCipherSolver.putTogetherWithSpaces(input)); 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) @Order(9)
@Tag("C") @Tag("C")
@DisplayName("Test putTogetherWithSpaces([\"ABCD\", \"DDDD\"])") @ParameterizedTest
@Test @DisplayName("Test putTogetherWithSpaces()")
public void testPutTogetherWithSpaces() { @MethodSource("putArgumentsStream")
List<String> input = new ArrayList<>(); public void testPutTogetherWithSpaces(String[] strings) {
input.add("ABCD"); List<String> input = Arrays.asList(strings);
input.add("DDDD"); Assertions.assertEquals(String.join(" ", input), CaesarCipherSolver.putTogetherWithSpaces(input));
Assertions.assertEquals("ABCD DDDD", CaesarCipherSolver.putTogetherWithSpaces(input));
} }
@Order(10) private static Stream<Arguments> howArgumentsStream() {
@Tag("C") return Stream.of(
@DisplayName("Test howManyWordsIn([\"ABCD\", \"DDDD\"], [])") arguments(new String[] {""}, new String[] {"ABCD", "DDDD"}, 0),
@Test arguments(new String[] {"ABCD"}, new String[] {"ABCD", "DDDD"}, 1),
public void testHowManyWordsInEmpty() { arguments(new String[] {"ABCD", "EFGH"}, new String[] {"ABCD", "ABCD", "NOT"}, 2),
List<String> dictionary = new ArrayList<>(); // DECLARATION but with duplicate words removed
List<String> sentence = new ArrayList<>(); arguments(new String[] {"WHEN", "IN", "THE", "COURSE", "OF", "HUMAN", "EVENTS", "IT", "BECOMES",
sentence.add(new String("ABCD")); "NECESSARY", "FOR", "ONE", "PEOPLE", "TO", "DISSOLVE", "POLITICAL", "BANDS", "WHICH",
sentence.add(new String("DDDD")); "HAVE", "CONNECTED", "THEM", "WITH", "ANOTHER", "AND", "ASSUME", "AMONG", "POWERS",
Assertions.assertEquals(0, CaesarCipherSolver.howManyWordsIn(sentence, dictionary)); "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") @Tag("C")
@DisplayName("Test howManyWordsIn([\"ABCD\", \"DDDD\"], [\"ABCD\"])") @ParameterizedTest
@Test @DisplayName("Test howManyWordsIn")
public void testHowManyWordsInSingleton() { @MethodSource("howArgumentsStream")
List<String> dictionary = new ArrayList<>(); public void testHowManyWords(String[] dict, String[] sent, int same) {
dictionary.add(new String("ABCD")); List<String> dictionary = Arrays.asList(dict);
List<String> sentence = new ArrayList<>(); List<String> sentence = Arrays.asList(sent);
sentence.add(new String("ABCD")); Assertions.assertEquals(same, CaesarCipherSolver.howManyWordsIn(sentence, dictionary));
sentence.add(new String("DDDD"));
Assertions.assertEquals(1, CaesarCipherSolver.howManyWordsIn(sentence, dictionary));
} }
@Order(12) private static Stream<Arguments> mainArgumentsStream() {
@Tag("C") return Stream.of(
@DisplayName("Test howManyWordsIn([\"ABCD\", \"ABCD\", \"NOT\"], [\"ABCD\", \"EFGH\"])") arguments("HELLO", new String[] {"HELLO"}),
@Test arguments("FYYFHP FY IFBS", new String[] {"ATTACK AT DAWN"}),
public void testHowManyWordsWithDuplicates() { arguments("AI NYUG", new String[] {"GO TEAM"}),
List<String> dictionary = new ArrayList<>(); arguments("NK", new String[] {"BY", "HE", "IF"}),
dictionary.add(new String("ABCD")); arguments("EH", new String[] {"OR", "BE"}),
dictionary.add(new String("EFGH")); arguments("BO", new String[] {"RE", "AN"}),
List<String> sentence = new ArrayList<>(); // Stress tests
sentence.add(new String("ABCD")); arguments("DOLU PU AOL JVBYZL VM OBTHU LCLUAZ PA ILJVTLZ ULJLZZHYF MVY VUL WLVWSL AV KPZZVSCL AOL " +
sentence.add(new String("ABCD")); "WVSPAPJHS IHUKZ DOPJO OHCL JVUULJALK AOLT DPAO HUVAOLY HUK AV HZZBTL HTVUN AOL WVDLYZ VM AOL " +
sentence.add(new String("NOT")); "LHYAO AOL ZLWHYHAL HUK LXBHS ZAHAPVU AV DOPJO AOL SHDZ VM UHABYL HUK VM UHABYLZ NVK LUAPASL " +
Assertions.assertEquals(2, CaesarCipherSolver.howManyWordsIn(sentence, dictionary)); "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") @Tag("C")
@ParameterizedTest @ParameterizedTest
@DisplayName("Test main()") @DisplayName("Test main()")
@CsvSource({ @MethodSource("mainArgumentsStream")
"HELLO, HELLO", public void testMain(String cipher, String[] expected) {
"FYYFHP FY IFBS, ATTACK AT DAWN",
"AI NYUG, GO TEAM"
})
public void testMain(String cipher, String expected) {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
System.setOut(new PrintStream(outputStream)); System.setOut(new PrintStream(outputStream));
byte[] input = cipher.getBytes(); byte[] input = cipher.getBytes();
InputStream fakeIn = new ByteArrayInputStream(input); InputStream fakeIn = new ByteArrayInputStream(input);
System.setIn(fakeIn); System.setIn(fakeIn);
...@@ -162,6 +189,7 @@ class CaesarCipherSolverTests { ...@@ -162,6 +189,7 @@ class CaesarCipherSolverTests {
System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out))); System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out)));
String output = outputStream.toString(); String output = outputStream.toString();
System.out.print(output); 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
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment