diff --git a/src/main/java/mattrixwv/CipherStreamJava/Playfair.java b/src/main/java/mattrixwv/CipherStreamJava/Playfair.java index 09d00da..9ec148a 100644 --- a/src/main/java/mattrixwv/CipherStreamJava/Playfair.java +++ b/src/main/java/mattrixwv/CipherStreamJava/Playfair.java @@ -1,7 +1,7 @@ //CipherStreamJava/src/main/java/mattrixwv/CipherStreamJava/Playfair.java //Matthew Ellison // Created: 07-30-21 -//Modified: 07-30-21 +//Modified: 01-04-22 //This is the declaration of the Playfair class package mattrixwv.CipherStreamJava; @@ -19,6 +19,21 @@ public class Playfair{ super(message, throwable); } } + //A class representing the location of a character in the grid + private class CharLocation{ + private int x; + private int y; + public CharLocation(int x, int y){ + this.x = x; + this.y = y; + } + public int getX(){ + return x; + } + public int getY(){ + return y; + } + } //Variables private boolean leaveCapitals; //Whether to respect captials in the output string @@ -41,7 +56,7 @@ public class Playfair{ } } //Strips invalid characters from the string that needs encoded/decoded - private void setInputString(String inputString) throws InvalidCharacterException{ + private void setInputString(String inputString, boolean encoding) throws InvalidCharacterException{ //Make sure the input string is not null if(inputString == null){ throw new InvalidCharacterException("The input string cannot be null"); @@ -49,13 +64,13 @@ public class Playfair{ //Set the options if(!leaveCapitals){ - inputString.toLowerCase(); + inputString = inputString.toUpperCase(); } if(!leaveWhitespace){ inputString = inputString.replaceAll("\\s+", ""); } if(!leaveSymbols){ - inputString = inputString.replaceAll("[^a-zA-Z0-9\\s+]", ""); + inputString = inputString.replaceAll("[^a-zA-Z0-9\\s]", ""); } //Make replace all of the replacers with replaced @@ -66,45 +81,80 @@ public class Playfair{ throw new InvalidCharacterException("The input string cannot be blank"); } - //Replace characters that need replaced - StringBuilder sanitizedInput = new StringBuilder(); - for(int inputCnt = 0;inputCnt < inputString.length();++inputCnt){ - //Get the first letter - char firstLetter = inputString.charAt(inputCnt++); - //Make sure the first letter doesn't need replaced - if(firstLetter == replaced){ - firstLetter = replacer; + //If this is encoding parse it and clean up an problems + if(encoding){ + //Replace characters that need replaced + inputString = inputString.replaceAll(Character.toString(replaced), Character.toString(replacer)); + + //Check if there are any doubled characters + StringBuilder cleanInput = new StringBuilder(); + int letterCount = 0; + for(int cnt = 0;cnt < inputString.length();){ + //Advance until you find a letter, saving the input for inclusion + StringBuilder prepend = new StringBuilder(); + while((cnt < inputString.length()) && !Character.isAlphabetic(inputString.charAt(cnt))){ + prepend.append(inputString.charAt(cnt++)); + } + //If we have reached the end of the string end the loop + if(cnt == inputString.length()){ + cleanInput.append(prepend); + break; + } + //Get the next character + char firstLetter = inputString.charAt(cnt++); + ++letterCount; + + //Advance until you find a letter, saving the input for inclusion + StringBuilder middle = new StringBuilder(); + while((cnt < inputString.length()) && !Character.isAlphabetic(inputString.charAt(cnt))){ + middle.append(inputString.charAt(cnt++)); + } + char secondLetter = '\0'; + //If we have not reached the end of the string get the next character + if(cnt != inputString.length()){ + secondLetter = inputString.charAt(cnt++); + ++letterCount; + } + //If the second character is the same as the first character set the pointer back and use the doubled character + if(secondLetter == firstLetter){ + --cnt; + secondLetter = doubled; + } + + //Add all of the gathered input to the cleaned up input + cleanInput.append(prepend); + cleanInput.append(firstLetter); + cleanInput.append(middle); + if(secondLetter != '\0'){ + cleanInput.append(secondLetter); + } } - //Save all of the characters inbetween letters - StringBuilder inBetween = new StringBuilder(); - while((!Character.isAlphabetic(inputString.charAt(inputCnt))) && (inputCnt != inputString.length())){ - inBetween.append(inputString.charAt(inputCnt++)); + //Check if there are an odd number of characters + if((letterCount % 2) == 1){ + int lastLetterLocation = cleanInput.length() - 1; + while(!Character.isAlphabetic(cleanInput.charAt(lastLetterLocation))){ + --lastLetterLocation; + } + if(cleanInput.charAt(lastLetterLocation) == doubled){ + cleanInput.append(replacer); + } + else{ + cleanInput.append(doubled); + } } - //Get the second letter - char secondLetter = '\0'; - if(inputCnt != inputString.length()){ - secondLetter = inputString.charAt(inputCnt++); - } - else{ - secondLetter = doubled; - } - //Make sure the second letter doesn't need replaced - if(secondLetter == replaced){ - secondLetter = replacer; - } - if(secondLetter == firstLetter){ - secondLetter = doubled; - --inputCnt; - } - - //Add the letters to the sanitized string - sanitizedInput.append(firstLetter); - sanitizedInput.append(inBetween.toString()); - sanitizedInput.append(secondLetter); + this.inputString = cleanInput.toString(); + } + //If this is decoding just add it without parsing it + else{ + //Throw an exception if replaced is included + if(inputString.contains(Character.toString(replaced))){ + throw new InvalidCharacterException("An encoded message cannot contain a letter that needs replaced"); + } + + this.inputString = inputString; } - this.inputString = sanitizedInput.toString(); } //Returns the inputs string ready for encoding private String getPreparedInputString(){ @@ -134,72 +184,163 @@ public class Playfair{ //Create the grid from the sanitized keyword createGrid(); } + //Returns the location of the given character in the grid + private CharLocation findChar(char letter) throws Exception{ + for(int row = 0;row < grid.length;++row){ + for(int col = 0;col < grid[row].length;++col){ + if(grid[row][col] == letter){ + return new CharLocation(row, col); + } + } + } + //If it was not found something went wrong + throw new Exception("That character was not found in the grid. ERROR"); + } + //Returns the location in the grid of x and y, adjusting for out of bounds + private char getGridChar(int x, int y){ + if(x < 0){ + x += 5; + } + if(y < 0){ + y += 5; + } + return grid[x % 5][y % 5]; + } + //Adds characters that aren't letters to the output + private void addCharactersToCleanString(String cleanString){ + int outputCnt = 0; + StringBuilder fullOutput = new StringBuilder(); + for(int inputCnt = 0;inputCnt < inputString.length();++inputCnt){ + if(Character.isUpperCase(inputString.charAt(inputCnt))){ + fullOutput.append(cleanString.charAt(outputCnt++)); + } + else if(Character.isLowerCase(inputString.charAt(inputCnt))){ + fullOutput.append(Character.toLowerCase(cleanString.charAt(outputCnt++))); + } + else{ + fullOutput.append(inputString.charAt(inputCnt)); + } + } + outputString = fullOutput.toString(); + } //Encoded inputString using the Playfair cipher and stores the result in outputString - private String encode(){ + private String encode() throws Exception{ StringBuilder output = new StringBuilder(); int inputCnt = 0; String cleanString = getPreparedInputString(); - while(inputCnt < inputString.length()){ + while(inputCnt < cleanString.length()){ //Get the next 2 letters to be encoded - char firstLetter = inputString.charAt(inputCnt++); - char secondLetter = '\0'; - StringBuilder inBetween = new StringBuilder(); + char firstLetter = cleanString.charAt(inputCnt++); + char secondLetter = cleanString.charAt(inputCnt++); - //TODO: //Find the letters in the grid + CharLocation firstLocation = findChar(firstLetter); + CharLocation secondLocation = findChar(secondLetter); //Encode the letters + if(firstLocation.getX() == secondLocation.getX()){ + firstLetter = getGridChar(firstLocation.getX(), firstLocation.getY() + 1); + secondLetter = getGridChar(secondLocation.getX(), secondLocation.getY() + 1); + } + else if(firstLocation.getY() == secondLocation.getY()){ + firstLetter = getGridChar(firstLocation.getX() + 1, firstLocation.getY()); + secondLetter = getGridChar(secondLocation.getX() + 1, secondLocation.getY()); + } + else{ + firstLetter = getGridChar(firstLocation.getX(), secondLocation.getY()); + secondLetter = getGridChar(secondLocation.getX(), firstLocation.getY()); + } //Add the new letters to the output string + output.append(firstLetter); + output.append(secondLetter); } + //Add other characters to the output string + addCharactersToCleanString(output.toString()); + //Return the output string + return outputString; } //Decodes inputString using the Playfair cipher and stores the result in outputString - private String decode(){ - //TODO: - return null; + private String decode() throws Exception{ + StringBuilder output = new StringBuilder(); + int inputCnt = 0; + String cleanString = getPreparedInputString(); + while(inputCnt < cleanString.length()){ + //Get the next 2 letters to be encoded + char firstLetter = cleanString.charAt(inputCnt++); + char secondLetter = cleanString.charAt(inputCnt++); + + //Find the letters in the grid + CharLocation firstLocation = findChar(firstLetter); + CharLocation secondLocation = findChar(secondLetter); + + //Decode the letters + if(firstLocation.getX() == secondLocation.getX()){ + firstLetter = getGridChar(firstLocation.getX(), firstLocation.getY() - 1); + secondLetter = getGridChar(secondLocation.getX(), secondLocation.getY() - 1); + } + else if(firstLocation.getY() == secondLocation.getY()){ + firstLetter = getGridChar(firstLocation.getX() - 1, firstLocation.getY()); + secondLetter = getGridChar(secondLocation.getX() - 1, secondLocation.getY()); + } + else{ + firstLetter = getGridChar(firstLocation.getX(), secondLocation.getY()); + secondLetter = getGridChar(secondLocation.getX(), firstLocation.getY()); + } + + //Add the new letters to the output string + output.append(firstLetter); + output.append(secondLetter); + } + + //Add other characters to the output string + addCharactersToCleanString(output.toString()); + + //Return the output string + return outputString; } - public Playfair(){ + public Playfair() throws InvalidCharacterException{ reset(); - replaced = 'J'; - replacer = 'I'; - doubled = 'X'; leaveCapitals = false; leaveWhitespace = false; leaveSymbols = false; + setReplaced('J'); + setReplacer('I'); + setDoubled('X'); } - public Playfair(boolean leaveCapitals, boolean leaveWhitespace, boolean leaveSymbols){ + public Playfair(boolean leaveCapitals, boolean leaveWhitespace, boolean leaveSymbols) throws InvalidCharacterException{ reset(); - replaced = 'J'; - replacer = 'I'; - doubled = 'X'; this.leaveCapitals = leaveCapitals; this.leaveWhitespace = leaveWhitespace; this.leaveSymbols = leaveSymbols; + setReplaced('J'); + setReplacer('I'); + setDoubled('X'); } public Playfair(boolean leaveCapitals, boolean leaveWhitespace, boolean leaveSymbols, char replaced, char replacer, char doubled) throws InvalidCharacterException{ reset(); - setReplaced(replaced); - setReplacer(replacer); - setDoubled(doubled); this.leaveCapitals = leaveCapitals; this.leaveWhitespace = leaveWhitespace; this.leaveSymbols = leaveSymbols; + setReplaced(replaced); + setReplacer(replacer); + setDoubled(doubled); } //Sets the keyword and inputString and encodes the message - public String encode(String keyword, String input) throws InvalidCharacterException{ + public String encode(String keyword, String input) throws InvalidCharacterException, Exception{ reset(); setKeyword(keyword); - setInputString(input); + setInputString(input, true); return encode(); } //Sets the keyword and inputString and decodes the message - public String decode(String keyword, String input) throws InvalidCharacterException{ + public String decode(String keyword, String input) throws InvalidCharacterException, Exception{ reset(); setKeyword(keyword); - setInputString(input); + setInputString(input, false); return decode(); } @@ -224,9 +365,7 @@ public class Playfair{ throw new InvalidCharacterException("The replaced letter cannot be the same as the replacing letter"); } - if((Character.isAlphabetic(replaced)) && (replaced != replacer)){ - this.replaced = Character.toUpperCase(replaced); - } + this.replaced = Character.toUpperCase(replaced); } public char getReplacer(){ return replacer; diff --git a/src/test/java/mattrixwv/CipherStreamJava/TestPlayfair.java b/src/test/java/mattrixwv/CipherStreamJava/TestPlayfair.java index e4ff54a..187d0de 100644 --- a/src/test/java/mattrixwv/CipherStreamJava/TestPlayfair.java +++ b/src/test/java/mattrixwv/CipherStreamJava/TestPlayfair.java @@ -1,7 +1,7 @@ //CipherStreamJava/src/main/java/mattrixwv/CipherStreamJava/TestPlayfair.java //Matthew Ellison // Created: 07-30-21 -//Modified: 07-30-21 +//Modified: 01-04-22 //These are the tests for the Playfair class package mattrixwv.CipherStreamJava; @@ -10,18 +10,508 @@ import static org.junit.Assert.assertEquals; import org.junit.Test; +import mattrixwv.CipherStreamJava.Playfair.InvalidCharacterException; + public class TestPlayfair{ @Test - public void testDecode(){ - Playfair cipher = new Playfair(); + public void testDecode() throws InvalidCharacterException, Exception{ + Playfair cipher = new Playfair(true, true, true); - //Test 1 + //Test lowercase decoding + String inputString = "bmodzbxdnabekudmuixmmouvif"; + String keyword = "Playfair Example"; + String correctOutput = "hidethegoldinthetrexestump"; + String output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed lowercase decoding.", correctOutput, output); + //Test uppercase decoding + inputString = "BMODZBXDNABEKUDMUIXMMOUVIF"; + keyword = "Playfair Example"; + correctOutput = "HIDETHEGOLDINTHETREXESTUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed uppercase decoding.", correctOutput, output); + //Test odd letter count decoding + inputString = "bmodzbxdnabekudmuixmmouvim"; + keyword = "Playfair Example"; + correctOutput = "hidethegoldinthetrexestumx"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed odd letter count decoding.", correctOutput, output); + + //Test whitespace decoding + inputString = "bmod zbx dnab ek udm uixmm ouvif"; + keyword = "Playfair Example"; + correctOutput = "hide the gold in the trexe stump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed whitespace decoding.", correctOutput, output); + + //Test symbol decoding + inputString = "bmodzbxdnabek-udm@uixmm+ouvif"; + keyword = "Playfair Example"; + correctOutput = "hidethegoldin-the@trexe+stump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed symbol decoding.", correctOutput, output); + + //Test mixed case, whtiespace, symbol decoding + inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif"; + keyword = "Playfair Example"; + correctOutput = "Hide the gold in - the@trexe+stump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed mixed case, whitespace, symbol decoding.", correctOutput, output); + //Test mixed case, whtiespace, symbol decoding with mangled keyword + inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif"; + keyword = "Play-fair@Exam ple"; + correctOutput = "Hide the gold in - the@trexe+stump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output); } @Test - public void testEncode(){ - Playfair cipher = new Playfair(); + public void testNoWhitespaceDecode() throws InvalidCharacterException, Exception{ + Playfair cipher = new Playfair(true, false, true); - //Test 1 + //Test lowercase decoding + String inputString = "bmodzbxdnabekudmuixmmouvif"; + String keyword = "Playfair Example"; + String correctOutput = "hidethegoldinthetrexestump"; + String output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no whitespace lowercase decoding.", correctOutput, output); + //Test uppercase decoding + inputString = "BMODZBXDNABEKUDMUIXMMOUVIF"; + keyword = "Playfair Example"; + correctOutput = "HIDETHEGOLDINTHETREXESTUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no whitespace uppercase decoding.", correctOutput, output); + //Test odd letter count decoding + inputString = "bmodzbxdnabekudmuixmmouvim"; + keyword = "Playfair Example"; + correctOutput = "hidethegoldinthetrexestumx"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no whitespace odd letter count decoding.", correctOutput, output); + + //Test whitespace decoding + inputString = "bmodzbxdnabekudmuixmmouvif"; + keyword = "Playfair Example"; + correctOutput = "hidethegoldinthetrexestump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no whitespace whitespace decoding.", correctOutput, output); + + //Test symbol decoding + inputString = "bmodzbxdnabek-udm@uixmm+ouvif"; + keyword = "Playfair Example"; + correctOutput = "hidethegoldin-the@trexe+stump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no whitespace symbol decoding.", correctOutput, output); + + //Test mixed case, whtiespace, symbol decoding + inputString = "Bmodzbxdnabek-udm@uixmm+ouvif"; + keyword = "Playfair Example"; + correctOutput = "Hidethegoldin-the@trexe+stump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol decoding.", correctOutput, output); + //Test mixed case, whtiespace, symbol decoding with mangled keyword + inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif"; + keyword = "Play-fair@Exam ple"; + correctOutput = "Hidethegoldin-the@trexe+stump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output); + } + @Test + public void testNoCapitalDecode() throws InvalidCharacterException, Exception{ + Playfair cipher = new Playfair(false, true, true); + + //Test lowercase decoding + String inputString = "bmodzbxdnabekudmuixmmouvif"; + String keyword = "Playfair Example"; + String correctOutput = "HIDETHEGOLDINTHETREXESTUMP"; + String output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no capital lowercase decoding.", correctOutput, output); + //Test uppercase decoding + inputString = "BMODZBXDNABEKUDMUIXMMOUVIF"; + keyword = "Playfair Example"; + correctOutput = "HIDETHEGOLDINTHETREXESTUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no capital uppercase decoding.", correctOutput, output); + //Test odd letter count decoding + inputString = "bmodzbxdnabekudmuixmmouvim"; + keyword = "Playfair Example"; + correctOutput = "HIDETHEGOLDINTHETREXESTUMX"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no capital odd letter count decoding.", correctOutput, output); + + //Test whitespace decoding + inputString = "bmod zbx dnab ek udm uixmm ouvif"; + keyword = "Playfair Example"; + correctOutput = "HIDE THE GOLD IN THE TREXE STUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no capital whitespace decoding.", correctOutput, output); + + //Test symbol decoding + inputString = "bmodzbxdnabek-udm@uixmm+ouvif"; + keyword = "Playfair Example"; + correctOutput = "HIDETHEGOLDIN-THE@TREXE+STUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no capital symbol decoding.", correctOutput, output); + + //Test mixed case, whtiespace, symbol decoding + inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif"; + keyword = "Playfair Example"; + correctOutput = "HIDE THE GOLD IN - THE@TREXE+STUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no capital mixed case, whitespace, symbol decoding.", correctOutput, output); + //Test mixed case, whtiespace, symbol decoding with mangled keyword + inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif"; + keyword = "Play-fair@Exam ple"; + correctOutput = "HIDE THE GOLD IN - THE@TREXE+STUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no capital mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output); + } + @Test + public void testNoSymbolDecode() throws InvalidCharacterException, Exception{ + Playfair cipher = new Playfair(true, true, false); + + //Test lowercase decoding + String inputString = "bmodzbxdnabekudmuixmmouvif"; + String keyword = "Playfair Example"; + String correctOutput = "hidethegoldinthetrexestump"; + String output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no symbol lowercase decoding.", correctOutput, output); + //Test uppercase decoding + inputString = "BMODZBXDNABEKUDMUIXMMOUVIF"; + keyword = "Playfair Example"; + correctOutput = "HIDETHEGOLDINTHETREXESTUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no symbol uppercase decoding.", correctOutput, output); + //Test odd letter count decoding + inputString = "bmodzbxdnabekudmuixmmouvim"; + keyword = "Playfair Example"; + correctOutput = "hidethegoldinthetrexestumx"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no symbol odd letter count decoding.", correctOutput, output); + + //Test whitespace decoding + inputString = "bmod zbx dnab ek udm uixmm ouvif"; + keyword = "Playfair Example"; + correctOutput = "hide the gold in the trexe stump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no symbol whitespace decoding.", correctOutput, output); + + //Test symbol decoding + inputString = "bmodzbxdnabek-udm@uixmm+ouvif"; + keyword = "Playfair Example"; + correctOutput = "hidethegoldinthetrexestump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no symbol symbol decoding.", correctOutput, output); + + //Test mixed case, whtiespace, symbol decoding + inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif"; + keyword = "Playfair Example"; + correctOutput = "Hide the gold in thetrexestump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no symbol mixed case, whitespace, symbol decoding.", correctOutput, output); + //Test mixed case, whtiespace, symbol decoding with mangled keyword + inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif"; + keyword = "Play-fair@Exam ple"; + correctOutput = "Hide the gold in thetrexestump"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed no symbol mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output); + } + @Test + public void testNoCapitalWhitespaceSymbolDecode() throws InvalidCharacterException, Exception{ + Playfair cipher = new Playfair(false, false, false); + + //Test lowercase decoding + String inputString = "bmodzbxdnabekudmuixmmouvif"; + String keyword = "Playfair Example"; + String correctOutput = "HIDETHEGOLDINTHETREXESTUMP"; + String output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed secure lowercase decoding.", correctOutput, output); + //Test uppercase decoding + inputString = "BMODZBXDNABEKUDMUIXMMOUVIF"; + keyword = "Playfair Example"; + correctOutput = "HIDETHEGOLDINTHETREXESTUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed secure uppercase decoding.", correctOutput, output); + //Test odd letter count decoding + inputString = "bmodzbxdnabekudmuixmmouvim"; + keyword = "Playfair Example"; + correctOutput = "HIDETHEGOLDINTHETREXESTUMX"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed secure odd letter count decoding.", correctOutput, output); + + //Test whitespace decoding + inputString = "bmod zbx dnab ek udm uixmm ouvif"; + keyword = "Playfair Example"; + correctOutput = "HIDETHEGOLDINTHETREXESTUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed secure whitespace decoding.", correctOutput, output); + + //Test symbol decoding + inputString = "bmodzbxdnabek-udm@uixmm+ouvif"; + keyword = "Playfair Example"; + correctOutput = "HIDETHEGOLDINTHETREXESTUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed secure symbol decoding.", correctOutput, output); + + //Test mixed case, whtiespace, symbol decoding + inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif"; + keyword = "Playfair Example"; + correctOutput = "HIDETHEGOLDINTHETREXESTUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed secure mixed case, whitespace, symbol decoding.", correctOutput, output); + //Test mixed case, whtiespace, symbol decoding with mangled keyword + inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif"; + keyword = "Play-fair@Exam ple"; + correctOutput = "HIDETHEGOLDINTHETREXESTUMP"; + output = cipher.decode(keyword, inputString); + assertEquals("Playfair failed secure mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output); + } + @Test + public void testEncode() throws InvalidCharacterException, Exception{ + Playfair cipher = new Playfair(true, true, true); + + //Test lowercase encoding + String inputString = "hidethegoldinthetrexestump"; + String keyword = "Playfair Example"; + String correctOutput = "bmodzbxdnabekudmuixmmouvif"; + String output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed lowercase encoding.", correctOutput, output); + //Test uppercase encoding + inputString = "HIDETHEGOLDINTHETREXESTUMP"; + keyword = "Playfair Example"; + correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed uppercase encoding.", correctOutput, output); + //Test odd letter count encoding + inputString = "hidethegoldinthetrexestum"; + keyword = "Playfair Example"; + correctOutput = "bmodzbxdnabekudmuixmmouviM"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed odd letter count encoding.", correctOutput, output); + + //Test whitespace encoding + inputString = "hide the gold in the trexe stump"; + keyword = "Playfair Example"; + correctOutput = "bmod zbx dnab ek udm uixmm ouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed whitespace encoding.", correctOutput, output); + + //Test symbol encoding + inputString = "hidethegoldin-the@trexe+stump"; + keyword = "Playfair Example"; + correctOutput = "bmodzbxdnabek-udm@uixmm+ouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed symbol encoding.", correctOutput, output); + + //Test mixed case, whitespace, symbol encoding + inputString = "Hide the gold in - the@tree+stump"; + keyword = "Playfair Example"; + correctOutput = "Bmod zbx dnab ek - udm@uixMm+ouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed mixed case, whitespace, symbol encoding.", correctOutput, output); + //Test mixed case, whitespace, symbol encoding with mangled keyword + inputString = "Hide the gold in - the@tree+stump"; + keyword = "Play-fair@Exam ple"; + correctOutput = "Bmod zbx dnab ek - udm@uixMm+ouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output); + } + @Test + public void testNoWhitespaceEncode() throws InvalidCharacterException, Exception{ + Playfair cipher = new Playfair(true, false, true); + + //Test lowercase encoding + String inputString = "hidethegoldinthetrexestump"; + String keyword = "Playfair Example"; + String correctOutput = "bmodzbxdnabekudmuixmmouvif"; + String output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no whitespace lowercase encoding.", correctOutput, output); + //Test uppercase encoding + inputString = "HIDETHEGOLDINTHETREXESTUMP"; + keyword = "Playfair Example"; + correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no whitespace uppercase encoding.", correctOutput, output); + //Test odd letter count encoding + inputString = "hidethegoldinthetrexestum"; + keyword = "Playfair Example"; + correctOutput = "bmodzbxdnabekudmuixmmouviM"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no whitespace odd letter count encoding.", correctOutput, output); + + //Test whitespace encoding + inputString = "hide the gold in the trexe stump"; + keyword = "Playfair Example"; + correctOutput = "bmodzbxdnabekudmuixmmouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no whitespace whitespace encoding.", correctOutput, output); + + //Test symbol encoding + inputString = "hidethegoldin-the@trexe+stump"; + keyword = "Playfair Example"; + correctOutput = "bmodzbxdnabek-udm@uixmm+ouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no whitespace symbol encoding.", correctOutput, output); + + //Test mixed case, whitespace, symbol encoding + inputString = "Hide the gold in - the@tree+stump"; + keyword = "Playfair Example"; + correctOutput = "Bmodzbxdnabek-udm@uixMm+ouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol encoding.", correctOutput, output); + //Test mixed case, whitespace, symbol encoding with mangled keyword + inputString = "Hide the gold in - the@tree+stump"; + keyword = "Play-fair@Exam ple"; + correctOutput = "Bmodzbxdnabek-udm@uixMm+ouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output); + } + @Test + public void testNoCapitalEncode() throws InvalidCharacterException, Exception{ + Playfair cipher = new Playfair(false, true, true); + + //Test lowercase encoding + String inputString = "hidethegoldinthetrexestump"; + String keyword = "Playfair Example"; + String correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF"; + String output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no capital lowercase encoding.", correctOutput, output); + //Test uppercase encoding + inputString = "HIDETHEGOLDINTHETREXESTUMP"; + keyword = "Playfair Example"; + correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no capital uppercase encoding.", correctOutput, output); + //Test odd letter count encoding + inputString = "hidethegoldinthetrexestum"; + keyword = "Playfair Example"; + correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIM"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no capital odd letter count encoding.", correctOutput, output); + + //Test whitespace encoding + inputString = "hide the gold in the trexe stump"; + keyword = "Playfair Example"; + correctOutput = "BMOD ZBX DNAB EK UDM UIXMM OUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no capital whitespace encoding.", correctOutput, output); + + //Test symbol encoding + inputString = "hidethegoldin-the@trexe+stump"; + keyword = "Playfair Example"; + correctOutput = "BMODZBXDNABEK-UDM@UIXMM+OUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no capital symbol encoding.", correctOutput, output); + + //Test mixed case, whitespace, symbol encoding + inputString = "Hide the gold in - the@tree+stump"; + keyword = "Playfair Example"; + correctOutput = "BMOD ZBX DNAB EK - UDM@UIXMM+OUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no capital mixed case, whitespace, symbol encoding.", correctOutput, output); + //Test mixed case, whitespace, symbol encoding with mangled keyword + inputString = "Hide the gold in - the@tree+stump"; + keyword = "Play-fair@Exam ple"; + correctOutput = "BMOD ZBX DNAB EK - UDM@UIXMM+OUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no capital mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output); + } + @Test + public void testNoSymbolEncode() throws InvalidCharacterException, Exception{ + Playfair cipher = new Playfair(true, true, false); + + //Test lowercase encoding + String inputString = "hidethegoldinthetrexestump"; + String keyword = "Playfair Example"; + String correctOutput = "bmodzbxdnabekudmuixmmouvif"; + String output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no symbol lowercase encoding.", correctOutput, output); + //Test uppercase encoding + inputString = "HIDETHEGOLDINTHETREXESTUMP"; + keyword = "Playfair Example"; + correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no symbol uppercase encoding.", correctOutput, output); + //Test odd letter count encoding + inputString = "hidethegoldinthetrexestum"; + keyword = "Playfair Example"; + correctOutput = "bmodzbxdnabekudmuixmmouviM"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no symbol odd letter count encoding.", correctOutput, output); + + //Test whitespace encoding + inputString = "hide the gold in the trexe stump"; + keyword = "Playfair Example"; + correctOutput = "bmod zbx dnab ek udm uixmm ouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no symbol whitespace encoding.", correctOutput, output); + + //Test symbol encoding + inputString = "hidethegoldin-the@trexe+stump"; + keyword = "Playfair Example"; + correctOutput = "bmodzbxdnabekudmuixmmouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no symbol symbol encoding.", correctOutput, output); + + //Test mixed case, whitespace, symbol encoding + inputString = "Hide the gold in - the@tree+stump"; + keyword = "Playfair Example"; + correctOutput = "Bmod zbx dnab ek udmuixMmouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no symbol mixed case, whitespace, symbol encoding.", correctOutput, output); + //Test mixed case, whitespace, symbol encoding with mangled keyword + inputString = "Hide the gold in - the@tree+stump"; + keyword = "Play-fair@Exam ple"; + correctOutput = "Bmod zbx dnab ek udmuixMmouvif"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed no symbol mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output); + } + @Test + public void testNoCapitalWhitespaceSymbolEncode() throws InvalidCharacterException, Exception{ + Playfair cipher = new Playfair(false, false, false); + + //Test lowercase encoding + String inputString = "hidethegoldinthetrexestump"; + String keyword = "Playfair Example"; + String correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF"; + String output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed secure lowercase encoding.", correctOutput, output); + //Test uppercase encoding + inputString = "HIDETHEGOLDINTHETREXESTUMP"; + keyword = "Playfair Example"; + correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed secure uppercase encoding.", correctOutput, output); + //Test odd letter count encoding + inputString = "hidethegoldinthetrexestum"; + keyword = "Playfair Example"; + correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIM"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed secure odd letter count encoding.", correctOutput, output); + + //Test whitespace encoding + inputString = "hide the gold in the trexe stump"; + keyword = "Playfair Example"; + correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed secure whitespace encoding.", correctOutput, output); + + //Test symbol encoding + inputString = "hidethegoldin-the@trexe+stump"; + keyword = "Playfair Example"; + correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed secure symbol encoding.", correctOutput, output); + + //Test mixed case, whitespace, symbol encoding + inputString = "Hide the gold in - the@tree+stump"; + keyword = "Playfair Example"; + correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed secure mixed case, whitespace, symbol encoding.", correctOutput, output); + //Test mixed case, whitespace, symbol encoding with mangled keyword + inputString = "Hide the gold in - the@tree+stump"; + keyword = "Play-fair@Exam ple"; + correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF"; + output = cipher.encode(keyword, inputString); + assertEquals("Playfair failed secure mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output); } }