diff --git a/pom.xml b/pom.xml index 46a2663..844dae3 100644 --- a/pom.xml +++ b/pom.xml @@ -26,7 +26,7 @@ com.mattrixwv cipher-stream-java - 1.3.10-SNAPSHOT + 1.4.0-SNAPSHOT CipherStreamJava A library to encrypt and decrypt simple ciphers @@ -54,13 +54,13 @@ com.mattrixwv myClasses - 1.3.9 + 1.4.1 com.mattrixwv matrix - 1.2.3 + 1.3.1 diff --git a/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidBaseException.java b/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidBaseException.java index 778de57..cb1e7c2 100644 --- a/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidBaseException.java +++ b/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidBaseException.java @@ -1,23 +1,3 @@ -//CipherStreamJava/src/main/java/com/mattrixwv/CipherStreamJava/Exceptions/InvalidBaseException.java -//Mattrixwv -// Created: 01-09-22 -//Modified: 08-11-24 -/* - Copyright (C) 2024 Mattrixwv - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Lesser General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program. If not, see . -*/ package com.mattrixwv.cipherstream.exceptions; diff --git a/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidCharacterException.java b/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidCharacterException.java index fb4e62d..409da75 100644 --- a/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidCharacterException.java +++ b/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidCharacterException.java @@ -1,23 +1,3 @@ -//CipherStreamJava/src/main/java/com/mattrixwv/CipherStreamJava/Exceptions/InvalidCharacterException.java -//Mattrixwv -// Created: 01-04-22 -//Modified: 08-11-24 -/* - Copyright (C) 2024 Mattrixwv - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Lesser General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program. If not, see . -*/ package com.mattrixwv.cipherstream.exceptions; diff --git a/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidInputException.java b/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidInputException.java index 96d7482..2f20637 100644 --- a/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidInputException.java +++ b/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidInputException.java @@ -1,23 +1,3 @@ -//CipherStreamJava/src/main/java/com/mattrixwv/CipherStreamJava/Exceptions/InvalidInputException.java -//Mattrixwv -// Created: 01-09-22 -//Modified: 08-11-24 -/* - Copyright (C) 2024 Mattrixwv - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Lesser General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program. If not, see . -*/ package com.mattrixwv.cipherstream.exceptions; diff --git a/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidKeyException.java b/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidKeyException.java index dd7946a..d9c9245 100644 --- a/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidKeyException.java +++ b/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidKeyException.java @@ -1,23 +1,3 @@ -//CipherStreamJava/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidKeyException.java -//Matrixwv -// Created: 07-09-22 -//Modified: 08-11-24 -/* - Copyright (C) 2024 Mattrixwv - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Lesser General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program. If not, see . -*/ package com.mattrixwv.cipherstream.exceptions; diff --git a/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidKeywordException.java b/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidKeywordException.java index 5a8de5c..375bd6a 100644 --- a/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidKeywordException.java +++ b/src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidKeywordException.java @@ -1,23 +1,3 @@ -//CipherStreamJava/src/main/java/com/mattrixwv/CipherStreamJava/Exceptions/InvalidKeywordException.java -//Mattrixwv -// Created: 01-09-22 -//Modified: 08-11-24 -/* - Copyright (C) 2024 Mattrixwv - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Lesser General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program. If not, see . -*/ package com.mattrixwv.cipherstream.exceptions; diff --git a/src/main/java/com/mattrixwv/cipherstream/monosubstitution/Caesar.java b/src/main/java/com/mattrixwv/cipherstream/monosubstitution/Caesar.java index f8a9501..c31eb48 100644 --- a/src/main/java/com/mattrixwv/cipherstream/monosubstitution/Caesar.java +++ b/src/main/java/com/mattrixwv/cipherstream/monosubstitution/Caesar.java @@ -44,6 +44,11 @@ public final class Caesar{ logger.debug("Setting shift {}", shiftAmount); //If you shift more than 26 you will just be wrapping back around again + if(shiftAmount < 0){ + logger.debug("Negative shift detected, converting to positive equivalent"); + + shiftAmount += 26; + } shift = shiftAmount % 26; logger.debug("Cleaned shift {}", shift); @@ -100,7 +105,7 @@ public final class Caesar{ if(Character.isUpperCase(currentChar)){ logger.debug("Encoding uppercase"); - currentChar = (char)((int)currentChar + shift); + currentChar = (char)(currentChar + shift); //Wrap around if the letter is now out of bounds if(currentChar < 'A'){ logger.debug("Wrapping around to Z"); @@ -115,7 +120,7 @@ public final class Caesar{ else if(Character.isLowerCase(currentChar)){ logger.debug("Encoding lowercase"); - currentChar = (char)((int)currentChar + shift); + currentChar = (char)(currentChar + shift); //Wrap around if the letter is now out of bounds if(currentChar < 'a'){ logger.debug("Wrapping around to z"); @@ -150,7 +155,7 @@ public final class Caesar{ if(Character.isUpperCase(currentChar)){ logger.debug("Decoding uppercase"); - currentChar = (char)((int)currentChar - shift); + currentChar = (char)(currentChar - shift); //Wrap around if the letter is now out of bounds if(currentChar < 'A'){ logger.debug("Wrapping around to Z"); @@ -167,7 +172,7 @@ public final class Caesar{ else if(Character.isLowerCase(currentChar)){ logger.debug("Decoding lowercase"); - currentChar = (char)((int)currentChar - shift); + currentChar = (char)(currentChar - shift); //Wrap around if the letter is now out of bounds if(currentChar < 'a'){ logger.debug("Wrapping around to z"); diff --git a/src/test/java/com/mattrixwv/cipherstream/combination/ADFGVXTest.java b/src/test/java/com/mattrixwv/cipherstream/combination/ADFGVXTest.java index 9a004b3..6b5dda1 100644 --- a/src/test/java/com/mattrixwv/cipherstream/combination/ADFGVXTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/combination/ADFGVXTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/combination/TestADFGVX.java -//Mattrixwv -// Created: 01-26-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.combination; @@ -29,12 +25,12 @@ public class ADFGVXTest{ @Mock private Logger logger; //Variables - private static final String decodedString = "Message to^encode"; - private static final String decodedStringClean = "MESSAGETOENCODE"; - private static final String encodedString = "AXgvdavfxgagfa afag^aaxdxfgdagda"; - private static final String encodedStringClean = "AXGVDAVFXGAGFAAFAGAAXDXFGDAGDA"; - private static final String keyword = "keyword"; - private static final String squareKeyword = "SquareKeyword"; + private static final String DECODED_STRING = "Message to^encode"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String ENCODED_STRING = "AXgvdavfxgagfa afag^aaxdxfgdagda"; + private static final String ENCODED_STRING_CLEAN = "AXGVDAVFXGAGFAAFAGAAXDXFGDAGDA"; + private static final String KEYWORD = "keyword"; + private static final String SQUARE_KEYWORD = "SquareKeyword"; @Test @@ -99,10 +95,10 @@ public class ADFGVXTest{ @Test public void testSetSquareKeyword(){ - cipher.setSquareKeyword(squareKeyword); + cipher.setSquareKeyword(SQUARE_KEYWORD); - assertEquals(squareKeyword, cipher.squareKeyword); - verify(logger, times(1)).debug("squareKeyword '{}'", squareKeyword); + assertEquals(SQUARE_KEYWORD, cipher.squareKeyword); + verify(logger, times(1)).debug("squareKeyword '{}'", SQUARE_KEYWORD); } @Test @@ -117,10 +113,10 @@ public class ADFGVXTest{ @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keyword, cipher.keyword); - verify(logger, times(1)).debug("keyword '{}'", keyword); + assertEquals(KEYWORD, cipher.keyword); + verify(logger, times(1)).debug("keyword '{}'", KEYWORD); } @Test @@ -139,14 +135,14 @@ public class ADFGVXTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING); } @Test @@ -155,14 +151,14 @@ public class ADFGVXTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase()); } @Test @@ -171,14 +167,14 @@ public class ADFGVXTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("\\s", "")); } @Test @@ -187,14 +183,14 @@ public class ADFGVXTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -235,45 +231,45 @@ public class ADFGVXTest{ @Test public void testFormateOutputStringEncode(){ - cipher.inputString = decodedString; - cipher.outputString = encodedStringClean; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING_CLEAN; cipher.formatOutputStringEncode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Formatting output string to match input string"); verify(logger, times(17)).debug(eq("Input character {}"), anyChar()); verify(logger, times(1)).debug("Converting output to uppercase"); verify(logger, times(14)).debug("Converting output to lowercase"); verify(logger, times(2)).debug("Appending symbol to output"); - verify(logger, times(1)).debug("Saving output string '{}'", encodedString); + verify(logger, times(1)).debug("Saving output string '{}'", ENCODED_STRING); } @Test public void testFormatOutputStringDecode(){ - cipher.outputString = decodedStringClean; - cipher.inputString = encodedString; + cipher.outputString = DECODED_STRING_CLEAN; + cipher.inputString = ENCODED_STRING; cipher.formatOutputStringDecode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Formatting output string to match input string"); verify(logger, times(17)).debug(eq("Input character {}"), anyChar()); verify(logger, times(1)).debug("Converting output to uppercase"); verify(logger, times(14)).debug("Converting output to lowercase"); verify(logger, times(2)).debug("Appending symbol to output"); - verify(logger, times(1)).debug("Saving output string '{}'", decodedString); + verify(logger, times(1)).debug("Saving output string '{}'", DECODED_STRING); } @Test public void testEncode(){ - cipher.inputString = decodedString; - cipher.keyword = keyword; - cipher.squareKeyword = squareKeyword; + cipher.inputString = DECODED_STRING; + cipher.keyword = KEYWORD; + cipher.squareKeyword = SQUARE_KEYWORD; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding using Polybius Square"); verify(logger, times(1)).debug("Replacing coordinates with letters"); verify(logger, times(1)).debug("Encoding using columnar"); @@ -281,13 +277,13 @@ public class ADFGVXTest{ @Test public void testDecode(){ - cipher.inputString = encodedString; - cipher.keyword = keyword; - cipher.squareKeyword = squareKeyword; + cipher.inputString = ENCODED_STRING; + cipher.keyword = KEYWORD; + cipher.squareKeyword = SQUARE_KEYWORD; cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding using columnar"); verify(logger, times(1)).debug("Replacing letters with coordinates"); verify(logger, times(1)).debug("Decoding using Polybius Square"); @@ -295,25 +291,25 @@ public class ADFGVXTest{ @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.squareKeyword = squareKeyword; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.squareKeyword = SQUARE_KEYWORD; + cipher.keyword = KEYWORD; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); - assertEquals(squareKeyword, cipher.getSquareKeyword()); - assertEquals(keyword, cipher.getKeyword()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); + assertEquals(SQUARE_KEYWORD, cipher.getSquareKeyword()); + assertEquals(KEYWORD, cipher.getKeyword()); } @Test public void testReset(){ LargePolybiusSquare ps = cipher.largePolybiusSquare; Columnar columnar = cipher.columnar; - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.squareKeyword = squareKeyword; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.squareKeyword = SQUARE_KEYWORD; + cipher.keyword = KEYWORD; cipher.reset(); @@ -330,47 +326,47 @@ public class ADFGVXTest{ public void testPracticalEncoding(){ cipher = new ADFGVX(true, true, true); - String output = cipher.encode(squareKeyword, keyword, decodedString); + String output = cipher.encode(SQUARE_KEYWORD, KEYWORD, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(keyword, cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(KEYWORD, cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new ADFGVX(false, false, false); - String output = cipher.encode(squareKeyword, keyword, decodedString); + String output = cipher.encode(SQUARE_KEYWORD, KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(keyword, cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD, cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding(){ cipher = new ADFGVX(true, true, true); - String output = cipher.decode(squareKeyword, keyword, encodedString); + String output = cipher.decode(SQUARE_KEYWORD, KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(keyword, cipher.keyword); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEYWORD, cipher.keyword); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_clean(){ cipher = new ADFGVX(false, false, false); - String output = cipher.decode(squareKeyword, keyword, encodedString); + String output = cipher.decode(SQUARE_KEYWORD, KEYWORD, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(keyword, cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD, cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/combination/ADFGXTest.java b/src/test/java/com/mattrixwv/cipherstream/combination/ADFGXTest.java index c4dcb32..294f7b3 100644 --- a/src/test/java/com/mattrixwv/cipherstream/combination/ADFGXTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/combination/ADFGXTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/combination/TestADFGX.java -//Mattrixwv -// Created: 01-25-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.combination; @@ -29,12 +25,12 @@ public class ADFGXTest{ @Mock private Logger logger; //Variables - private static final String decodedString = "Message to^encode"; - private static final String decodedStringClean = "MESSAGETOENCODE"; - private static final String encodedString = "AAgagadfagaxxd axdx^adafafxddgdf"; - private static final String encodedStringClean = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF"; - private static final String keyword = "keyword"; - private static final String squareKeyword = "SquareKeyword"; + private static final String DECODED_STRING = "Message to^encode"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String ENCODED_STRING = "AAgagadfagaxxd axdx^adafafxddgdf"; + private static final String ENCODED_STRING_CLEAN = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF"; + private static final String KEYWORD = "keyword"; + private static final String SQUARE_KEYWORD = "SquareKeyword"; @Test @@ -99,9 +95,9 @@ public class ADFGXTest{ @Test public void testSetSquareKeyword(){ - cipher.setSquareKeyword(squareKeyword); - assertEquals(squareKeyword, cipher.squareKeyword); - verify(logger, times(1)).debug("Square keyword '{}'", squareKeyword); + cipher.setSquareKeyword(SQUARE_KEYWORD); + assertEquals(SQUARE_KEYWORD, cipher.squareKeyword); + verify(logger, times(1)).debug("Square keyword '{}'", SQUARE_KEYWORD); } @Test @@ -116,10 +112,10 @@ public class ADFGXTest{ @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keyword, cipher.keyword); - verify(logger, times(1)).debug("Keyword '{}'", keyword); + assertEquals(KEYWORD, cipher.keyword); + verify(logger, times(1)).debug("Keyword '{}'", KEYWORD); } @Test @@ -138,14 +134,14 @@ public class ADFGXTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING); } @Test @@ -154,14 +150,14 @@ public class ADFGXTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase()); } @Test @@ -170,14 +166,14 @@ public class ADFGXTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("\\s", "")); } @Test @@ -186,14 +182,14 @@ public class ADFGXTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -234,45 +230,45 @@ public class ADFGXTest{ @Test public void testFormatOutputStringEncode(){ - cipher.inputString = decodedString; - cipher.outputString = encodedStringClean; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING_CLEAN; cipher.formatOutputStringEncode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Formatting output string to match input string"); verify(logger, times(17)).debug(eq("Input character {}"), anyChar()); verify(logger, times(1)).debug("Converting output to uppercase"); verify(logger, times(14)).debug("Converting output to lowercase"); verify(logger, times(2)).debug("Appending symbol to output"); - verify(logger, times(1)).debug("Saving output string '{}'", encodedString); + verify(logger, times(1)).debug("Saving output string '{}'", ENCODED_STRING); } @Test public void testFormatOutputStringDecode(){ - cipher.outputString = decodedStringClean; - cipher.inputString = encodedString; + cipher.outputString = DECODED_STRING_CLEAN; + cipher.inputString = ENCODED_STRING; cipher.formatOutputStringDecode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Formatting output string to match input string"); verify(logger, times(17)).debug(eq("Input character {}"), anyChar()); verify(logger, times(1)).debug("Converting output to uppercase"); verify(logger, times(14)).debug("Converting output to lowercase"); verify(logger, times(2)).debug("Appending symbol to output"); - verify(logger, times(1)).debug("Saving output string '{}'", decodedString); + verify(logger, times(1)).debug("Saving output string '{}'", DECODED_STRING); } @Test public void testEncode(){ - cipher.inputString = decodedString; - cipher.keyword = keyword; - cipher.squareKeyword = squareKeyword; + cipher.inputString = DECODED_STRING; + cipher.keyword = KEYWORD; + cipher.squareKeyword = SQUARE_KEYWORD; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding using Polybius Square"); verify(logger, times(1)).debug("Replacing coordinates with letters"); verify(logger, times(1)).debug("Encoding using columnar"); @@ -280,13 +276,13 @@ public class ADFGXTest{ @Test public void testDecode(){ - cipher.inputString = encodedString; - cipher.keyword = keyword; - cipher.squareKeyword = squareKeyword; + cipher.inputString = ENCODED_STRING; + cipher.keyword = KEYWORD; + cipher.squareKeyword = SQUARE_KEYWORD; cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding using columnar"); verify(logger, times(1)).debug("Replacing letters with coordinates"); verify(logger, times(1)).debug("Decoding using Polybius Square"); @@ -294,25 +290,25 @@ public class ADFGXTest{ @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.squareKeyword = squareKeyword; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.squareKeyword = SQUARE_KEYWORD; + cipher.keyword = KEYWORD; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); - assertEquals(squareKeyword, cipher.getSquareKeyword()); - assertEquals(keyword, cipher.getKeyword()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); + assertEquals(SQUARE_KEYWORD, cipher.getSquareKeyword()); + assertEquals(KEYWORD, cipher.getKeyword()); } @Test public void testReset(){ PolybiusSquare polybius = cipher.polybiusSquare; Columnar columnar = cipher.columnar; - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.squareKeyword = squareKeyword; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.squareKeyword = SQUARE_KEYWORD; + cipher.keyword = KEYWORD; cipher.reset(); @@ -329,47 +325,47 @@ public class ADFGXTest{ public void testPracticalEncoding(){ cipher = new ADFGX(true, true, true); - String output = cipher.encode(squareKeyword, keyword, decodedString); + String output = cipher.encode(SQUARE_KEYWORD, KEYWORD, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new ADFGX(false, false, false); - String output = cipher.encode(squareKeyword, keyword, decodedString); + String output = cipher.encode(SQUARE_KEYWORD, KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding(){ cipher = new ADFGX(true, true, true); - String output = cipher.decode(squareKeyword, keyword, encodedString); + String output = cipher.decode(SQUARE_KEYWORD, KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_clean(){ cipher = new ADFGX(false, false, false); - String output = cipher.decode(squareKeyword, keyword, encodedString); + String output = cipher.decode(SQUARE_KEYWORD, KEYWORD, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidBaseExceptionTest.java b/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidBaseExceptionTest.java index 10c84f5..5050af8 100644 --- a/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidBaseExceptionTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidBaseExceptionTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/exceptions/TestInvalidBaseException.java -//Mattrixwv -// Created: 04-14-23 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.exceptions; @@ -11,8 +7,8 @@ import org.junit.jupiter.api.Test; public class InvalidBaseExceptionTest{ - private static final String message = "message"; - private static final Throwable cause = new Exception(); + private static final String MESSAGE = "message"; + private static final Throwable CAUSE = new Exception(); @Test @@ -24,22 +20,22 @@ public class InvalidBaseExceptionTest{ @Test public void testConstructor_message(){ - InvalidBaseException exception = new InvalidBaseException(message); - assertEquals(message, exception.getMessage()); + InvalidBaseException exception = new InvalidBaseException(MESSAGE); + assertEquals(MESSAGE, exception.getMessage()); assertNull(exception.getCause()); } @Test public void testConstructor_cause(){ - InvalidBaseException exception = new InvalidBaseException(cause); - assertEquals(cause.toString(), exception.getMessage()); - assertEquals(cause, exception.getCause()); + InvalidBaseException exception = new InvalidBaseException(CAUSE); + assertEquals(CAUSE.toString(), exception.getMessage()); + assertEquals(CAUSE, exception.getCause()); } @Test public void testConstructor_messageAndCause(){ - InvalidBaseException exception = new InvalidBaseException(message, cause); - assertEquals(message, exception.getMessage()); - assertEquals(cause, exception.getCause()); + InvalidBaseException exception = new InvalidBaseException(MESSAGE, CAUSE); + assertEquals(MESSAGE, exception.getMessage()); + assertEquals(CAUSE, exception.getCause()); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidCharacterExceptionTest.java b/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidCharacterExceptionTest.java index 44846a4..1b8a8b5 100644 --- a/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidCharacterExceptionTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidCharacterExceptionTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/exceptions/TestInvalidcharacterException.java -//Mattrixwv -// Created: 04-14-23 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.exceptions; @@ -11,8 +7,8 @@ import org.junit.jupiter.api.Test; public class InvalidCharacterExceptionTest{ - private String message = "message"; - private Throwable cause = new Exception(); + private static final String MESSAGE = "message"; + private static final Throwable CAUSE = new Exception(); @Test @@ -24,22 +20,22 @@ public class InvalidCharacterExceptionTest{ @Test public void testConstructor_message(){ - InvalidCharacterException exception = new InvalidCharacterException(message); - assertEquals(message, exception.getMessage()); + InvalidCharacterException exception = new InvalidCharacterException(MESSAGE); + assertEquals(MESSAGE, exception.getMessage()); assertNull(exception.getCause()); } @Test public void testConstructor_cause(){ - InvalidCharacterException exception = new InvalidCharacterException(cause); - assertEquals(cause.toString(), exception.getMessage()); - assertEquals(cause, exception.getCause()); + InvalidCharacterException exception = new InvalidCharacterException(CAUSE); + assertEquals(CAUSE.toString(), exception.getMessage()); + assertEquals(CAUSE, exception.getCause()); } @Test public void testConstructor_messageAndCause(){ - InvalidCharacterException exception = new InvalidCharacterException(message, cause); - assertEquals(message, exception.getMessage()); - assertEquals(cause, exception.getCause()); + InvalidCharacterException exception = new InvalidCharacterException(MESSAGE, CAUSE); + assertEquals(MESSAGE, exception.getMessage()); + assertEquals(CAUSE, exception.getCause()); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidInputExceptionTest.java b/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidInputExceptionTest.java index 88f056c..a8fe84a 100644 --- a/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidInputExceptionTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidInputExceptionTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/exception/TestInvalidInputException.java -//Mattrixwv -// Created: 04-14-23 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.exceptions; @@ -11,8 +7,8 @@ import org.junit.jupiter.api.Test; public class InvalidInputExceptionTest{ - private String message = "message"; - private Throwable cause = new Exception(); + private static final String MESSAGE = "message"; + private static final Throwable CAUSE = new Exception(); @Test @@ -24,22 +20,22 @@ public class InvalidInputExceptionTest{ @Test public void testConstructor_message(){ - InvalidInputException exception = new InvalidInputException(message); - assertEquals(message, exception.getMessage()); + InvalidInputException exception = new InvalidInputException(MESSAGE); + assertEquals(MESSAGE, exception.getMessage()); assertNull(exception.getCause()); } @Test public void testConstructor_cause(){ - InvalidInputException exception = new InvalidInputException(cause); - assertEquals(cause.toString(), exception.getMessage()); - assertEquals(cause, exception.getCause()); + InvalidInputException exception = new InvalidInputException(CAUSE); + assertEquals(CAUSE.toString(), exception.getMessage()); + assertEquals(CAUSE, exception.getCause()); } @Test public void testConstructor_messageAndCause(){ - InvalidInputException exception = new InvalidInputException(message, cause); - assertEquals(message, exception.getMessage()); - assertEquals(cause, exception.getCause()); + InvalidInputException exception = new InvalidInputException(MESSAGE, CAUSE); + assertEquals(MESSAGE, exception.getMessage()); + assertEquals(CAUSE, exception.getCause()); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidKeyExceptionTest.java b/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidKeyExceptionTest.java index f688f5d..e9949d9 100644 --- a/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidKeyExceptionTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidKeyExceptionTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/exceptions/TestInvalidKeyException.java -//Mattrixwv -// Created: 04-14-23 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.exceptions; @@ -11,8 +7,8 @@ import org.junit.jupiter.api.Test; public class InvalidKeyExceptionTest{ - public String message = "message"; - public Throwable cause = new Exception(); + public static final String MESSAGE = "message"; + public static final Throwable CAUSE = new Exception(); @Test @@ -24,22 +20,22 @@ public class InvalidKeyExceptionTest{ @Test public void testConstructor_message(){ - InvalidKeyException exception = new InvalidKeyException(message); - assertEquals(message, exception.getMessage()); + InvalidKeyException exception = new InvalidKeyException(MESSAGE); + assertEquals(MESSAGE, exception.getMessage()); assertNull(exception.getCause()); } @Test public void testConstructor_cause(){ - InvalidKeyException exception = new InvalidKeyException(cause); - assertEquals(cause.toString(), exception.getMessage()); - assertEquals(cause, exception.getCause()); + InvalidKeyException exception = new InvalidKeyException(CAUSE); + assertEquals(CAUSE.toString(), exception.getMessage()); + assertEquals(CAUSE, exception.getCause()); } @Test public void testConstructor_messageAndCause(){ - InvalidKeyException exception = new InvalidKeyException(message, cause); - assertEquals(message, exception.getMessage()); - assertEquals(cause, exception.getCause()); + InvalidKeyException exception = new InvalidKeyException(MESSAGE, CAUSE); + assertEquals(MESSAGE, exception.getMessage()); + assertEquals(CAUSE, exception.getCause()); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidKeywordExceptionTest.java b/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidKeywordExceptionTest.java index 487c5ab..eb411a4 100644 --- a/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidKeywordExceptionTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidKeywordExceptionTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/exceptions/TestInvalidKeywordException.java -//Mattrixwv -// Created: 04-14-23 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.exceptions; @@ -11,8 +7,8 @@ import org.junit.jupiter.api.Test; public class InvalidKeywordExceptionTest{ - private String message = "message"; - private Throwable cause = new Exception(); + private static final String MESSAGE = "message"; + private static final Throwable CAUSE = new Exception(); @Test @@ -24,22 +20,22 @@ public class InvalidKeywordExceptionTest{ @Test public void testConstructor_message(){ - InvalidKeywordException exception = new InvalidKeywordException(message); - assertEquals(message, exception.getMessage()); + InvalidKeywordException exception = new InvalidKeywordException(MESSAGE); + assertEquals(MESSAGE, exception.getMessage()); assertNull(exception.getCause()); } @Test public void testConstructor_cause(){ - InvalidKeywordException exception = new InvalidKeywordException(cause); - assertEquals(cause.toString(), exception.getMessage()); - assertEquals(cause, exception.getCause()); + InvalidKeywordException exception = new InvalidKeywordException(CAUSE); + assertEquals(CAUSE.toString(), exception.getMessage()); + assertEquals(CAUSE, exception.getCause()); } @Test public void testConstructor_messageAndCause(){ - InvalidKeywordException exception = new InvalidKeywordException(message, cause); - assertEquals(message, exception.getMessage()); - assertEquals(cause, exception.getCause()); + InvalidKeywordException exception = new InvalidKeywordException(MESSAGE, CAUSE); + assertEquals(MESSAGE, exception.getMessage()); + assertEquals(CAUSE, exception.getCause()); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AffineTest.java b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AffineTest.java index 6d0f993..2c9241c 100644 --- a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AffineTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AffineTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/polysubstitution/AffineTest.java -//Mattrixwv -// Created: 01-26-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.monosubstitution; @@ -27,12 +23,12 @@ public class AffineTest{ @Mock private Logger logger; //Variables - private static final String decodedString = "MEssage to^encode"; - private static final String decodedStringClean = "messagetoencode"; - private static final String encodedString = "PBtthlb yz^burzwb"; - private static final String encodedStringClean = "pbtthlbyzburzwb"; - private static final int key1 = 5; - private static final int key2 = 7; + private static final String DECODED_STRING = "MEssage to^encode"; + private static final String DECODED_STRING_CLEAN = "messagetoencode"; + private static final String ENCODED_STRING = "PBtthlb yz^burzwb"; + private static final String ENCODED_STRING_CLEAN = "pbtthlbyzburzwb"; + private static final int KEY_1 = 5; + private static final int KEY_2 = 7; @Test @@ -89,11 +85,11 @@ public class AffineTest{ @Test public void testKey1(){ - cipher.setKey1(key1); + cipher.setKey1(KEY_1); - assertEquals(key1, cipher.key1); - verify(logger, times(1)).debug("Setting key1 {}", key1); - verify(logger, times(1)).debug("Cleaned key1 {}", key1); + assertEquals(KEY_1, cipher.key1); + verify(logger, times(1)).debug("Setting key1 {}", KEY_1); + verify(logger, times(1)).debug("Cleaned key1 {}", KEY_1); } @Test @@ -117,20 +113,20 @@ public class AffineTest{ @Test public void testSetKey1_large(){ - cipher.setKey1(key1 + 26); + cipher.setKey1(KEY_1 + 26); - assertEquals(key1, cipher.key1); - verify(logger, times(1)).debug("Setting key1 {}", key1 + 26); - verify(logger, times(1)).debug("Cleaned key1 {}", key1); + assertEquals(KEY_1, cipher.key1); + verify(logger, times(1)).debug("Setting key1 {}", KEY_1 + 26); + verify(logger, times(1)).debug("Cleaned key1 {}", KEY_1); } @Test public void testSetKey2(){ - cipher.setKey2(key2); + cipher.setKey2(KEY_2); - assertEquals(key2, cipher.key2); - verify(logger, times(1)).debug("Setting key2 {}", key2); - verify(logger, times(1)).debug("Cleaned key2 {}", key2); + assertEquals(KEY_2, cipher.key2); + verify(logger, times(1)).debug("Setting key2 {}", KEY_2); + verify(logger, times(1)).debug("Cleaned key2 {}", KEY_2); } @Test @@ -144,11 +140,11 @@ public class AffineTest{ @Test public void testSetKey2_large(){ - cipher.setKey2(key2 + 26); + cipher.setKey2(KEY_2 + 26); - assertEquals(key2, cipher.key2); - verify(logger, times(1)).debug("Setting key2 {}", key2 + 26); - verify(logger, times(1)).debug("Cleaned key2 {}", key2); + assertEquals(KEY_2, cipher.key2); + verify(logger, times(1)).debug("Setting key2 {}", KEY_2 + 26); + verify(logger, times(1)).debug("Cleaned key2 {}", KEY_2); } @Test @@ -157,14 +153,14 @@ public class AffineTest{ cipher.preserveSymbols = true; cipher.preserveWhitespace = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING); } @Test @@ -173,14 +169,14 @@ public class AffineTest{ cipher.preserveSymbols = true; cipher.preserveWhitespace = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.toLowerCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toLowerCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toLowerCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toLowerCase()); } @Test @@ -189,14 +185,14 @@ public class AffineTest{ cipher.preserveSymbols = true; cipher.preserveWhitespace = false; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing sybols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("\\s", "")); } @Test @@ -205,14 +201,14 @@ public class AffineTest{ cipher.preserveSymbols = false; cipher.preserveWhitespace = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -256,17 +252,17 @@ public class AffineTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.inputString = decodedString; - cipher.key1 = key1; - cipher.key2 = key2; + cipher.inputString = DECODED_STRING; + cipher.key1 = KEY_1; + cipher.key2 = KEY_2; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(17)).debug(eq("Current char {}"), anyChar()); verify(logger, times(15)).debug(eq("Encoded char {}"), anyChar()); - verify(logger, times(1)).debug("Saving output string '{}'", encodedString); + verify(logger, times(1)).debug("Saving output string '{}'", ENCODED_STRING); } @Test @@ -274,39 +270,39 @@ public class AffineTest{ cipher.preserveCapitals = true; cipher.preserveSymbols = true; cipher.preserveWhitespace = true; - cipher.inputString = encodedString; - cipher.key1 = key1; - cipher.key2 = key2; + cipher.inputString = ENCODED_STRING; + cipher.key1 = KEY_1; + cipher.key2 = KEY_2; cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(1)).debug("Key1 inverse {}", 21); verify(logger, times(17)).debug(eq("Current char {}"), anyChar()); verify(logger, times(15)).debug(eq("Decoded char {}"), anyChar()); - verify(logger, times(1)).debug("Saving output string '{}'", decodedString); + verify(logger, times(1)).debug("Saving output string '{}'", DECODED_STRING); } @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.key1 = key1; - cipher.key2 = key2; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.key1 = KEY_1; + cipher.key2 = KEY_2; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); - assertEquals(key1, cipher.getKey1()); - assertEquals(key2, cipher.getKey2()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); + assertEquals(KEY_1, cipher.getKey1()); + assertEquals(KEY_2, cipher.getKey2()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.key1 = key1; - cipher.key2 = key2; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.key1 = KEY_1; + cipher.key2 = KEY_2; cipher.reset(); @@ -321,51 +317,51 @@ public class AffineTest{ public void testPracticalEncoding(){ cipher = new Affine(true, true, true); - String output = cipher.encode(key1, key2, decodedString); + String output = cipher.encode(KEY_1, KEY_2, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(key1, cipher.key1); - assertEquals(key2, cipher.key2); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(KEY_1, cipher.key1); + assertEquals(KEY_2, cipher.key2); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new Affine(false, false, false); - String output = cipher.encode(key1, key2, decodedString); + String output = cipher.encode(KEY_1, KEY_2, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(key1, cipher.key1); - assertEquals(key2, cipher.key2); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEY_1, cipher.key1); + assertEquals(KEY_2, cipher.key2); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding(){ cipher = new Affine(true, true, true); - String output = cipher.decode(key1, key2, encodedString); + String output = cipher.decode(KEY_1, KEY_2, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(key1, cipher.key1); - assertEquals(key2, cipher.key2); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEY_1, cipher.key1); + assertEquals(KEY_2, cipher.key2); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testpracticalDecoding_clean(){ cipher = new Affine(false, false, false); - String output = cipher.decode(key1, key2, encodedString); + String output = cipher.decode(KEY_1, KEY_2, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(key1, cipher.key1); - assertEquals(key2, cipher.key2); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEY_1, cipher.key1); + assertEquals(KEY_2, cipher.key2); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AtbashTest.java b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AtbashTest.java index a475046..1696ceb 100644 --- a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AtbashTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AtbashTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AtbashTest.java -//Mattrixwv -// Created: 07-25-21 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.monosubstitution; @@ -26,10 +22,10 @@ public class AtbashTest{ @Mock private Logger logger; //Variables - private static final String decodedString = "Message to^encode"; - private static final String decodedStringClean = "MESSAGETOENCODE"; - private static final String encodedString = "Nvhhztv gl^vmxlwv"; - private static final String encodedStringClean = "NVHHZTVGLVMXLWV"; + private static final String DECODED_STRING = "Message to^encode"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String ENCODED_STRING = "Nvhhztv gl^vmxlwv"; + private static final String ENCODED_STRING_CLEAN = "NVHHZTVGLVMXLWV"; @Test @@ -78,17 +74,17 @@ public class AtbashTest{ @Test public void testEncode(){ - cipher.inputString = decodedString; + cipher.inputString = DECODED_STRING; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(17)).debug(eq("Encoding char {}"), anyChar()); verify(logger, times(1)).debug("Encoding uppercase"); verify(logger, times(14)).debug("Encoding lowercase"); verify(logger, times(2)).debug("Appending symbol"); - verify(logger, times(1)).debug("Saving output string '{}'", encodedString); + verify(logger, times(1)).debug("Saving output string '{}'", ENCODED_STRING); } @Test @@ -97,14 +93,14 @@ public class AtbashTest{ cipher.preserveSymbols = true; cipher.preserveWhitespace = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING); } @Test @@ -113,14 +109,14 @@ public class AtbashTest{ cipher.preserveSymbols = true; cipher.preserveWhitespace = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase()); } @Test @@ -129,14 +125,14 @@ public class AtbashTest{ cipher.preserveSymbols = true; cipher.preserveWhitespace = false; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("\\s", "")); } @Test @@ -145,14 +141,14 @@ public class AtbashTest{ cipher.preserveSymbols = false; cipher.preserveWhitespace = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -178,7 +174,7 @@ public class AtbashTest{ cipher.preserveCapitals = true; cipher.preserveSymbols = true; cipher.preserveWhitespace = true; - cipher.inputString = decodedString; + cipher.inputString = DECODED_STRING; assertThrows(InvalidInputException.class, () -> { cipher.setInputString(""); @@ -194,17 +190,17 @@ public class AtbashTest{ @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; cipher.reset(); @@ -217,43 +213,43 @@ public class AtbashTest{ public void testPracticalEncoding(){ cipher = new Atbash(true, true, true); - String output = cipher.encode(decodedString); + String output = cipher.encode(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new Atbash(false, false, false); - String output = cipher.encode(decodedString); + String output = cipher.encode(DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding(){ cipher = new Atbash(true, true, true); - String output = cipher.decode(encodedString); + String output = cipher.decode(ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_clean(){ cipher = new Atbash(false, false, false); - String output = cipher.decode(encodedString); + String output = cipher.decode(ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AutokeyTest.java b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AutokeyTest.java index 93a192a..1d4b482 100644 --- a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AutokeyTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AutokeyTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/monosubstitution/AutokeyTest.java -//Mattrixwv -// Created: 07-26-21 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.monosubstitution; @@ -27,12 +23,12 @@ public class AutokeyTest{ @Mock(name = "com.mattrixwv.cipherstream.monosubstitution.Autokey") private Logger logger; //Variables - private static final String decodedString = "MeSsage to^encode"; - private static final String decodedStringClean = "MESSAGETOENCODE"; - private static final String encodedString = "WiQooxh fs^wfcuhx"; - private static final String encodedStringClean = "WIQOOXHFSWFCUHX"; - private static final String keyword = "keyword"; - private static final ArrayList offset = new ArrayList<>(List.of(10, 4, 24, 22, 14, 17, 3, 12, 4, 18, 18, 0, 6, 4, 19)); + private static final String DECODED_STRING = "MeSsage to^encode"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String ENCODED_STRING = "WiQooxh fs^wfcuhx"; + private static final String ENCODED_STRING_CLEAN = "WIQOOXHFSWFCUHX"; + private static final String KEYWORD = "keyword"; + private static final ArrayList OFFSET = new ArrayList<>(List.of(10, 4, 24, 22, 14, 17, 3, 12, 4, 18, 18, 0, 6, 4, 19)); @Test @@ -93,11 +89,11 @@ public class AutokeyTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.encodeSet(keyword, decodedString); + cipher.encodeSet(KEYWORD, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals((keyword + decodedString.replaceAll("\\s", "").replaceAll("[^a-zA-Z\\s]", "").substring(0, 8)).toUpperCase(), cipher.keyword); - assertEquals(offset, cipher.offset); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals((KEYWORD + DECODED_STRING.replaceAll("\\s", "").replaceAll("[^a-zA-Z\\s]", "").substring(0, 8)).toUpperCase(), cipher.keyword); + assertEquals(OFFSET, cipher.offset); verify(logger, times(1)).debug("Setting fields for encoding"); verify(logger, times(1)).debug("Setting keyword"); verify(logger, times(1)).debug("Adding input to keyword"); @@ -110,10 +106,10 @@ public class AutokeyTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.decodeSet(keyword, decodedString); + cipher.decodeSet(KEYWORD, DECODED_STRING); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(decodedString, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(DECODED_STRING, cipher.inputString); verify(logger, times(1)).debug("Setting fields for decoding"); verify(logger, times(1)).debug("Setting keyword"); verify(logger, times(1)).debug("Setting input string"); @@ -124,11 +120,11 @@ public class AutokeyTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.decodeSet(keyword, encodedString); + cipher.decodeSet(KEYWORD, ENCODED_STRING); cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(2)).debug("Appending partial output to keyword"); verify(logger, times(17)).debug(eq("Working character {}"), anyChar()); @@ -137,27 +133,27 @@ public class AutokeyTest{ verify(logger, times(13)).debug("Appending lowercase"); verify(logger, times(3)).debug("Wrapping around to z"); verify(logger, times(17)).debug(eq("Decoded letter {}"), anyChar()); - verify(logger, times(1)).debug("Saving output string '{}'", decodedString); + verify(logger, times(1)).debug("Saving output string '{}'", DECODED_STRING); } @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; cipher.offset.add(1); - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); - assertEquals(keyword, cipher.getKeyword()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); + assertEquals(KEYWORD, cipher.getKeyword()); assertEquals(new ArrayList<>(List.of(1)), cipher.getOffsets()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; cipher.offset.add(1); cipher.reset(); @@ -172,47 +168,47 @@ public class AutokeyTest{ public void testPracticalEncoding(){ cipher = new Autokey(true, true, true); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals((keyword + decodedStringClean.substring(0, 8)).toUpperCase(), cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals((KEYWORD + DECODED_STRING_CLEAN.substring(0, 8)).toUpperCase(), cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new Autokey(false, false, false); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals((keyword + decodedStringClean.substring(0, 8)).toUpperCase(), cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals((KEYWORD + DECODED_STRING_CLEAN.substring(0, 8)).toUpperCase(), cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding(){ cipher = new Autokey(true, true, true); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals((keyword + decodedStringClean.substring(0, 14)).toUpperCase(), cipher.keyword); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals((KEYWORD + DECODED_STRING_CLEAN.substring(0, 14)).toUpperCase(), cipher.keyword); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testpracticalDecoding_clean(){ cipher = new Autokey(false, false, false); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals((keyword + decodedStringClean.substring(0, 14)).toUpperCase(), cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals((KEYWORD + DECODED_STRING_CLEAN.substring(0, 14)).toUpperCase(), cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BaconianTest.java b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BaconianTest.java index 558d61a..564890a 100644 --- a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BaconianTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BaconianTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/BaconianTest.java -//Mattrixwv -// Created: 01-12-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.monosubstitution; @@ -27,10 +23,10 @@ public class BaconianTest{ @Mock private Logger logger; //Variables - private static final String decodedString = "Message to-encode"; - private static final String decodedStringClean = "Messagetoencode"; - private static final String decodedStringCleanLower = "messagetoencode"; - private static final String encodedString = "ABABB aabaa baaab baaab aaaaa aabba aabaa baaba abbab aabaa abbaa aaaba abbab aaabb aabaa"; + private static final String DECODED_STRING = "Message to-encode"; + private static final String DECODED_STRING_CLEAN = "Messagetoencode"; + private static final String DECODED_STRING_CLEAN_LOWER = "messagetoencode"; + private static final String ENCODED_STRING = "ABABB aabaa baaab baaab aaaaa aabba aabaa baaba abbab aabaa abbaa aaaba abbab aaabb aabaa"; @Test @@ -55,24 +51,24 @@ public class BaconianTest{ public void testSetInputStringEncode(){ cipher.preserveCapitals = true; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - verify(logger, times(1)).debug("Setting input string for encoding '{}'", decodedString); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + verify(logger, times(1)).debug("Setting input string for encoding '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringClean); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_CLEAN); } @Test public void testSetInputStringEncode_noCapitals(){ cipher.preserveCapitals = false; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringCleanLower, cipher.inputString); - verify(logger, times(1)).debug("Setting input string for encoding '{}'", decodedString); + assertEquals(DECODED_STRING_CLEAN_LOWER, cipher.inputString); + verify(logger, times(1)).debug("Setting input string for encoding '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing case"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringCleanLower); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_CLEAN_LOWER); } @Test @@ -107,30 +103,30 @@ public class BaconianTest{ public void testSetInputStringDecode(){ cipher.preserveCapitals = true; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - verify(logger, times(1)).debug("Setting input string for decoding '{}'", encodedString); + assertEquals(ENCODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Setting input string for decoding '{}'", ENCODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Ensuring all 'letters' contain 5 characters"); verify(logger, times(15)).debug(eq("Current 'letter' {}"), anyString()); verify(logger, times(15)).debug("Replacing all non-abAB characters"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING); } @Test public void testSetInputStringDecode_noCapitals(){ cipher.preserveCapitals = false; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedString.toLowerCase(), cipher.inputString); - verify(logger, times(1)).debug("Setting input string for decoding '{}'", encodedString); + assertEquals(ENCODED_STRING.toLowerCase(), cipher.inputString); + verify(logger, times(1)).debug("Setting input string for decoding '{}'", ENCODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Ensuring all 'letters' contain 5 characters"); verify(logger, times(15)).debug(eq("Current 'letter' {}"), anyString()); verify(logger, times(15)).debug("Replacing all non-abAB characters"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedString.toLowerCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING.toLowerCase()); } @Test @@ -204,49 +200,49 @@ public class BaconianTest{ @Test public void testEncode(){ cipher.preserveCapitals = true; - cipher.inputString = decodedStringClean; + cipher.inputString = DECODED_STRING_CLEAN; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(15)).debug(eq("Working character {}"), anyChar()); verify(logger, times(1)).debug("Encoding uppercase"); verify(logger, times(14)).debug("Encoding lowercase"); verify(logger, times(15)).debug(eq("Output letter {}"), anyString()); - verify(logger, times(1)).debug("Saving output string '{}'", encodedString); + verify(logger, times(1)).debug("Saving output string '{}'", ENCODED_STRING); } @Test public void testDecode(){ cipher.preserveCapitals = true; - cipher.inputString = encodedString; + cipher.inputString = ENCODED_STRING; cipher.decode(); - assertEquals(decodedStringClean, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(15)).debug(eq("Working letter {}"), anyString()); verify(logger, times(15)).debug(eq("Location of letter {}"), anyInt()); verify(logger, times(1)).debug("Decoding uppercase"); verify(logger, times(14)).debug("Decoding lowercase"); verify(logger, times(15)).debug(eq("Decoded character {}"), anyChar()); - verify(logger, times(1)).debug("Saving output string '{}'", decodedStringClean); + verify(logger, times(1)).debug("Saving output string '{}'", DECODED_STRING_CLEAN); } @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; cipher.reset(); @@ -259,65 +255,65 @@ public class BaconianTest{ public void testPracticalEncoding(){ cipher.preserveCapitals = true; - String output = cipher.encode(decodedString); + String output = cipher.encode(DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher.preserveCapitals = false; - String output = cipher.encode(decodedString); + String output = cipher.encode(DECODED_STRING); - assertEquals(decodedStringCleanLower, cipher.inputString); - assertEquals(encodedString.toLowerCase(), cipher.outputString); - assertEquals(encodedString.toLowerCase(), output); + assertEquals(DECODED_STRING_CLEAN_LOWER, cipher.inputString); + assertEquals(ENCODED_STRING.toLowerCase(), cipher.outputString); + assertEquals(ENCODED_STRING.toLowerCase(), output); } @Test public void testPracticalDecoding(){ cipher.preserveCapitals = true; - String output = cipher.decode(encodedString); + String output = cipher.decode(ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding_clean(){ cipher.preserveCapitals = false; - String output = cipher.decode(encodedString); + String output = cipher.decode(ENCODED_STRING); - assertEquals(encodedString.toLowerCase(), cipher.inputString); - assertEquals(decodedStringCleanLower, cipher.outputString); - assertEquals(decodedStringCleanLower, output); + assertEquals(ENCODED_STRING.toLowerCase(), cipher.inputString); + assertEquals(DECODED_STRING_CLEAN_LOWER, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN_LOWER, output); } @Test public void testPracticalDecoding_upper(){ cipher.preserveCapitals = false; - String output = cipher.decode(encodedString.toUpperCase()); + String output = cipher.decode(ENCODED_STRING.toUpperCase()); - assertEquals(encodedString.toLowerCase(), cipher.inputString); - assertEquals(decodedStringCleanLower, cipher.outputString); - assertEquals(decodedStringCleanLower, output); + assertEquals(ENCODED_STRING.toLowerCase(), cipher.inputString); + assertEquals(DECODED_STRING_CLEAN_LOWER, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN_LOWER, output); } @Test public void testPracticalDecoding_lower(){ cipher.preserveCapitals = false; - String output = cipher.decode(encodedString.toLowerCase()); + String output = cipher.decode(ENCODED_STRING.toLowerCase()); - assertEquals(encodedString.toLowerCase(), cipher.inputString); - assertEquals(decodedStringCleanLower, cipher.outputString); - assertEquals(decodedStringCleanLower, output); + assertEquals(ENCODED_STRING.toLowerCase(), cipher.inputString); + assertEquals(DECODED_STRING_CLEAN_LOWER, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN_LOWER, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BaseXTest.java b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BaseXTest.java index f55fd99..e3774ec 100644 --- a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BaseXTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BaseXTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BaseXTest.java -//Mattrixwv -// Created: 01-08-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.monosubstitution; @@ -28,11 +24,11 @@ public class BaseXTest{ @Mock private Logger logger; //Variables - private static final String decodedString = "A+B@C d\te\nf"; - private static final String encodedString_2 = "1000001 101011 1000010 1000000 1000011 100000 1100100 1001 1100101 1010 1100110"; - private static final String encodedString_8 = "101 53 102 100 103 40 144 11 145 12 146"; - private static final String encodedString_10 = "65 43 66 64 67 32 100 9 101 10 102"; - private static final String encodedString_16 = "41 2B 42 40 43 20 64 9 65 A 66"; + private static final String DECODED_STRING = "A+B@C d\te\nf"; + private static final String ENCODED_STRING_2 = "1000001 101011 1000010 1000000 1000011 100000 1100100 1001 1100101 1010 1100110"; + private static final String ENCODED_STRING_8 = "101 53 102 100 103 40 144 11 145 12 146"; + private static final String ENCODED_STRING_10 = "65 43 66 64 67 32 100 9 101 10 102"; + private static final String ENCODED_STRING_16 = "41 2B 42 40 43 20 64 9 65 A 66"; @Test @@ -55,10 +51,10 @@ public class BaseXTest{ @Test public void testSetInputStringEncode(){ - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - verify(logger, times(1)).debug("Setting input string for encoding '{}'", decodedString); + assertEquals(DECODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Setting input string for encoding '{}'", DECODED_STRING); } @Test @@ -78,7 +74,7 @@ public class BaseXTest{ }); assertEquals("", cipher.inputString); - verify(logger, never()).debug("Setting input string for encoding '{}'", decodedString); + verify(logger, never()).debug("Setting input string for encoding '{}'", DECODED_STRING); verify(logger, never()).debug(anyString(), anyString()); verify(logger, never()).debug(anyString()); } @@ -87,14 +83,14 @@ public class BaseXTest{ public void testSetInputStringDecode(){ cipher.base = 16; - cipher.setInputStringDecode(encodedString_16); + cipher.setInputStringDecode(ENCODED_STRING_16); - assertEquals(encodedString_16, cipher.inputString); - verify(logger, times(1)).debug("Setting input string for decoding '{}'", encodedString_16); + assertEquals(ENCODED_STRING_16, cipher.inputString); + verify(logger, times(1)).debug("Setting input string for decoding '{}'", ENCODED_STRING_16); verify(logger, times(1)).debug("Creating string of valid 'numbers'"); verify(logger, times(16)).debug(eq("Current number {}, converted {}"), anyInt(), anyString()); verify(logger, times(1)).debug("Checking for invalid characters"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedString_16); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING_16); } @Test @@ -176,29 +172,29 @@ public class BaseXTest{ @Test public void testEncode(){ cipher.base = 16; - cipher.inputString = decodedString; + cipher.inputString = DECODED_STRING; cipher.encode(); - assertEquals(encodedString_16, cipher.outputString); + assertEquals(ENCODED_STRING_16, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(11)).debug(eq("Working number {}"), anyChar()); verify(logger, times(11)).debug(eq("Converted number {}"), anyString()); - verify(logger, times(1)).debug("Saving output string '{}'", encodedString_16); + verify(logger, times(1)).debug("Saving output string '{}'", ENCODED_STRING_16); } @Test public void testDecode(){ cipher.base = 16; - cipher.inputString = encodedString_16; + cipher.inputString = ENCODED_STRING_16; cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(11)).debug(eq("Current number {}"), anyString()); verify(logger, times(11)).debug(eq("Decoded number {}"), anyInt()); - verify(logger, times(1)).debug("Saving output string '{}'", decodedString); + verify(logger, times(1)).debug("Saving output string '{}'", DECODED_STRING); } @Test @@ -218,19 +214,19 @@ public class BaseXTest{ @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString_2; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING_2; cipher.base = 8; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString_2, cipher.getOutputString()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING_2, cipher.getOutputString()); assertEquals(8, cipher.getBase()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString_2; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING_2; cipher.reset(); @@ -241,101 +237,101 @@ public class BaseXTest{ @Test public void testPracticalEncoding_2(){ - String output = cipher.encode(2, decodedString); + String output = cipher.encode(2, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); + assertEquals(DECODED_STRING, cipher.inputString); assertEquals(2, cipher.base); - assertEquals(encodedString_2, cipher.outputString); - assertEquals(encodedString_2, output); + assertEquals(ENCODED_STRING_2, cipher.outputString); + assertEquals(ENCODED_STRING_2, output); } @Test public void testPracticalEncoding_8(){ - String output = cipher.encode(8, decodedString); + String output = cipher.encode(8, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); + assertEquals(DECODED_STRING, cipher.inputString); assertEquals(8, cipher.base); - assertEquals(encodedString_8, cipher.outputString); - assertEquals(encodedString_8, output); + assertEquals(ENCODED_STRING_8, cipher.outputString); + assertEquals(ENCODED_STRING_8, output); } @Test public void testPracticalEncoding_10(){ - String output = cipher.encode(10, decodedString); + String output = cipher.encode(10, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); + assertEquals(DECODED_STRING, cipher.inputString); assertEquals(10, cipher.base); - assertEquals(encodedString_10, cipher.outputString); - assertEquals(encodedString_10, output); + assertEquals(ENCODED_STRING_10, cipher.outputString); + assertEquals(ENCODED_STRING_10, output); } @Test public void testPracticalEncoding_16(){ - String output = cipher.encode(16, decodedString); + String output = cipher.encode(16, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); + assertEquals(DECODED_STRING, cipher.inputString); assertEquals(16, cipher.base); - assertEquals(encodedString_16, cipher.outputString); - assertEquals(encodedString_16, output); + assertEquals(ENCODED_STRING_16, cipher.outputString); + assertEquals(ENCODED_STRING_16, output); } @Test public void testPracticalEncoding_inputOnly(){ - String output = cipher.encode(decodedString); + String output = cipher.encode(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); + assertEquals(DECODED_STRING, cipher.inputString); assertEquals(2, cipher.base); - assertEquals(encodedString_2, cipher.outputString); - assertEquals(encodedString_2, output); + assertEquals(ENCODED_STRING_2, cipher.outputString); + assertEquals(ENCODED_STRING_2, output); } @Test public void testPracticalDecoding_2(){ - String output = cipher.decode(2, encodedString_2); + String output = cipher.decode(2, ENCODED_STRING_2); - assertEquals(encodedString_2, cipher.inputString); + assertEquals(ENCODED_STRING_2, cipher.inputString); assertEquals(2, cipher.base); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_8(){ - String output = cipher.decode(8, encodedString_8); + String output = cipher.decode(8, ENCODED_STRING_8); - assertEquals(encodedString_8, cipher.inputString); + assertEquals(ENCODED_STRING_8, cipher.inputString); assertEquals(8, cipher.base); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_10(){ - String output = cipher.decode(10, encodedString_10); + String output = cipher.decode(10, ENCODED_STRING_10); - assertEquals(encodedString_10, cipher.inputString); + assertEquals(ENCODED_STRING_10, cipher.inputString); assertEquals(10, cipher.base); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_16(){ - String output = cipher.decode(16, encodedString_16); + String output = cipher.decode(16, ENCODED_STRING_16); - assertEquals(encodedString_16, cipher.inputString); + assertEquals(ENCODED_STRING_16, cipher.inputString); assertEquals(16, cipher.base); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_inputOnly(){ - String output = cipher.decode(encodedString_2); + String output = cipher.decode(ENCODED_STRING_2); - assertEquals(encodedString_2, cipher.inputString); + assertEquals(ENCODED_STRING_2, cipher.inputString); assertEquals(2, cipher.base); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BeaufortTest.java b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BeaufortTest.java index a5851c8..85b4d98 100644 --- a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BeaufortTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BeaufortTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/monosubstitution/BeaufortTest.java -//Mattrixwv -// Created: 02-23-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.monosubstitution; @@ -27,12 +23,12 @@ public class BeaufortTest{ @Mock private Logger logger; //Variables - private static final String decodedString = "Message to^encode"; - private static final String decodedStringClean = "MESSAGETOENCODE"; - private static final String encodedString = "Yageolz rq^ujmdag"; - private static final String encodedStringClean = "YAGEOLZRQUJMDAG"; - private static final String keyword = "Ke*y word"; - private static final String keywordClean = "KEYWORD"; + private static final String DECODED_STRING = "Message to^encode"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String ENCODED_STRING = "Yageolz rq^ujmdag"; + private static final String ENCODED_STRING_CLEAN = "YAGEOLZRQUJMDAG"; + private static final String KEYWORD = "Ke*y word"; + private static final String KEYWORD_CLEAN = "KEYWORD"; @Test @@ -125,14 +121,14 @@ public class BeaufortTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING); } @Test @@ -141,14 +137,14 @@ public class BeaufortTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase()); } @Test @@ -157,14 +153,14 @@ public class BeaufortTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("\\s", "")); } @Test @@ -173,14 +169,14 @@ public class BeaufortTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -217,13 +213,13 @@ public class BeaufortTest{ @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keywordClean, cipher.keyword); - verify(logger, times(1)).debug("Original keyword '{}'", keyword); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + verify(logger, times(1)).debug("Original keyword '{}'", KEYWORD); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Removing all non-letters"); - verify(logger, times(1)).debug("Cleaned keyword '{}'", keywordClean); + verify(logger, times(1)).debug("Cleaned keyword '{}'", KEYWORD_CLEAN); } @Test @@ -268,51 +264,51 @@ public class BeaufortTest{ @Test public void testEncode(){ cipher = new Beaufort(true, true, true); - cipher.keyword = keywordClean; - cipher.inputString = decodedString; + cipher.keyword = KEYWORD_CLEAN; + cipher.inputString = DECODED_STRING; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(1)).debug("Encoding with Atbash"); verify(logger, times(1)).debug("Shifting all letters by 1"); verify(logger, times(1)).debug("Encoding with Vigenere"); - verify(logger, times(1)).debug("Saving output string '{}'", encodedString); + verify(logger, times(1)).debug("Saving output string '{}'", ENCODED_STRING); } @Test public void testDecode(){ cipher = new Beaufort(true, true, true); - cipher.keyword = keywordClean; - cipher.inputString = decodedString; + cipher.keyword = KEYWORD_CLEAN; + cipher.inputString = DECODED_STRING; cipher.decode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(1)).debug("Encoding with Atbash"); verify(logger, times(1)).debug("Shifting all letters by 1"); verify(logger, times(1)).debug("Encoding with Vigenere"); - verify(logger, times(1)).debug("Saving output string '{}'", encodedString); + verify(logger, times(1)).debug("Saving output string '{}'", ENCODED_STRING); } @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); - assertEquals(keyword, cipher.getKeyword()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); + assertEquals(KEYWORD, cipher.getKeyword()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; cipher.reset(); @@ -325,43 +321,43 @@ public class BeaufortTest{ public void testPracticalEncoding(){ cipher = new Beaufort(true, true, true); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new Beaufort(false, false, false); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding(){ cipher = new Beaufort(true, true, true); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_clean(){ cipher = new Beaufort(false, false, false); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/CaesarTest.java b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/CaesarTest.java index 2cfdcf9..1b001d2 100644 --- a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/CaesarTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/CaesarTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/CaesarTest.java -//Matthew Ellison -// Created: 07-25-21 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.monosubstitution; @@ -26,11 +22,11 @@ public class CaesarTest{ @Mock private Logger logger; //Variables - private static final String decodedString = "The quick brown fox jumps over - the lAzy dog"; - private static final String decodedStringClean = "thequickbrownfoxjumpsoverthelazydog"; - private static final String encodedString = "Qeb nrfzh yoltk clu grjmp lsbo - qeb iXwv ald"; - private static final String encodedStringClean = "qebnrfzhyoltkclugrjmplsboqebixwvald"; - private static final int shift = 23; + private static final String DECODED_STRING = "The quick brown fox jumps over - the lAzy dog"; + private static final String DECODED_STRING_CLEAN = "thequickbrownfoxjumpsoverthelazydog"; + private static final String ENCODED_STRING = "Qeb nrfzh yoltk clu grjmp lsbo - qeb iXwv ald"; + private static final String ENCODED_STRING_CLEAN = "qebnrfzhyoltkclugrjmplsboqebixwvald"; + private static final int SHIFT = 23; @Test @@ -83,29 +79,29 @@ public class CaesarTest{ @Test public void testSetShift(){ - cipher.setShift(shift); + cipher.setShift(SHIFT); - assertEquals(shift, cipher.shift); - verify(logger, times(1)).debug("Setting shift {}", shift); - verify(logger, times(1)).debug("Cleaned shift {}", shift); + assertEquals(SHIFT, cipher.shift); + verify(logger, times(1)).debug("Setting shift {}", SHIFT); + verify(logger, times(1)).debug("Cleaned shift {}", SHIFT); } @Test public void testSetShift_large(){ - cipher.setShift(shift + 26); + cipher.setShift(SHIFT + 26); - assertEquals(shift, cipher.shift); - verify(logger, times(1)).debug("Setting shift {}", shift + 26); - verify(logger, times(1)).debug("Cleaned shift {}", shift); + assertEquals(SHIFT, cipher.shift); + verify(logger, times(1)).debug("Setting shift {}", SHIFT + 26); + verify(logger, times(1)).debug("Cleaned shift {}", SHIFT); } @Test public void testSetShift_negative(){ - cipher.setShift(shift - 26); + cipher.setShift(SHIFT - 26); - assertEquals(shift - 26, cipher.shift); - verify(logger, times(1)).debug("Setting shift {}", shift - 26); - verify(logger, times(1)).debug("Cleaned shift {}", shift - 26); + assertEquals(SHIFT, cipher.shift); + verify(logger, times(1)).debug("Setting shift {}", SHIFT - 26); + verify(logger, times(1)).debug("Cleaned shift {}", SHIFT); } @Test @@ -114,14 +110,14 @@ public class CaesarTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING); } @Test @@ -130,14 +126,14 @@ public class CaesarTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.toLowerCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toLowerCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toLowerCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toLowerCase()); } @Test @@ -146,14 +142,14 @@ public class CaesarTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("\\s", "")); } @Test @@ -162,14 +158,14 @@ public class CaesarTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -210,12 +206,12 @@ public class CaesarTest{ @Test public void testEncode(){ - cipher.inputString = decodedString; - cipher.shift = shift; + cipher.inputString = DECODED_STRING; + cipher.shift = SHIFT; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(45)).debug(eq("Working character {}"), anyChar()); verify(logger, times(2)).debug("Encoding uppercase"); @@ -225,17 +221,17 @@ public class CaesarTest{ verify(logger, never()).debug("Wrapping around to z"); verify(logger, times(31)).debug("Wrapping around to a"); verify(logger, times(45)).debug(eq("Encoded character {}"), anyChar()); - verify(logger, times(1)).debug("Saving encoded string '{}'", encodedString); + verify(logger, times(1)).debug("Saving encoded string '{}'", ENCODED_STRING); } @Test public void testEncode_negative(){ - cipher.inputString = decodedString; - cipher.shift = shift - 26; + cipher.inputString = DECODED_STRING; + cipher.shift = SHIFT - 26; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(45)).debug(eq("Working character {}"), anyChar()); verify(logger, times(2)).debug("Encoding uppercase"); @@ -245,17 +241,17 @@ public class CaesarTest{ verify(logger, times(2)).debug("Wrapping around to z"); verify(logger, never()).debug("Wrapping around to a"); verify(logger, times(45)).debug(eq("Encoded character {}"), anyChar()); - verify(logger, times(1)).debug("Saving encoded string '{}'", encodedString); + verify(logger, times(1)).debug("Saving encoded string '{}'", ENCODED_STRING); } @Test public void testDecode(){ - cipher.inputString = encodedString; - cipher.shift = shift; + cipher.inputString = ENCODED_STRING; + cipher.shift = SHIFT; cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(45)).debug(eq("Working character {}"), anyChar()); verify(logger, times(2)).debug("Decoding uppercase"); @@ -265,17 +261,17 @@ public class CaesarTest{ verify(logger, times(31)).debug("Wrapping around to z"); verify(logger, never()).debug("Wrapping around to a"); verify(logger, times(45)).debug(eq("Decoded character {}"), anyChar()); - verify(logger, times(1)).debug("Saving decoded string '{}'", decodedString); + verify(logger, times(1)).debug("Saving decoded string '{}'", DECODED_STRING); } @Test public void testDecode_negative(){ - cipher.inputString = encodedString; - cipher.shift = shift - 26; + cipher.inputString = ENCODED_STRING; + cipher.shift = SHIFT - 26; cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(45)).debug(eq("Working character {}"), anyChar()); verify(logger, times(2)).debug("Decoding uppercase"); @@ -285,25 +281,25 @@ public class CaesarTest{ verify(logger, never()).debug("Wrapping around to z"); verify(logger, times(2)).debug("Wrapping around to a"); verify(logger, times(45)).debug(eq("Decoded character {}"), anyChar()); - verify(logger, times(1)).debug("Saving decoded string '{}'", decodedString); + verify(logger, times(1)).debug("Saving decoded string '{}'", DECODED_STRING); } @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.shift = shift; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.shift = SHIFT; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); - assertEquals(shift, cipher.getShift()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); + assertEquals(SHIFT, cipher.getShift()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.shift = shift; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.shift = SHIFT; cipher.reset(); @@ -317,70 +313,70 @@ public class CaesarTest{ public void testPracticalEncoding(){ cipher = new Caesar(true, true, true); - String output = cipher.encode(shift, decodedString); + String output = cipher.encode(SHIFT, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(shift, cipher.shift); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(SHIFT, cipher.shift); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new Caesar(false, false, false); - String output = cipher.encode(shift, decodedString); + String output = cipher.encode(SHIFT, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(shift, cipher.shift); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(SHIFT, cipher.shift); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalEncoding_negative(){ cipher = new Caesar(true, true, true); - String output = cipher.encode(shift, decodedString); + String output = cipher.encode(-3, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(shift, cipher.shift); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(SHIFT, cipher.shift); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalDecoding(){ cipher = new Caesar(true, true, true); - String output = cipher.decode(shift, encodedString); + String output = cipher.decode(SHIFT, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(shift, cipher.shift); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(SHIFT, cipher.shift); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_clean(){ cipher = new Caesar(false, false, false); - String output = cipher.decode(shift, encodedString); + String output = cipher.decode(SHIFT, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(shift, cipher.shift); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(SHIFT, cipher.shift); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding_negative(){ cipher = new Caesar(true, true, true); - String output = cipher.decode(shift - 26, encodedString); + String output = cipher.decode(SHIFT - 26, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(shift - 26, cipher.shift); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(SHIFT, cipher.shift); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/OneTimePadTest.java b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/OneTimePadTest.java index ac47b45..e7f60d5 100644 --- a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/OneTimePadTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/OneTimePadTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/monosubstitution/OneTimePadTest.java -//Mattrixwv -// Created: 02-23-22 -//Modified: 05-04-23 package com.mattrixwv.cipherstream.monosubstitution; @@ -29,12 +25,12 @@ public class OneTimePadTest{ @Mock(name = "com.mattrixwv.cipherstream.monosubstitution.OneTimePad") private Logger logger; //Variables - private static final String decodedString = "Message to^encode"; - private static final String decodedStringClean = "MESSAGETOENCODE"; - private static final String encodedString = "Wiqooxh mv^egkgws"; - private static final String encodedStringClean = "WIQOOXHMVEGKGWS"; - private static final String keyword = "keywordThatIsTotallyRandom"; - private static final ArrayList offset = new ArrayList<>(Arrays.asList(10, 4, 24, 22, 14, 17, 3, 19, 7, 0, 19, 8, 18, 19, 14, 19, 0, 11, 11, 24, 17, 0, 13, 3, 14, 12)); + private static final String DECODED_STRING = "Message to^encode"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String ENCODED_STRING = "Wiqooxh mv^egkgws"; + private static final String ENCODED_STRING_CLEAN = "WIQOOXHMVEGKGWS"; + private static final String KEYWORD = "keywordThatIsTotallyRandom"; + private static final ArrayList OFFSET = new ArrayList<>(Arrays.asList(10, 4, 24, 22, 14, 17, 3, 19, 7, 0, 19, 8, 18, 19, 14, 19, 0, 11, 11, 24, 17, 0, 13, 3, 14, 12)); @Test @@ -95,13 +91,13 @@ public class OneTimePadTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); - assertEquals(offset, cipher.offset); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); + assertEquals(OFFSET, cipher.offset); verify(logger, times(1)).debug("Encoding"); } @@ -111,13 +107,13 @@ public class OneTimePadTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = false; - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); - assertEquals(offset, cipher.offset); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); + assertEquals(OFFSET, cipher.offset); verify(logger, times(1)).debug("Encoding"); } @@ -128,7 +124,7 @@ public class OneTimePadTest{ cipher.preserveSymbols = true; assertThrows(InvalidKeywordException.class, () -> { - cipher.encode("keyword", decodedString); + cipher.encode("keyword", DECODED_STRING); }); assertEquals("", cipher.inputString); @@ -144,13 +140,13 @@ public class OneTimePadTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); - assertEquals(offset, cipher.offset); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); + assertEquals(OFFSET, cipher.offset); verify(logger, times(1)).debug("Decoding"); } @@ -160,20 +156,20 @@ public class OneTimePadTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = false; - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); - assertEquals(offset, cipher.offset); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); + assertEquals(OFFSET, cipher.offset); verify(logger, times(1)).debug("Decoding"); } @Test public void testDecode_short(){ assertThrows(InvalidKeywordException.class, () -> { - cipher.decode("keyword", encodedString); + cipher.decode("keyword", ENCODED_STRING); }); assertEquals("", cipher.inputString); @@ -187,47 +183,47 @@ public class OneTimePadTest{ public void testPracticalEncoding(){ cipher = new OneTimePad(true, true, true); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new OneTimePad(false, false, false); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding(){ cipher = new OneTimePad(true, true, true); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_clean(){ cipher = new OneTimePad(false, false, false); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/PortaTest.java b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/PortaTest.java index 55badd9..6128b3d 100644 --- a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/PortaTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/PortaTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/monosubstitution/PortaTest.java -//Mattrixwv -// Created: 02-28-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.monosubstitution; @@ -27,12 +23,12 @@ public class PortaTest{ @Mock private Logger logger; //Variables - private static final String decodedString = "Message to^encode"; - private static final String decodedStringClean = "MESSAGETOENCODE"; - private static final String encodedString = "Rtghuos bm^qcwgrw"; - private static final String encodedStringClean = "RTGHUOSBMQCWGRW"; - private static final String keyword = "keyword"; - private static final String keywordDirty = "Ke yw*ord"; + private static final String DECODED_STRING = "Message to^encode"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String ENCODED_STRING = "Rtghuos bm^qcwgrw"; + private static final String ENCODED_STRING_CLEAN = "RTGHUOSBMQCWGRW"; + private static final String KEYWORD = "keyword"; + private static final String KEYWORD_DIRTY = "Ke yw*ord"; @Test @@ -85,24 +81,24 @@ public class PortaTest{ @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keyword.toUpperCase(), cipher.keyword); - verify(logger, times(1)).debug("Original keyword '{}'", keyword); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + verify(logger, times(1)).debug("Original keyword '{}'", KEYWORD); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Removing all non-letters"); - verify(logger, times(1)).debug("Cleaned keyword '{}'", keyword.toUpperCase()); + verify(logger, times(1)).debug("Cleaned keyword '{}'", KEYWORD.toUpperCase()); } @Test public void testSetKeyword_dirty(){ - cipher.setKeyword(keywordDirty); + cipher.setKeyword(KEYWORD_DIRTY); - assertEquals(keyword.toUpperCase(), cipher.keyword); - verify(logger, times(1)).debug("Original keyword '{}'", keywordDirty); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + verify(logger, times(1)).debug("Original keyword '{}'", KEYWORD_DIRTY); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Removing all non-letters"); - verify(logger, times(1)).debug("Cleaned keyword '{}'", keyword.toUpperCase()); + verify(logger, times(1)).debug("Cleaned keyword '{}'", KEYWORD.toUpperCase()); } @Test @@ -148,11 +144,11 @@ public class PortaTest{ public void testSetKeyword_symbols(){ cipher.setKeyword("key*word^"); - assertEquals(keyword.toUpperCase(), cipher.keyword); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); verify(logger, times(1)).debug("Original keyword '{}'", "key*word^"); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Removing all non-letters"); - verify(logger, times(1)).debug("Cleaned keyword '{}'", keyword.toUpperCase()); + verify(logger, times(1)).debug("Cleaned keyword '{}'", KEYWORD.toUpperCase()); } @Test @@ -161,14 +157,14 @@ public class PortaTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - verify(logger, times(1)).debug("Original input string {}", decodedString); + assertEquals(DECODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string {}", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING); } @Test @@ -177,14 +173,14 @@ public class PortaTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string {}", decodedString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string {}", DECODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase()); } @Test @@ -193,14 +189,14 @@ public class PortaTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string {}", decodedString); + assertEquals(DECODED_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string {}", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("\\s", "")); } @Test @@ -209,14 +205,14 @@ public class PortaTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string {}", decodedString); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string {}", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -639,18 +635,18 @@ public class PortaTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keyword.toUpperCase(); - cipher.inputString = decodedString; + cipher.keyword = KEYWORD.toUpperCase(); + cipher.inputString = DECODED_STRING; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(17)).debug(eq("Working character {}"), anyChar()); verify(logger, times(1)).debug("Encoding uppercase"); verify(logger, times(14)).debug("Encoding lowercase"); verify(logger, times(17)).debug(eq("Encoded letter {}"), anyChar()); - verify(logger, times(1)).debug("Saving output string '{}'", encodedString); + verify(logger, times(1)).debug("Saving output string '{}'", ENCODED_STRING); } @Test @@ -658,36 +654,36 @@ public class PortaTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keyword.toUpperCase(); - cipher.inputString = encodedString; + cipher.keyword = KEYWORD.toUpperCase(); + cipher.inputString = ENCODED_STRING; cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(17)).debug(eq("Working character {}"), anyChar()); verify(logger, times(1)).debug("Encoding uppercase"); verify(logger, times(14)).debug("Encoding lowercase"); verify(logger, times(17)).debug(eq("Encoded letter {}"), anyChar()); - verify(logger, times(1)).debug("Saving output string '{}'", decodedString); + verify(logger, times(1)).debug("Saving output string '{}'", DECODED_STRING); } @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); - assertEquals(keyword, cipher.getKeyword()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); + assertEquals(KEYWORD, cipher.getKeyword()); } @Test public void testRest(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; cipher.reset(); @@ -700,47 +696,47 @@ public class PortaTest{ public void testPracticalEncoding(){ cipher = new Porta(true, true, true); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new Porta(false, false, false); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding(){ cipher = new Porta(true, true, true); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_clean(){ cipher = new Porta(false, false, false); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(keyword.toUpperCase(), cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD.toUpperCase(), cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/SubstitutionTest.java b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/SubstitutionTest.java index 4fec132..b64ad80 100644 --- a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/SubstitutionTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/SubstitutionTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/monosubstitution/SubstitutionTest.java -//Mattrixwv -// Created: 02-22-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.monosubstitution; @@ -27,18 +23,18 @@ public class SubstitutionTest{ @Mock private Logger logger; //Variables - private static final String decodedString = "Message to^encode"; - private static final String decodedStringClean = "MESSAGETOENCODE"; - private static final String decodedStringAlNum = "Message to^encode 123"; - private static final String decodedStringAlNumClean = "MESSAGETOENCODE"; - private static final String encodedString = "Oguucig vq^gpeqfg"; - private static final String encodedStringClean = "OGUUCIGVQGPEQFG"; - private static final String encodedStringAlNum = "Oguucig vq^gpeqfg 876"; - private static final String encodedStringAlNumClean = "OGUUCIGVQGPEQFG"; - private static final String keyword = "cdefghijklmnopqrstuvwxyzab"; - private static final String keywordClean = "CDEFGHIJKLMNOPQRSTUVWXYZAB"; - private static final String keywordAlNum = "cdefghijklmnopqrstuvwxyzab9876543210"; - private static final String keywordAlNumClean = "CDEFGHIJKLMNOPQRSTUVWXYZAB9876543210"; + private static final String DECODED_STRING = "Message to^encode"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String DECODED_STRING_AL_NUM = "Message to^encode 123"; + private static final String DECODED_STRING_AL_NUM_CLEAN = "MESSAGETOENCODE"; + private static final String ENCODED_STRING = "Oguucig vq^gpeqfg"; + private static final String ENCODED_STRING_CLEAN = "OGUUCIGVQGPEQFG"; + private static final String ENCODED_STRING_AL_NUM = "Oguucig vq^gpeqfg 876"; + private static final String ENCODED_STRING_AL_NUM_CLEAN = "OGUUCIGVQGPEQFG"; + private static final String KEYWORD = "cdefghijklmnopqrstuvwxyzab"; + private static final String KEYWORD_CLEAN = "CDEFGHIJKLMNOPQRSTUVWXYZAB"; + private static final String KEYWORD_AL_NUM = "cdefghijklmnopqrstuvwxyzab9876543210"; + private static final String KEYWORD_AL_NUM_CLEAN = "CDEFGHIJKLMNOPQRSTUVWXYZAB9876543210"; @Test @@ -91,28 +87,28 @@ public class SubstitutionTest{ @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keywordClean, cipher.keyword); - verify(logger, times(1)).debug("Original key '{}'", keyword); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + verify(logger, times(1)).debug("Original key '{}'", KEYWORD); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Ensuring there are no duplicate mappings"); verify(logger, times(1)).debug("Ensuring there are only letters in the key"); verify(logger, never()).debug("Ensuring there are only alpha-numeric characters in the key"); - verify(logger, times(1)).debug("Cleaned key '{}'", keywordClean); + verify(logger, times(1)).debug("Cleaned key '{}'", KEYWORD_CLEAN); } @Test public void testSetKeyword_alNum(){ - cipher.setKeyword(keywordAlNum); + cipher.setKeyword(KEYWORD_AL_NUM); - assertEquals(keywordAlNumClean, cipher.keyword); - verify(logger, times(1)).debug("Original key '{}'", keywordAlNum); + assertEquals(KEYWORD_AL_NUM_CLEAN, cipher.keyword); + verify(logger, times(1)).debug("Original key '{}'", KEYWORD_AL_NUM); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Ensuring there are no duplicate mappings"); verify(logger, never()).debug("Ensuring there are only letters in the key"); verify(logger, times(1)).debug("Ensuring there are only alpha-numeric characters in the key"); - verify(logger, times(1)).debug("Cleaned key '{}'", keywordAlNumClean); + verify(logger, times(1)).debug("Cleaned key '{}'", KEYWORD_AL_NUM_CLEAN); } @Test @@ -196,14 +192,14 @@ public class SubstitutionTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING); } @Test @@ -212,14 +208,14 @@ public class SubstitutionTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase()); } @Test @@ -228,14 +224,14 @@ public class SubstitutionTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("\\s", "")); } @Test @@ -244,14 +240,14 @@ public class SubstitutionTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -295,19 +291,19 @@ public class SubstitutionTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.inputString = decodedStringAlNum; - cipher.keyword = keywordAlNumClean; + cipher.inputString = DECODED_STRING_AL_NUM; + cipher.keyword = KEYWORD_AL_NUM_CLEAN; cipher.encode(); - assertEquals(encodedStringAlNum, cipher.outputString); + assertEquals(ENCODED_STRING_AL_NUM, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(21)).debug(eq("Working character {}"), anyChar()); verify(logger, times(1)).debug("Encoding uppercase"); verify(logger, times(14)).debug("Encoding lowercase"); verify(logger, times(3)).debug("Encoding digit"); verify(logger, times(3)).debug("Passing symbol through"); - verify(logger, times(1)).debug("Encoded message '{}'", encodedStringAlNum); + verify(logger, times(1)).debug("Encoded message '{}'", ENCODED_STRING_AL_NUM); } @Test @@ -315,37 +311,37 @@ public class SubstitutionTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.inputString = encodedStringAlNum; - cipher.keyword = keywordAlNumClean; + cipher.inputString = ENCODED_STRING_AL_NUM; + cipher.keyword = KEYWORD_AL_NUM_CLEAN; cipher.decode(); - assertEquals(decodedStringAlNum, cipher.outputString); + assertEquals(DECODED_STRING_AL_NUM, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(21)).debug(eq("Working character {}"), anyChar()); verify(logger, times(1)).debug("Encoding uppercase"); verify(logger, times(14)).debug("Encoding lowercase"); verify(logger, times(3)).debug("Encoding digit"); verify(logger, times(3)).debug("Passing symbol through"); - verify(logger, times(1)).debug("Decoded message '{}'", decodedStringAlNum); + verify(logger, times(1)).debug("Decoded message '{}'", DECODED_STRING_AL_NUM); } @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); - assertEquals(keyword, cipher.getKeyword()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); + assertEquals(KEYWORD, cipher.getKeyword()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; cipher.reset(); @@ -359,119 +355,119 @@ public class SubstitutionTest{ public void testPracticalEncoding(){ cipher = new Substitution(true, true, true); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new Substitution(false, false, false); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalEncoding_alNum(){ cipher = new Substitution(true, true, true); - String output = cipher.encode(keywordAlNum, decodedStringAlNum); + String output = cipher.encode(KEYWORD_AL_NUM, DECODED_STRING_AL_NUM); - assertEquals(decodedStringAlNum, cipher.inputString); - assertEquals(keywordAlNumClean, cipher.keyword); - assertEquals(encodedStringAlNum, cipher.outputString); - assertEquals(encodedStringAlNum, output); + assertEquals(DECODED_STRING_AL_NUM, cipher.inputString); + assertEquals(KEYWORD_AL_NUM_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING_AL_NUM, cipher.outputString); + assertEquals(ENCODED_STRING_AL_NUM, output); } @Test public void testPracticalEncoding_alNumClean(){ cipher = new Substitution(false, false, false); - String output = cipher.encode(keywordAlNum, decodedStringAlNum); + String output = cipher.encode(KEYWORD_AL_NUM, DECODED_STRING_AL_NUM); - assertEquals(decodedStringAlNumClean, cipher.inputString); - assertEquals(keywordAlNumClean, cipher.keyword); - assertEquals(encodedStringAlNumClean, cipher.outputString); - assertEquals(encodedStringAlNumClean, output); + assertEquals(DECODED_STRING_AL_NUM_CLEAN, cipher.inputString); + assertEquals(KEYWORD_AL_NUM_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING_AL_NUM_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_AL_NUM_CLEAN, output); } @Test public void testPrecticalEncoding_noAlNumKey(){ cipher = new Substitution(true, true, true); - String output = cipher.encode(keyword, decodedStringAlNum); + String output = cipher.encode(KEYWORD, DECODED_STRING_AL_NUM); - assertEquals(decodedStringAlNum, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedString + " 123", cipher.outputString); - assertEquals(encodedString + " 123", output); + assertEquals(DECODED_STRING_AL_NUM, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING + " 123", cipher.outputString); + assertEquals(ENCODED_STRING + " 123", output); } @Test public void testPracticalDecoding(){ cipher = new Substitution(true, true, true); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_clean(){ cipher = new Substitution(false, false, false); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding_alNum(){ cipher = new Substitution(true, true, true); - String output = cipher.decode(keywordAlNum, encodedStringAlNum); + String output = cipher.decode(KEYWORD_AL_NUM, ENCODED_STRING_AL_NUM); - assertEquals(encodedStringAlNum, cipher.inputString); - assertEquals(keywordAlNumClean, cipher.keyword); - assertEquals(decodedStringAlNum, cipher.outputString); - assertEquals(decodedStringAlNum, output); + assertEquals(ENCODED_STRING_AL_NUM, cipher.inputString); + assertEquals(KEYWORD_AL_NUM_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING_AL_NUM, cipher.outputString); + assertEquals(DECODED_STRING_AL_NUM, output); } @Test public void testPracticalDecoding_alNumClean(){ cipher = new Substitution(false, false, false); - String output = cipher.decode(keywordAlNum, encodedStringAlNum); + String output = cipher.decode(KEYWORD_AL_NUM, ENCODED_STRING_AL_NUM); - assertEquals(encodedStringAlNumClean, cipher.inputString); - assertEquals(keywordAlNumClean, cipher.keyword); - assertEquals(decodedStringAlNumClean, cipher.outputString); - assertEquals(decodedStringAlNumClean, output); + assertEquals(ENCODED_STRING_AL_NUM_CLEAN, cipher.inputString); + assertEquals(KEYWORD_AL_NUM_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING_AL_NUM_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_AL_NUM_CLEAN, output); } @Test public void testPracticalDecoding_noAlNumKey(){ cipher = new Substitution(true, true, true); - String output = cipher.decode(keyword, encodedString + " 123"); + String output = cipher.decode(KEYWORD, ENCODED_STRING + " 123"); - assertEquals(encodedString + " 123", cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedString + " 123", cipher.outputString); - assertEquals(decodedString + " 123", output); + assertEquals(ENCODED_STRING + " 123", cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING + " 123", cipher.outputString); + assertEquals(DECODED_STRING + " 123", output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/VigenereTest.java b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/VigenereTest.java index 3846bf8..62478d0 100644 --- a/src/test/java/com/mattrixwv/cipherstream/monosubstitution/VigenereTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/monosubstitution/VigenereTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/monosubstitution/VigenereTest.java -//Mattrixwv -// Created: 07-25-21 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.monosubstitution; @@ -12,6 +8,7 @@ import static org.mockito.Mockito.*; import java.util.ArrayList; import java.util.List; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; @@ -30,13 +27,19 @@ public class VigenereTest{ @Mock private Logger logger; //Variables - private static final String inputString = "MeSsage to^encode"; - private static final String inputStringClean = "MESSAGETOENCODE"; - private static final String outputString = "WiQooxh ds^cjqfgo"; - private static final String outputStringClean = "WIQOOXHDSCJQFGO"; - private static final String keyword = "ke yw*ord"; - private static final String keywordClean = "KEYWORD"; - private ArrayList offset = new ArrayList<>(List.of(10, 4, 24, 22, 14, 17, 3)); + private static final String INPUT_STRING = "MeSsage to^encode"; + private static final String INPUT_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String OUTPUT_STRING = "WiQooxh ds^cjqfgo"; + private static final String OUTPUT_STRING_CLEAN = "WIQOOXHDSCJQFGO"; + private static final String KEYWORD = "ke yw*ord"; + private static final String KEYWORD_CLEAN = "KEYWORD"; + private ArrayList offset; + + + @BeforeEach + public void setup(){ + offset = new ArrayList<>(List.of(10, 4, 24, 22, 14, 17, 3)); + } @Test @@ -93,11 +96,11 @@ public class VigenereTest{ @Test public void testSetOffset(){ - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.setOffset(); - assertEquals(keywordClean, cipher.keyword); + assertEquals(KEYWORD_CLEAN, cipher.keyword); assertEquals(offset, cipher.offset); verify(logger, times(1)).debug("Setting offset array from keyword"); verify(logger, times(1)).debug("Offset {}", offset); @@ -108,17 +111,17 @@ public class VigenereTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.offset = offset; - cipher.setInputString(inputString); + cipher.setInputString(INPUT_STRING); - assertEquals(inputString, cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", inputString); + assertEquals(INPUT_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", INPUT_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", inputString); + verify(logger, times(1)).debug("Cleaned input string '{}'", INPUT_STRING); } @Test @@ -126,17 +129,17 @@ public class VigenereTest{ cipher.preserveCapitals = false; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.offset = offset; - cipher.setInputString(inputString); + cipher.setInputString(INPUT_STRING); - assertEquals(inputString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", inputString); + assertEquals(INPUT_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", INPUT_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", inputString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", INPUT_STRING.toUpperCase()); } @Test @@ -144,17 +147,17 @@ public class VigenereTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.offset = offset; - cipher.setInputString(inputString); + cipher.setInputString(INPUT_STRING); - assertEquals(inputString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", inputString); + assertEquals(INPUT_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", INPUT_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", inputString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", INPUT_STRING.replaceAll("\\s", "")); } @Test @@ -162,17 +165,17 @@ public class VigenereTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.offset = offset; - cipher.setInputString(inputString); + cipher.setInputString(INPUT_STRING); - assertEquals(inputString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", inputString); + assertEquals(INPUT_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", INPUT_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", inputString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", INPUT_STRING.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -180,7 +183,7 @@ public class VigenereTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.offset = offset; assertThrows(InvalidInputException.class, () -> { @@ -200,7 +203,7 @@ public class VigenereTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.offset = offset; assertThrows(InvalidInputException.class, () -> { @@ -217,14 +220,14 @@ public class VigenereTest{ @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keywordClean, cipher.keyword); + assertEquals(KEYWORD_CLEAN, cipher.keyword); assertEquals(offset, cipher.offset); - verify(logger, times(1)).debug("Original keyword '{}'", keyword); + verify(logger, times(1)).debug("Original keyword '{}'", KEYWORD); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Removing all non-letter characters"); - verify(logger, times(1)).debug("Clean keyword '{}'", keywordClean); + verify(logger, times(1)).debug("Clean keyword '{}'", KEYWORD_CLEAN); } @Test @@ -260,13 +263,13 @@ public class VigenereTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.inputString = inputString; - cipher.keyword = keywordClean; + cipher.inputString = INPUT_STRING; + cipher.keyword = KEYWORD_CLEAN; cipher.offset = offset; cipher.encode(); - assertEquals(outputString, cipher.outputString); + assertEquals(OUTPUT_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(17)).debug(eq("Working character {}"), anyChar()); verify(logger, times(2)).debug("Encoding uppercase"); @@ -274,7 +277,7 @@ public class VigenereTest{ verify(logger, times(13)).debug("Encoding lowercase"); verify(logger, times(5)).debug("Wrapping around to a"); verify(logger, times(17)).debug(eq("Encoded character {}"), anyChar()); - verify(logger, times(1)).debug("Encoded message '{}'", outputString); + verify(logger, times(1)).debug("Encoded message '{}'", OUTPUT_STRING); } @Test @@ -282,13 +285,13 @@ public class VigenereTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.inputString = outputString; - cipher.keyword = keywordClean; + cipher.inputString = OUTPUT_STRING; + cipher.keyword = KEYWORD_CLEAN; cipher.offset = offset; cipher.decode(); - assertEquals(inputString, cipher.outputString); + assertEquals(INPUT_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(17)).debug(eq("Working character {}"), anyChar()); verify(logger, times(2)).debug("Decoding uppercase"); @@ -296,27 +299,27 @@ public class VigenereTest{ verify(logger, times(13)).debug("Decoding lowercase"); verify(logger, times(5)).debug("Wrapping around to z"); verify(logger, times(17)).debug(eq("Decoded character {}"), anyChar()); - verify(logger, times(1)).debug("Decoded message '{}'", inputString); + verify(logger, times(1)).debug("Decoded message '{}'", INPUT_STRING); } @Test public void testGetters(){ - cipher.inputString = inputString; - cipher.outputString = outputString; - cipher.keyword = keyword; + cipher.inputString = INPUT_STRING; + cipher.outputString = OUTPUT_STRING; + cipher.keyword = KEYWORD; cipher.offset = offset; - assertEquals(inputString, cipher.getInputString()); - assertEquals(outputString, cipher.getOutputString()); - assertEquals(keyword, cipher.getKeyword()); + assertEquals(INPUT_STRING, cipher.getInputString()); + assertEquals(OUTPUT_STRING, cipher.getOutputString()); + assertEquals(KEYWORD, cipher.getKeyword()); assertEquals(offset, cipher.getOffsets()); } @Test public void testReset(){ - cipher.inputString = inputString; - cipher.outputString = outputString; - cipher.keyword = keyword; + cipher.inputString = INPUT_STRING; + cipher.outputString = OUTPUT_STRING; + cipher.keyword = KEYWORD; cipher.offset = offset; cipher.reset(); @@ -332,51 +335,51 @@ public class VigenereTest{ public void testPracticalEncoding(){ cipher = new Vigenere(true, true, true); - String output = cipher.encode(keyword, inputString); + String output = cipher.encode(KEYWORD, INPUT_STRING); - assertEquals(inputString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); + assertEquals(INPUT_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); assertEquals(offset, cipher.offset); - assertEquals(outputString, cipher.outputString); - assertEquals(outputString, output); + assertEquals(OUTPUT_STRING, cipher.outputString); + assertEquals(OUTPUT_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new Vigenere(false, false, false); - String output = cipher.encode(keyword, inputString); + String output = cipher.encode(KEYWORD, INPUT_STRING); - assertEquals(inputStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); + assertEquals(INPUT_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); assertEquals(offset, cipher.offset); - assertEquals(outputStringClean, cipher.outputString); - assertEquals(outputStringClean, output); + assertEquals(OUTPUT_STRING_CLEAN, cipher.outputString); + assertEquals(OUTPUT_STRING_CLEAN, output); } @Test public void testPracticalDecoding(){ cipher = new Vigenere(true, true, true); - String output = cipher.decode(keyword, outputString); + String output = cipher.decode(KEYWORD, OUTPUT_STRING); - assertEquals(outputString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); + assertEquals(OUTPUT_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); assertEquals(offset, cipher.offset); - assertEquals(inputString, cipher.outputString); - assertEquals(inputString, output); + assertEquals(INPUT_STRING, cipher.outputString); + assertEquals(INPUT_STRING, output); } @Test public void testPracticalDecoding_clean(){ cipher = new Vigenere(false, false, false); - String output = cipher.decode(keyword, outputString); + String output = cipher.decode(KEYWORD, OUTPUT_STRING); - assertEquals(outputStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); + assertEquals(OUTPUT_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); assertEquals(offset, cipher.offset); - assertEquals(inputStringClean, cipher.outputString); - assertEquals(inputStringClean, output); + assertEquals(INPUT_STRING_CLEAN, cipher.outputString); + assertEquals(INPUT_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/BifidTest.java b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/BifidTest.java index 578b0a9..1060ec9 100644 --- a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/BifidTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/BifidTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/polysubstitution/BifidTest.java -//Mattrixwv -// Created: 03-03-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.polysubstitution; @@ -27,12 +23,12 @@ public class BifidTest{ @Mock private Logger logger; //Test - private static final String inputString = "Message to^encode"; - private static final String inputStringClean = "MESSAGETOENCODE"; - private static final String outputString = "Mqaokne kc^vdodzd"; - private static final String outputStringClean = "MQAOKNEKCVDODZD"; - private static final String keyword = "keyword"; - private static final String keywordClean = "KEYWORDABCFGHILMNPQSTUVXZ"; + private static final String INPUT_STRING = "Message to^encode"; + private static final String INPUT_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String OUTPUT_STRING = "Mqaokne kc^vdodzd"; + private static final String OUTPUT_STRING_CLEAN = "MQAOKNEKCVDODZD"; + private static final String KEYWORD = "keyword"; + private static final String KEYWORD_CLEAN = "KEYWORDABCFGHILMNPQSTUVXZ"; @Test @@ -97,10 +93,10 @@ public class BifidTest{ @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keyword, cipher.keyword); - verify(logger, times(1)).debug("Setting keyword '{}'", keyword); + assertEquals(KEYWORD, cipher.keyword); + verify(logger, times(1)).debug("Setting keyword '{}'", KEYWORD); } @Test @@ -118,14 +114,14 @@ public class BifidTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(inputString); + cipher.setInputString(INPUT_STRING); - assertEquals(inputString, cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", inputString); + assertEquals(INPUT_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", INPUT_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", inputString); + verify(logger, times(1)).debug("Cleaned input string '{}'", INPUT_STRING); } @Test @@ -134,14 +130,14 @@ public class BifidTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(inputString); + cipher.setInputString(INPUT_STRING); - assertEquals(inputString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", inputString); + assertEquals(INPUT_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", INPUT_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", inputString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", INPUT_STRING.toUpperCase()); } @Test @@ -150,14 +146,14 @@ public class BifidTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.setInputString(inputString); + cipher.setInputString(INPUT_STRING); - assertEquals(inputString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", inputString); + assertEquals(INPUT_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", INPUT_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", inputString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", INPUT_STRING.replaceAll("\\s", "")); } @Test @@ -166,14 +162,14 @@ public class BifidTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.setInputString(inputString); + cipher.setInputString(INPUT_STRING); - assertEquals(inputString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", inputString); + assertEquals(INPUT_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", INPUT_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", inputString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", INPUT_STRING.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -214,29 +210,29 @@ public class BifidTest{ @Test public void testFormatOutput(){ - cipher.inputString = inputString; + cipher.inputString = INPUT_STRING; - cipher.formatOutput(outputStringClean); + cipher.formatOutput(OUTPUT_STRING_CLEAN); - assertEquals(outputString, cipher.outputString); + assertEquals(OUTPUT_STRING, cipher.outputString); verify(logger, times(1)).debug("Formatting output"); verify(logger, times(17)).debug(eq("Current character {}"), anyChar()); verify(logger, times(1)).debug("Altering uppercase"); verify(logger, times(14)).debug("Altering lowercase"); verify(logger, times(2)).debug("Adding symbol"); - verify(logger, times(1)).debug("Formatted output string '{}'", outputString); + verify(logger, times(1)).debug("Formatted output string '{}'", OUTPUT_STRING); } @Test public void testEncode(){ - cipher.inputString = inputString; - cipher.keyword = keyword; + cipher.inputString = INPUT_STRING; + cipher.keyword = KEYWORD; cipher.encode(); - assertEquals(inputString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(outputString, cipher.outputString); + assertEquals(INPUT_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(OUTPUT_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(1)).debug("Encoding Polybius"); verify(logger, times(1)).debug("Splitting Polybius Square message"); @@ -246,14 +242,14 @@ public class BifidTest{ @Test public void testDecode(){ - cipher.inputString = outputString; - cipher.keyword = keyword; + cipher.inputString = OUTPUT_STRING; + cipher.keyword = KEYWORD; cipher.decode(); - assertEquals(outputString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(inputString, cipher.outputString); + assertEquals(OUTPUT_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(INPUT_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(1)).debug("Encoding Polybius Square"); verify(logger, times(1)).debug("Splitting Polybius Square message"); @@ -263,20 +259,20 @@ public class BifidTest{ @Test public void testGetters(){ - cipher.inputString = inputString; - cipher.keyword = keyword; - cipher.outputString = outputString; + cipher.inputString = INPUT_STRING; + cipher.keyword = KEYWORD; + cipher.outputString = OUTPUT_STRING; - assertEquals(inputString, cipher.getInputString()); - assertEquals(keyword, cipher.getKeyword()); - assertEquals(outputString, cipher.getOutputString()); + assertEquals(INPUT_STRING, cipher.getInputString()); + assertEquals(KEYWORD, cipher.getKeyword()); + assertEquals(OUTPUT_STRING, cipher.getOutputString()); } @Test public void testReset(){ - cipher.inputString = inputString; - cipher.keyword = keyword; - cipher.outputString = outputString; + cipher.inputString = INPUT_STRING; + cipher.keyword = KEYWORD; + cipher.outputString = OUTPUT_STRING; cipher.reset(); @@ -290,11 +286,11 @@ public class BifidTest{ public void testPracticalEncoding(){ cipher = new Bifid(true, true, true); - String output = cipher.encode(keyword, inputString); + String output = cipher.encode(KEYWORD, INPUT_STRING); - assertEquals(inputString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(outputString, cipher.outputString); + assertEquals(INPUT_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(OUTPUT_STRING, cipher.outputString); assertEquals(output, cipher.outputString); } @@ -302,35 +298,35 @@ public class BifidTest{ public void testPracticalEncoding_clean(){ cipher = new Bifid(false, false, false); - String output = cipher.encode(keyword, inputString); + String output = cipher.encode(KEYWORD, INPUT_STRING); - assertEquals(inputStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(outputStringClean, cipher.outputString); - assertEquals(outputStringClean, output); + assertEquals(INPUT_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(OUTPUT_STRING_CLEAN, cipher.outputString); + assertEquals(OUTPUT_STRING_CLEAN, output); } @Test public void testPracticalDecoding(){ cipher = new Bifid(true, true, true); - String output = cipher.decode(keyword, outputString); + String output = cipher.decode(KEYWORD, OUTPUT_STRING); - assertEquals(outputString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(inputString, cipher.outputString); - assertEquals(inputString, output); + assertEquals(OUTPUT_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(INPUT_STRING, cipher.outputString); + assertEquals(INPUT_STRING, output); } @Test public void testPracticalDecoding_clean(){ cipher = new Bifid(false, false, false); - String output = cipher.decode(keyword, outputString); + String output = cipher.decode(KEYWORD, OUTPUT_STRING); - assertEquals(outputStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(inputStringClean, cipher.outputString); - assertEquals(inputStringClean, output); + assertEquals(OUTPUT_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(INPUT_STRING_CLEAN, cipher.outputString); + assertEquals(INPUT_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/ColumnarTest.java b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/ColumnarTest.java index aadd15c..c869af6 100644 --- a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/ColumnarTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/ColumnarTest.java @@ -1,7 +1,3 @@ -//Mattrixwv/src/test/java/com/mattrixwv/cipherstream/polysubstitution/ColumnarTest.java -//Mattrixwv -// Created: 01-16-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.polysubstitution; @@ -31,16 +27,16 @@ public class ColumnarTest{ @Mock private Logger logger; //Variables - private static final String decodedString = "Message to*encode"; - private static final String decodedStringPadded = "Message to*encodexxxxxx"; - private static final String decodedStringClean = "MESSAGETOENCODEXXXXXX"; - private static final String encodedString = "Edeomte ac*gosnse"; + private static final String DECODED_STRING = "Message to*encode"; + private static final String DECODED_STRING_PADDED = "Message to*encodexxxxxx"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODEXXXXXX"; + private static final String ENCODED_STRING = "Edeomte ac*gosnse"; //TODO: This is a bug that needs fixed - private static final String encodedStringPadingAdded = "Edxeoxmte ac*xgoxsnxsex"; //When padding is added to outputString for decoding - private static final String encodedStringPadded = "Edxeoxm te*acxgoxsnxsex"; //When padding is left in outputString - private static final String encodedStringClean = "EDXEOXMTEACXGOXSNXSEX"; - private static final String keyword = "ke yw*ord"; - private static final String keywordClean = "KEYWORD"; + private static final String ENCODED_STRING_PADDING_ADDED = "Edxeoxmte ac*xgoxsnxsex"; //When padding is added to outputString for decoding + private static final String ENCODED_STRING_PADDED = "Edxeoxm te*acxgoxsnxsex"; //When padding is left in outputString + private static final String ENCODED_STRING_CLEAN = "EDXEOXMTEACXGOXSNXSEX"; + private static final String KEYWORD = "ke yw*ord"; + private static final String KEYWORD_CLEAN = "KEYWORD"; private static final ArrayList> encodeGrid = new ArrayList<>( List.of( new ArrayList<>( @@ -237,17 +233,17 @@ public class ColumnarTest{ @Test public void testGetCleanInputString(){ - cipher.inputString = decodedString; + cipher.inputString = DECODED_STRING; String output = cipher.getCleanInputString(); - assertEquals(decodedString.toUpperCase().replaceAll("[^A-Z]", ""), output); + assertEquals(DECODED_STRING.toUpperCase().replaceAll("[^A-Z]", ""), output); } @Test public void testCreateGridEncode(){ - cipher.inputString = decodedStringPadded; - cipher.keyword = keywordClean; + cipher.inputString = DECODED_STRING_PADDED; + cipher.keyword = KEYWORD_CLEAN; cipher.createGridEncode(); @@ -257,8 +253,8 @@ public class ColumnarTest{ @Test public void testCreateGridDecode(){ - cipher.inputString = encodedStringPadingAdded; - cipher.keyword = keywordClean; + cipher.inputString = ENCODED_STRING_PADDING_ADDED; + cipher.keyword = KEYWORD_CLEAN; cipher.createGridDecode(); @@ -271,19 +267,19 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'x'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringPadded, cipher.inputString); + assertEquals(DECODED_STRING_PADDED, cipher.inputString); verify(logger, times(1)).debug("Setting input string for encoding"); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); verify(logger, times(1)).debug("Appending {} characters", 6); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED); } @Test @@ -291,19 +287,19 @@ public class ColumnarTest{ cipher.preserveCapitals = false; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'X'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringPadded.toUpperCase(), cipher.inputString); + assertEquals(DECODED_STRING_PADDED.toUpperCase(), cipher.inputString); verify(logger, times(1)).debug("Setting input string for encoding"); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); verify(logger, times(1)).debug("Appending {} characters", 6); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED.toUpperCase()); } @Test @@ -311,19 +307,19 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'x'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringPadded.replaceAll("\\s", ""), cipher.inputString); + assertEquals(DECODED_STRING_PADDED.replaceAll("\\s", ""), cipher.inputString); verify(logger, times(1)).debug("Setting input string for encoding"); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); verify(logger, times(1)).debug("Appending {} characters", 6); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED.replaceAll("\\s", "")); } @Test @@ -331,19 +327,19 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'x'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringPadded.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + assertEquals(DECODED_STRING_PADDED.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); verify(logger, times(1)).debug("Setting input string for encoding"); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); verify(logger, times(1)).debug("Appending {} characters", 6); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -351,7 +347,7 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keyword; + cipher.keyword = KEYWORD; cipher.characterToAdd = 'x'; assertThrows(InvalidInputException.class, () -> { @@ -373,7 +369,7 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keyword; + cipher.keyword = KEYWORD; cipher.characterToAdd = 'x'; assertThrows(InvalidInputException.class, () -> { @@ -395,7 +391,7 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keyword; + cipher.keyword = KEYWORD; cipher.characterToAdd = 'x'; assertThrows(InvalidInputException.class, () -> { @@ -417,18 +413,18 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'x'; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedStringPadingAdded, cipher.inputString); + assertEquals(ENCODED_STRING_PADDING_ADDED, cipher.inputString); verify(logger, times(1)).debug("Setting input string for decoding"); - verify(logger, times(1)).debug("Original input string '{}'", encodedString); + verify(logger, times(1)).debug("Original input string '{}'", ENCODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedStringPadingAdded); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING_PADDING_ADDED); } @Test @@ -436,7 +432,7 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'x'; cipher.setInputStringDecode("Message to encod"); @@ -455,18 +451,18 @@ public class ColumnarTest{ cipher.preserveCapitals = false; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'X'; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedStringPadingAdded.toUpperCase(), cipher.inputString); + assertEquals(ENCODED_STRING_PADDING_ADDED.toUpperCase(), cipher.inputString); verify(logger, times(1)).debug("Setting input string for decoding"); - verify(logger, times(1)).debug("Original input string '{}'", encodedString); + verify(logger, times(1)).debug("Original input string '{}'", ENCODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedStringPadingAdded.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING_PADDING_ADDED.toUpperCase()); } @Test @@ -474,18 +470,18 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'x'; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedStringPadingAdded.replaceAll("\\s", ""), cipher.inputString); + assertEquals(ENCODED_STRING_PADDING_ADDED.replaceAll("\\s", ""), cipher.inputString); verify(logger, times(1)).debug("Setting input string for decoding"); - verify(logger, times(1)).debug("Original input string '{}'", encodedString); + verify(logger, times(1)).debug("Original input string '{}'", ENCODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedStringPadingAdded.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING_PADDING_ADDED.replaceAll("\\s", "")); } @Test @@ -493,18 +489,18 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'x'; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedStringPadingAdded.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + assertEquals(ENCODED_STRING_PADDING_ADDED.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); verify(logger, times(1)).debug("Setting input string for decoding"); - verify(logger, times(1)).debug("Original input string '{}'", encodedString); + verify(logger, times(1)).debug("Original input string '{}'", ENCODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedStringPadingAdded.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING_PADDING_ADDED.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -512,7 +508,7 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'x'; assertThrows(InvalidInputException.class, () -> { @@ -533,7 +529,7 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'x'; assertThrows(InvalidInputException.class, () -> { @@ -554,7 +550,7 @@ public class ColumnarTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.characterToAdd = 'x'; assertThrows(InvalidInputException.class, () -> { @@ -573,53 +569,53 @@ public class ColumnarTest{ @Test public void testCreateOutputStringFromColumns(){ cipher.removePadding = true; - cipher.inputString = decodedStringPadded; - cipher.keyword = keywordClean; + cipher.inputString = DECODED_STRING_PADDED; + cipher.keyword = KEYWORD_CLEAN; cipher.grid = decodeGrid; cipher.charsAdded = 6; cipher.characterToAdd = 'x'; cipher.createOutputStringFromColumns(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Creating output string for encoding"); verify(logger, times(1)).debug("Getting added characters"); verify(logger, times(1)).debug("Turning grid into string"); verify(logger, times(1)).debug("Formatting output string"); - verify(logger, times(1)).debug("Output string '{}'", encodedString); + verify(logger, times(1)).debug("Output string '{}'", ENCODED_STRING); } @Test public void testCreateOutputStringFromColumns_padding(){ cipher.removePadding = false; - cipher.inputString = decodedStringPadded; - cipher.keyword = keywordClean; + cipher.inputString = DECODED_STRING_PADDED; + cipher.keyword = KEYWORD_CLEAN; cipher.grid = decodeGrid; cipher.charsAdded = 6; cipher.characterToAdd = 'x'; cipher.createOutputStringFromColumns(); - assertEquals(encodedStringPadded, cipher.outputString); + assertEquals(ENCODED_STRING_PADDED, cipher.outputString); verify(logger, times(1)).debug("Creating output string for encoding"); verify(logger, times(1)).debug("Getting added characters"); verify(logger, times(1)).debug("Turning grid into string"); verify(logger, times(1)).debug("Formatting output string"); - verify(logger, times(1)).debug("Output string '{}'", encodedStringPadded); + verify(logger, times(1)).debug("Output string '{}'", ENCODED_STRING_PADDED); } @Test public void testCreateOutputStringFromRows(){ cipher.removePadding = false; - cipher.inputString = encodedStringPadded; - cipher.keyword = keywordClean; + cipher.inputString = ENCODED_STRING_PADDED; + cipher.keyword = KEYWORD_CLEAN; cipher.grid = encodeGrid; cipher.charsAdded = 6; cipher.characterToAdd = 'x'; cipher.createOutputStringFromRows(); - assertEquals(decodedStringPadded, cipher.outputString); + assertEquals(DECODED_STRING_PADDED, cipher.outputString); verify(logger, times(1)).debug("Creating output string for decoding"); verify(logger, times(1)).debug("Transforming grid to a string"); verify(logger, times(1)).debug("Removing padding"); @@ -628,21 +624,21 @@ public class ColumnarTest{ verify(logger, times(1)).debug("Adding upper case"); verify(logger, times(20)).debug("Adding lower case"); verify(logger, times(2)).debug("Adding symbol"); - verify(logger, times(1)).debug("Decoded output string '{}'", decodedStringPadded); + verify(logger, times(1)).debug("Decoded output string '{}'", DECODED_STRING_PADDED); } @Test public void testCreateOuputStringFromRows_removePadding(){ cipher.removePadding = true; - cipher.inputString = encodedStringPadingAdded; - cipher.keyword = keywordClean; + cipher.inputString = ENCODED_STRING_PADDING_ADDED; + cipher.keyword = KEYWORD_CLEAN; cipher.grid = encodeGrid; cipher.charsAdded = 6; cipher.characterToAdd = 'x'; cipher.createOutputStringFromRows(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Creating output string for decoding"); verify(logger, times(1)).debug("Transforming grid to a string"); verify(logger, times(1)).debug("Removing padding"); @@ -651,16 +647,16 @@ public class ColumnarTest{ verify(logger, times(1)).debug("Adding upper case"); verify(logger, times(14)).debug("Adding lower case"); verify(logger, times(2)).debug("Adding symbol"); - verify(logger, times(1)).debug("Decoded output string '{}'", decodedString); + verify(logger, times(1)).debug("Decoded output string '{}'", DECODED_STRING); } @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keywordClean, cipher.keyword); - verify(logger, times(1)).debug("Original keyword {}", keyword); - verify(logger, times(1)).debug("Cleaned keyword {}", keywordClean); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + verify(logger, times(1)).debug("Original keyword {}", KEYWORD); + verify(logger, times(1)).debug("Cleaned keyword {}", KEYWORD_CLEAN); } @Test @@ -722,7 +718,7 @@ public class ColumnarTest{ public void testGetKeywordAlphaLocations(){ ArrayList alphaLocations = new ArrayList<>(List.of(6, 1, 0, 4, 5, 3, 2)); - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; ArrayList returnedLocations = cipher.getKeywordAlphaLocations(); @@ -735,7 +731,7 @@ public class ColumnarTest{ public void testGetKeywordOriginalLocations(){ ArrayList orderedLocations = new ArrayList<>(List.of(2, 1, 6, 5, 3, 4, 0)); - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; ArrayList returnedLocations = cipher.getKeywordOriginalLocations(); @@ -774,14 +770,14 @@ public class ColumnarTest{ public void testEncode(){ cipher.preserveCapitals = true; cipher.removePadding = true; - cipher.inputString = decodedStringPadded; - cipher.keyword = keywordClean; + cipher.inputString = DECODED_STRING_PADDED; + cipher.keyword = KEYWORD_CLEAN; cipher.charsAdded = 6; cipher.characterToAdd = 'x'; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(1)).debug("Creating grid for encoding"); verify(logger, times(2)).debug("Creating an array of keyword letter locations"); @@ -793,14 +789,14 @@ public class ColumnarTest{ public void testEncode_padding(){ cipher.preserveCapitals = true; cipher.removePadding = false; - cipher.inputString = decodedStringPadded; - cipher.keyword = keywordClean; + cipher.inputString = DECODED_STRING_PADDED; + cipher.keyword = KEYWORD_CLEAN; cipher.charsAdded = 6; cipher.characterToAdd = 'x'; cipher.encode(); - assertEquals(encodedStringPadded, cipher.outputString); + assertEquals(ENCODED_STRING_PADDED, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(1)).debug("Creating grid for encoding"); verify(logger, times(1)).debug("Creating an array of keyword letter locations"); @@ -812,14 +808,14 @@ public class ColumnarTest{ public void testDecode(){ cipher.preserveCapitals = true; cipher.removePadding = true; - cipher.inputString = encodedStringPadingAdded; - cipher.keyword = keywordClean; + cipher.inputString = ENCODED_STRING_PADDING_ADDED; + cipher.keyword = KEYWORD_CLEAN; cipher.charsAdded = 6; cipher.characterToAdd = 'x'; cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(1)).debug("Creating grid for decoding"); verify(logger, times(2)).debug("Creating array of original keyword locations"); @@ -831,14 +827,14 @@ public class ColumnarTest{ public void testDecode_padding(){ cipher.preserveCapitals = true; cipher.removePadding = false; - cipher.inputString = encodedStringPadded; - cipher.keyword = keywordClean; + cipher.inputString = ENCODED_STRING_PADDED; + cipher.keyword = KEYWORD_CLEAN; cipher.charsAdded = 6; cipher.characterToAdd = 'x'; cipher.decode(); - assertEquals(decodedStringPadded, cipher.outputString); + assertEquals(DECODED_STRING_PADDED, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(1)).debug("Creating grid for decoding"); verify(logger, times(1)).debug("Creating array of original keyword locations"); @@ -848,20 +844,20 @@ public class ColumnarTest{ @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.keyword = keyword; - cipher.outputString = encodedString; + cipher.inputString = DECODED_STRING; + cipher.keyword = KEYWORD; + cipher.outputString = ENCODED_STRING; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(keyword, cipher.getKeyword()); - assertEquals(encodedString, cipher.getOutputString()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(KEYWORD, cipher.getKeyword()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.keyword = keyword; - cipher.outputString = encodedString; + cipher.inputString = DECODED_STRING; + cipher.keyword = KEYWORD; + cipher.outputString = ENCODED_STRING; cipher.grid = encodeGrid; cipher.charsAdded = 5; @@ -878,71 +874,71 @@ public class ColumnarTest{ public void testPracticalEncode(){ cipher = new Columnar(true, true, true, true); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringPadded, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING_PADDED, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncode_noPadding(){ cipher = new Columnar(true, true, true, false); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringPadded, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedStringPadded, cipher.outputString); - assertEquals(encodedStringPadded, output); + assertEquals(DECODED_STRING_PADDED, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING_PADDED, cipher.outputString); + assertEquals(ENCODED_STRING_PADDED, output); } @Test public void testPracticalEncode_clean(){ cipher = new Columnar(false, false, false, false); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalDecode(){ cipher = new Columnar(true, true, true, true); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedStringPadingAdded, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING_PADDING_ADDED, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecode_noPadding(){ cipher = new Columnar(true, true, true, false); - String output = cipher.decode(keyword, encodedStringPadded); + String output = cipher.decode(KEYWORD, ENCODED_STRING_PADDED); - assertEquals(encodedStringPadded, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedStringPadded, cipher.outputString); - assertEquals(decodedStringPadded, output); + assertEquals(ENCODED_STRING_PADDED, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING_PADDED, cipher.outputString); + assertEquals(DECODED_STRING_PADDED, output); } @Test public void testPracticalDecode_clean(){ cipher = new Columnar(false, false, false, false); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/HillTest.java b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/HillTest.java index 4aafa5b..25188b6 100644 --- a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/HillTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/HillTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/polysubstitution/HillTest.java -//Mattrixwv -// Created: 01-31-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.polysubstitution; @@ -31,13 +27,13 @@ public class HillTest{ @Mock private Logger logger; //Fields - private static final String decodedString = "Message to^encoded"; - private static final String decodedStringPadded = "Message to^encodedxx"; - private static final String decodedStringClean = "MESSAGETOENCODEDXX"; - private static final String encodedString = "Mgkeqge ul^ikhisplrd"; - private static final String encodedStringClean = "MGKEQGEULIKHISPLRD"; - private static final int[][] keyArray = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}}; - private static final ModMatrix key = new ModMatrix(keyArray, 26); + private static final String DECODED_STRING = "Message to^encoded"; + private static final String DECODED_STRING_PADDED = "Message to^encodedxx"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODEDXX"; + private static final String ENCODED_STRING = "Mgkeqge ul^ikhisplrd"; + private static final String ENCODED_STRING_CLEAN = "MGKEQGEULIKHISPLRD"; + private static final int[][] KEY_ARRAY = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}}; + private static final ModMatrix KEY = new ModMatrix(KEY_ARRAY, 26); @Test @@ -133,19 +129,19 @@ public class HillTest{ @Test public void testSetKey(){ - cipher.setKey(key); + cipher.setKey(KEY); - assertEquals(key, cipher.key); + assertEquals(KEY, cipher.key); verify(logger, times(1)).debug("Setting key"); verify(logger, times(1)).debug("Testing mod"); verify(logger, times(1)).debug("Testing square"); verify(logger, times(1)).debug("Testing invertable"); - verify(logger, times(1)).debug("key\n{}", key); + verify(logger, times(1)).debug("key\n{}", KEY); } @Test public void testSetKey_invalidMod(){ - ModMatrix matrix = new ModMatrix(keyArray, 30); + ModMatrix matrix = new ModMatrix(KEY_ARRAY, 30); assertThrows(InvalidKeyException.class, () -> { cipher.setKey(matrix); @@ -196,20 +192,20 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; cipher.characterToAdd = 'x'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringPadded, cipher.inputString); + assertEquals(DECODED_STRING_PADDED, cipher.inputString); verify(logger, times(1)).debug("Setting input string for encoding"); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); verify(logger, times(1)).debug("Checking length"); verify(logger, times(1)).debug("Adding {} characters", 2); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED); } @Test @@ -217,20 +213,20 @@ public class HillTest{ cipher.preserveCapitals = false; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; cipher.characterToAdd = 'X'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringPadded.toUpperCase(), cipher.inputString); + assertEquals(DECODED_STRING_PADDED.toUpperCase(), cipher.inputString); verify(logger, times(1)).debug("Setting input string for encoding"); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); verify(logger, times(1)).debug("Checking length"); verify(logger, times(1)).debug("Adding {} characters", 2); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED.toUpperCase()); } @Test @@ -238,20 +234,20 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; cipher.characterToAdd = 'x'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringPadded.replaceAll("\\s", ""), cipher.inputString); + assertEquals(DECODED_STRING_PADDED.replaceAll("\\s", ""), cipher.inputString); verify(logger, times(1)).debug("Setting input string for encoding"); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); verify(logger, times(1)).debug("Checking length"); verify(logger, times(1)).debug("Adding {} characters", 2); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED.replaceAll("\\s", "")); } @Test @@ -259,20 +255,20 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.key = key; + cipher.key = KEY; cipher.characterToAdd = 'x'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringPadded.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + assertEquals(DECODED_STRING_PADDED.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); verify(logger, times(1)).debug("Setting input string for encoding"); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); verify(logger, times(1)).debug("Checking length"); verify(logger, times(1)).debug("Adding {} characters", 2); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -280,7 +276,7 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; cipher.characterToAdd = 'x'; assertThrows(InvalidInputException.class, () -> { @@ -303,7 +299,7 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; cipher.characterToAdd = 'x'; assertThrows(InvalidInputException.class, () -> { @@ -326,7 +322,7 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; cipher.characterToAdd = 'x'; assertThrows(InvalidInputException.class, () -> { @@ -349,17 +345,17 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); + assertEquals(ENCODED_STRING, cipher.inputString); verify(logger, times(1)).debug("Setting input string for decoding"); - verify(logger, times(1)).debug("Original input string '{}'", encodedString); + verify(logger, times(1)).debug("Original input string '{}'", ENCODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING); verify(logger, times(1)).debug("Checking length"); } @@ -368,17 +364,17 @@ public class HillTest{ cipher.preserveCapitals = false; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedString.toUpperCase(), cipher.inputString); + assertEquals(ENCODED_STRING.toUpperCase(), cipher.inputString); verify(logger, times(1)).debug("Setting input string for decoding"); - verify(logger, times(1)).debug("Original input string '{}'", encodedString); + verify(logger, times(1)).debug("Original input string '{}'", ENCODED_STRING); verify(logger, times(1)).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING.toUpperCase()); verify(logger, times(1)).debug("Checking length"); } @@ -387,17 +383,17 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedString.replaceAll("\\s", ""), cipher.inputString); + assertEquals(ENCODED_STRING.replaceAll("\\s", ""), cipher.inputString); verify(logger, times(1)).debug("Setting input string for decoding"); - verify(logger, times(1)).debug("Original input string '{}'", encodedString); + verify(logger, times(1)).debug("Original input string '{}'", ENCODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING.replaceAll("\\s", "")); verify(logger, times(1)).debug("Checking length"); } @@ -406,17 +402,17 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.key = key; + cipher.key = KEY; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + assertEquals(ENCODED_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); verify(logger, times(1)).debug("Setting input string for decoding"); - verify(logger, times(1)).debug("Original input string '{}'", encodedString); + verify(logger, times(1)).debug("Original input string '{}'", ENCODED_STRING); verify(logger, never()).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING.replaceAll("[^a-zA-Z\\s]", "")); verify(logger, times(1)).debug("Checking length"); } @@ -425,19 +421,19 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; assertThrows(InvalidInputException.class, () -> { - cipher.setInputStringDecode(encodedString + "a"); + cipher.setInputStringDecode(ENCODED_STRING + "a"); }); - assertEquals(encodedString + "a", cipher.inputString); + assertEquals(ENCODED_STRING + "a", cipher.inputString); verify(logger, times(1)).debug("Setting input string for decoding"); - verify(logger, times(1)).debug("Original input string '{}'", encodedString + "a"); + verify(logger, times(1)).debug("Original input string '{}'", ENCODED_STRING + "a"); verify(logger, never()).debug("Removing capitals"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedString + "a"); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING + "a"); verify(logger, times(1)).debug("Checking length"); } @@ -446,7 +442,7 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; assertThrows(InvalidInputException.class, () -> { cipher.setInputStringDecode(""); @@ -467,7 +463,7 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; assertThrows(InvalidInputException.class, () -> { cipher.setInputStringDecode("*^&"); @@ -488,7 +484,7 @@ public class HillTest{ cipher.preserveCapitals = true; cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.key = key; + cipher.key = KEY; assertThrows(InvalidInputException.class, () -> { cipher.setInputStringDecode(null); @@ -506,13 +502,13 @@ public class HillTest{ @Test public void testGetCleanInputString(){ - cipher.inputString = decodedStringPadded; + cipher.inputString = DECODED_STRING_PADDED; String output = cipher.getCleanInputString(); - assertEquals(decodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, output); verify(logger, times(1)).debug("Cleaning inputString"); - verify(logger, times(1)).debug("Clean input string '{}'", decodedStringClean); + verify(logger, times(1)).debug("Clean input string '{}'", DECODED_STRING_CLEAN); } @Test @@ -555,18 +551,18 @@ public class HillTest{ @Test public void testPolishOutputString(){ - cipher.inputString = decodedStringPadded; - cipher.outputString = encodedStringClean; + cipher.inputString = DECODED_STRING_PADDED; + cipher.outputString = ENCODED_STRING_CLEAN; String output = cipher.polishOutputString(); - assertEquals(encodedString, output); + assertEquals(ENCODED_STRING, output); verify(logger, times(1)).debug("Polishing output string"); verify(logger, times(20)).debug(eq("Current char {}"), anyChar()); verify(logger, times(1)).debug("Uppercase"); verify(logger, times(17)).debug("Lowercase"); verify(logger, times(2)).debug("Symbol"); - verify(logger, times(1)).debug("Polished string '{}'", encodedString); + verify(logger, times(1)).debug("Polished string '{}'", ENCODED_STRING); } @Test @@ -579,8 +575,8 @@ public class HillTest{ expectedVectors.add(new ModMatrix(new int[][]{{14}, { 3}, { 4}}, 26)); expectedVectors.add(new ModMatrix(new int[][]{{ 3}, {23}, {23}}, 26)); - cipher.inputString = decodedStringPadded; - cipher.key = key; + cipher.inputString = DECODED_STRING_PADDED; + cipher.key = KEY; ArrayList returnedVectors = cipher.getInputVectors(); @@ -593,29 +589,29 @@ public class HillTest{ @Test public void testGetOutputFromVectors(){ ArrayList outputVectors = new ArrayList<>(); - outputVectors.add(key.multiply(new ModMatrix(new int[][]{{12}, { 4}, {18}}, 26))); - outputVectors.add(key.multiply(new ModMatrix(new int[][]{{18}, { 0}, { 6}}, 26))); - outputVectors.add(key.multiply(new ModMatrix(new int[][]{{ 4}, {19}, {14}}, 26))); - outputVectors.add(key.multiply(new ModMatrix(new int[][]{{ 4}, {13}, { 2}}, 26))); - outputVectors.add(key.multiply(new ModMatrix(new int[][]{{14}, { 3}, { 4}}, 26))); - outputVectors.add(key.multiply(new ModMatrix(new int[][]{{ 3}, {23}, {23}}, 26))); + outputVectors.add(KEY.multiply(new ModMatrix(new int[][]{{12}, { 4}, {18}}, 26))); + outputVectors.add(KEY.multiply(new ModMatrix(new int[][]{{18}, { 0}, { 6}}, 26))); + outputVectors.add(KEY.multiply(new ModMatrix(new int[][]{{ 4}, {19}, {14}}, 26))); + outputVectors.add(KEY.multiply(new ModMatrix(new int[][]{{ 4}, {13}, { 2}}, 26))); + outputVectors.add(KEY.multiply(new ModMatrix(new int[][]{{14}, { 3}, { 4}}, 26))); + outputVectors.add(KEY.multiply(new ModMatrix(new int[][]{{ 3}, {23}, {23}}, 26))); String returnedString = cipher.getOutputFromVectors(outputVectors); - assertEquals(encodedStringClean, returnedString); + assertEquals(ENCODED_STRING_CLEAN, returnedString); verify(logger, times(1)).debug("Turning vectors into a string"); verify(logger, times(6)).debug(eq("Current vector {}"), any(ModMatrix.class)); - verify(logger, times(1)).debug("Converted string '{}'", encodedStringClean); + verify(logger, times(1)).debug("Converted string '{}'", ENCODED_STRING_CLEAN); } @Test public void testEncode(){ - cipher.inputString = decodedStringPadded; - cipher.key = key; + cipher.inputString = DECODED_STRING_PADDED; + cipher.key = KEY; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(1)).debug("Multiplying vectors"); verify(logger, times(6)).debug(eq("Current input vector {}"), any(ModMatrix.class)); @@ -624,35 +620,35 @@ public class HillTest{ @Test public void testDecode(){ - cipher.inputString = encodedString; - cipher.key = key; + cipher.inputString = ENCODED_STRING; + cipher.key = KEY; cipher.decode(); - assertEquals(decodedStringPadded, cipher.outputString); + assertEquals(DECODED_STRING_PADDED, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(1)).debug("Getting inverse of key"); - verify(logger, times(1)).debug("Inverse of key {}", key.inverse()); + verify(logger, times(1)).debug("Inverse of key {}", KEY.inverse()); verify(logger, times(6)).debug(eq("Current input vector {}"), any(ModMatrix.class)); verify(logger, times(6)).debug(eq("Multiplied vector {}"), any(ModMatrix.class)); } @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.key = key; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.key = KEY; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); - assertEquals(key, cipher.getKey()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); + assertEquals(KEY, cipher.getKey()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.key = key; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.key = KEY; cipher.reset(); @@ -666,46 +662,46 @@ public class HillTest{ public void testPracticalEncode(){ cipher = new Hill(true, true, true); - String output = cipher.encode(key, decodedString); + String output = cipher.encode(KEY, DECODED_STRING); - assertEquals(decodedStringPadded, cipher.inputString); - assertEquals(key, cipher.key); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING_PADDED, cipher.inputString); + assertEquals(KEY, cipher.key); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncode_clean(){ cipher = new Hill(false, false, false); - String output = cipher.encode(key, decodedString); + String output = cipher.encode(KEY, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(key, cipher.key); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEY, cipher.key); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalEncode_array(){ cipher = new Hill(true, true, true); - String output = cipher.encode(keyArray, decodedString); + String output = cipher.encode(KEY_ARRAY, DECODED_STRING); - assertEquals(decodedStringPadded, cipher.inputString); - assertEquals(key, cipher.key); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING_PADDED, cipher.inputString); + assertEquals(KEY, cipher.key); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncode_padding(){ cipher = new Hill(true, true, true, 'j'); - String output = cipher.encode(key, decodedString); + String output = cipher.encode(KEY, DECODED_STRING); - assertEquals(decodedString + "jj", cipher.inputString); - assertEquals(key, cipher.key); + assertEquals(DECODED_STRING + "jj", cipher.inputString); + assertEquals(KEY, cipher.key); assertEquals("Mgkeqge ul^ikhispfzn", cipher.outputString); assertEquals("Mgkeqge ul^ikhispfzn", output); } @@ -714,47 +710,47 @@ public class HillTest{ public void testPracticalDecode(){ cipher = new Hill(true, true, true); - String output = cipher.decode(key, encodedString); + String output = cipher.decode(KEY, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(key, cipher.key); - assertEquals(decodedStringPadded, cipher.outputString); - assertEquals(decodedStringPadded, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEY, cipher.key); + assertEquals(DECODED_STRING_PADDED, cipher.outputString); + assertEquals(DECODED_STRING_PADDED, output); } @Test public void testPracticalDecode_clean(){ cipher = new Hill(false, false, false); - String output = cipher.decode(key, encodedString); + String output = cipher.decode(KEY, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(key, cipher.key); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEY, cipher.key); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } @Test public void testPracticalDecode_array(){ cipher = new Hill(true, true, true); - String output = cipher.decode(keyArray, encodedString); + String output = cipher.decode(KEY_ARRAY, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(key, cipher.key); - assertEquals(decodedStringPadded, cipher.outputString); - assertEquals(decodedStringPadded, output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEY, cipher.key); + assertEquals(DECODED_STRING_PADDED, cipher.outputString); + assertEquals(DECODED_STRING_PADDED, output); } @Test public void testPracticalDecode_padding(){ cipher = new Hill(true, true, true, 'j'); - String output = cipher.decode(key, "Mgkeqge ul^ikhispfzn"); + String output = cipher.decode(KEY, "Mgkeqge ul^ikhispfzn"); assertEquals("Mgkeqge ul^ikhispfzn", cipher.inputString); - assertEquals(key, cipher.key); - assertEquals(decodedString + "jj", cipher.outputString); - assertEquals(decodedString + "jj", output); + assertEquals(KEY, cipher.key); + assertEquals(DECODED_STRING + "jj", cipher.outputString); + assertEquals(DECODED_STRING + "jj", output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/LargePolybiusSquareTest.java b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/LargePolybiusSquareTest.java index 600d900..980caba 100644 --- a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/LargePolybiusSquareTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/LargePolybiusSquareTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/polysubstitution/LargePolybiusSquareTest.java -//Mattrixwv -// Created: 04-21-23 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.polysubstitution; @@ -27,14 +23,14 @@ public class LargePolybiusSquareTest{ @Mock(name = "com.mattrixwv.cipherstream.polysubstitution.LargePolybiusSquare") private Logger logger; //Variables - private static final String decodedString = "Message to^encode"; - private static final String decodedStringClean = "MESSAGETOENCODE"; - private static final String encodedString = "35124343222612 4415^123624152112"; - private static final String encodedStringClean = "31 15 41 41 11 21 15 42 33 15 32 13 33 14 15"; - private static final String keyword = "ke yw*ord"; - private static final String keywordClean = "KEYWORDABCFGHIJLMNPQSTUVXZ0123456789"; - private static final String keywordBlank = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; - private static final char[][] grid = { + private static final String DECODED_STRING = "Message to^encode"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String ENCODED_STRING = "35124343222612 4415^123624152112"; + private static final String ENCODED_STRING_CLEAN = "31 15 41 41 11 21 15 42 33 15 32 13 33 14 15"; + private static final String KEYWORD = "ke yw*ord"; + private static final String KEYWORD_CLEAN = "KEYWORDABCFGHIJLMNPQSTUVXZ0123456789"; + private static final String KEYWORD_BLANK = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; + private static final char[][] GRID = { {'K', 'E', 'Y', 'W', 'O', 'R'}, {'D', 'A', 'B', 'C', 'F', 'G'}, {'H', 'I', 'J', 'L', 'M', 'N'}, @@ -42,7 +38,7 @@ public class LargePolybiusSquareTest{ {'X', 'Z', '0', '1', '2', '3'}, {'4', '5', '6', '7', '8', '9'} }; - private static final char[][] gridClean = { + private static final char[][] GRID_CLEAN = { {'A', 'B', 'C', 'D', 'E', 'F'}, {'G', 'H', 'I', 'J', 'K', 'L'}, {'M', 'N', 'O', 'P', 'Q', 'R'}, @@ -90,11 +86,11 @@ public class LargePolybiusSquareTest{ @Test public void testCreateGrid(){ - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.createGrid(); - assertArrayEquals(grid, cipher.grid); + assertArrayEquals(GRID, cipher.grid); verify(logger, times(1)).debug("Creating grid"); } @@ -103,13 +99,13 @@ public class LargePolybiusSquareTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase()); } @Test @@ -117,13 +113,13 @@ public class LargePolybiusSquareTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedString.toUpperCase().replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase().replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase().replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase().replaceAll("\\s", "")); } @Test @@ -131,13 +127,13 @@ public class LargePolybiusSquareTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedString.toUpperCase().replaceAll("[^a-zA-Z0-9\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase().replaceAll("[^a-zA-Z0-9\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase().replaceAll("[^a-zA-Z0-9\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase().replaceAll("[^a-zA-Z0-9\\s]", "")); } @Test @@ -145,10 +141,10 @@ public class LargePolybiusSquareTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = false; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); assertEquals("M E S S A G E T O E N C O D E", cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); verify(logger, times(1)).debug("Cleaned input string '{}'", "M E S S A G E T O E N C O D E"); @@ -204,34 +200,34 @@ public class LargePolybiusSquareTest{ @Test public void testGetPreparedInputStringEncoding(){ - cipher.inputString = decodedString.toUpperCase(); + cipher.inputString = DECODED_STRING.toUpperCase(); String preparedInputString = cipher.getPreparedInputStringEncode(); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - assertEquals(decodedString.toUpperCase().replaceAll("[^A-Z0-9]", ""), preparedInputString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + assertEquals(DECODED_STRING.toUpperCase().replaceAll("[^A-Z0-9]", ""), preparedInputString); verify(logger, times(1)).debug("Preparing input string for encoding"); verify(logger, times(1)).debug("Prepared input string '{}'", preparedInputString); } @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keywordClean, cipher.keyword); - assertArrayEquals(grid, cipher.grid); - verify(logger, times(1)).debug("Original keyword '{}'", keyword); - verify(logger, times(1)).debug("Cleaned keyword '{}'", keywordClean); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertArrayEquals(GRID, cipher.grid); + verify(logger, times(1)).debug("Original keyword '{}'", KEYWORD); + verify(logger, times(1)).debug("Cleaned keyword '{}'", KEYWORD_CLEAN); } @Test public void testSetKeyword_blank(){ cipher.setKeyword(""); - assertEquals(keywordBlank, cipher.keyword); - assertArrayEquals(gridClean, cipher.grid); + assertEquals(KEYWORD_BLANK, cipher.keyword); + assertArrayEquals(GRID_CLEAN, cipher.grid); verify(logger, times(1)).debug("Original keyword '{}'", ""); - verify(logger, times(1)).debug("Cleaned keyword '{}'", keywordBlank); + verify(logger, times(1)).debug("Cleaned keyword '{}'", KEYWORD_BLANK); } @Test @@ -250,43 +246,43 @@ public class LargePolybiusSquareTest{ public void testAddCharactersToCleanStringEncode(){ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; - cipher.grid = grid; - cipher.inputString = decodedString.toUpperCase(); + cipher.keyword = KEYWORD_CLEAN; + cipher.grid = GRID; + cipher.inputString = DECODED_STRING.toUpperCase(); - cipher.addCharactersToCleanStringEncode(encodedString.replaceAll("\\s", "").replaceAll("[^0-9]", "")); + cipher.addCharactersToCleanStringEncode(ENCODED_STRING.replaceAll("\\s", "").replaceAll("[^0-9]", "")); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Formatting output string"); verify(logger, times(17)).debug(eq("Current character {}"), anyChar()); verify(logger, times(15)).debug("Appending character"); verify(logger, times(2)).debug("Appending symbol"); - verify(logger, times(1)).debug("Saving output string {}", encodedString); + verify(logger, times(1)).debug("Saving output string {}", ENCODED_STRING); } @Test public void testAddCharactersToCleanStringDecode(){ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.keyword = keywordClean; - cipher.grid = grid; - cipher.inputString = encodedString; + cipher.keyword = KEYWORD_CLEAN; + cipher.grid = GRID; + cipher.inputString = ENCODED_STRING; - cipher.addCharactersToCleanStringDecode(decodedStringClean); + cipher.addCharactersToCleanStringDecode(DECODED_STRING_CLEAN); verify(logger, times(1)).debug("Formatting output string"); verify(logger, times(17)).debug(eq("Current character {}"), anyChar()); verify(logger, times(15)).debug("Appending character"); verify(logger, times(2)).debug("Appending symbol"); - verify(logger, times(1)).debug("Saving output string {}", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Saving output string {}", DECODED_STRING.toUpperCase()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; - cipher.grid = grid; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; + cipher.grid = GRID; cipher.reset(); @@ -302,47 +298,47 @@ public class LargePolybiusSquareTest{ public void testPracticalEncoding(){ cipher = new LargePolybiusSquare(true, true); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); } @Test public void testPracticalEncoding_clean(){ cipher = new LargePolybiusSquare(false, false); - String output = cipher.encode(decodedString); + String output = cipher.encode(DECODED_STRING); assertEquals("M E S S A G E T O E N C O D E", cipher.inputString); - assertEquals(keywordBlank, cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); + assertEquals(KEYWORD_BLANK, cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding(){ cipher = new LargePolybiusSquare(true, true); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedString.toUpperCase(), cipher.outputString); - assertEquals(decodedString.toUpperCase(), output); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING.toUpperCase(), cipher.outputString); + assertEquals(DECODED_STRING.toUpperCase(), output); } @Test public void testPracticalDecoding_clean(){ cipher = new LargePolybiusSquare(false, false); - String output = cipher.decode(encodedStringClean); + String output = cipher.decode(ENCODED_STRING_CLEAN); - assertEquals(encodedStringClean.replaceAll("\\s", ""), cipher.inputString); - assertEquals(keywordBlank, cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_CLEAN.replaceAll("\\s", ""), cipher.inputString); + assertEquals(KEYWORD_BLANK, cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } } \ No newline at end of file diff --git a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/MorseTest.java b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/MorseTest.java index 5bee861..96396dd 100644 --- a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/MorseTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/MorseTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/main/java/com/mattrixwv/CipherStreamJava/MoresTest.java -//Matthew Ellison -// Created: 07-28-21 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.polysubstitution; @@ -26,9 +22,9 @@ public class MorseTest{ @Mock private Logger logger; //Fields - private static final String inputString = "Message to^encode123"; - private static final String inputStringClean = "MESSAGETOENCODE123"; - private static final String outputString = "-- . ... ... .- --. . - --- . -. -.-. --- -.. . .---- ..--- ...--"; + private static final String INPUT_STRING = "Message to^encode123"; + private static final String INPUT_STRING_CLEAN = "MESSAGETOENCODE123"; + private static final String OUTPUT_STRING = "-- . ... ... .- --. . - --- . -. -.-. --- -.. . .---- ..--- ...--"; @Test @@ -41,13 +37,13 @@ public class MorseTest{ @Test public void testSetInputStringEncode(){ - cipher.setInputStringEncode(inputString); + cipher.setInputStringEncode(INPUT_STRING); - assertEquals(inputStringClean, cipher.inputString); - verify(logger, times(1)).debug("Setting input string for encoding '{}'", inputString); + assertEquals(INPUT_STRING_CLEAN, cipher.inputString); + verify(logger, times(1)).debug("Setting input string for encoding '{}'", INPUT_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace and symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", inputStringClean); + verify(logger, times(1)).debug("Cleaned input string '{}'", INPUT_STRING_CLEAN); } @Test @@ -93,10 +89,10 @@ public class MorseTest{ @Test public void testSetInputStringDecode(){ - cipher.setInputStringDecode(outputString); + cipher.setInputStringDecode(OUTPUT_STRING); - assertEquals(outputString, cipher.inputString); - verify(logger, times(1)).debug("Setting input string for decoding '{}'", outputString); + assertEquals(OUTPUT_STRING, cipher.inputString); + verify(logger, times(1)).debug("Setting input string for decoding '{}'", OUTPUT_STRING); verify(logger, times(1)).debug("Checking for invalid characters"); verify(logger, times(1)).debug("Saving"); } @@ -141,16 +137,16 @@ public class MorseTest{ @Test public void testEncode(){ - cipher.inputString = inputStringClean; + cipher.inputString = INPUT_STRING_CLEAN; cipher.encode(); - assertEquals(outputString, cipher.outputString); + assertEquals(OUTPUT_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(18)).debug(eq("Working character {}"), anyChar()); verify(logger, times(15)).debug("Appending letter"); verify(logger, times(3)).debug("Appending number"); - verify(logger, times(1)).debug("Saving encoded string '{}'", outputString); + verify(logger, times(1)).debug("Saving encoded string '{}'", OUTPUT_STRING); } @Test @@ -166,20 +162,20 @@ public class MorseTest{ verify(logger, times(1)).debug(eq("Working character {}"), anyChar()); verify(logger, never()).debug("Appending letter"); verify(logger, never()).debug("Appending number"); - verify(logger, never()).debug("Saving encoded string '{}'", outputString); + verify(logger, never()).debug("Saving encoded string '{}'", OUTPUT_STRING); } @Test public void testDecode(){ - cipher.inputString = outputString; + cipher.inputString = OUTPUT_STRING; cipher.decode(); - assertEquals(inputStringClean, cipher.outputString); + assertEquals(INPUT_STRING_CLEAN, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(18)).debug(eq("Working letter {}"), anyString()); verify(logger, times(18)).debug(eq("Decoded letter {}"), anyChar()); - verify(logger, times(1)).debug("Saving decoded string '{}'", inputStringClean); + verify(logger, times(1)).debug("Saving decoded string '{}'", INPUT_STRING_CLEAN); } @Test @@ -199,17 +195,17 @@ public class MorseTest{ @Test public void testGetters(){ - cipher.inputString = inputString; - cipher.outputString = outputString; + cipher.inputString = INPUT_STRING; + cipher.outputString = OUTPUT_STRING; - assertEquals(inputString, cipher.getInputString()); - assertEquals(outputString, cipher.getOutputString()); + assertEquals(INPUT_STRING, cipher.getInputString()); + assertEquals(OUTPUT_STRING, cipher.getOutputString()); } @Test public void testReset(){ - cipher.inputString = inputString; - cipher.outputString = outputString; + cipher.inputString = INPUT_STRING; + cipher.outputString = OUTPUT_STRING; cipher.reset(); @@ -220,19 +216,19 @@ public class MorseTest{ @Test public void testPracticalEncode(){ - String output = cipher.encode(inputString); + String output = cipher.encode(INPUT_STRING); - assertEquals(inputStringClean, cipher.inputString); - assertEquals(outputString, cipher.outputString); - assertEquals(outputString, output); + assertEquals(INPUT_STRING_CLEAN, cipher.inputString); + assertEquals(OUTPUT_STRING, cipher.outputString); + assertEquals(OUTPUT_STRING, output); } @Test public void testPracticalDecode(){ - String output = cipher.decode(outputString); + String output = cipher.decode(OUTPUT_STRING); - assertEquals(outputString, cipher.inputString); - assertEquals(inputStringClean, cipher.outputString); - assertEquals(inputStringClean, output); + assertEquals(OUTPUT_STRING, cipher.inputString); + assertEquals(INPUT_STRING_CLEAN, cipher.outputString); + assertEquals(INPUT_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/PlayfairTest.java b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/PlayfairTest.java index 5ddefac..599d188 100644 --- a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/PlayfairTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/PlayfairTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/main/java/com/mattrixwv/CipherStreamJava/PlayfairTest.java -//Matthew Ellison -// Created: 07-30-21 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.polysubstitution; @@ -29,14 +25,14 @@ public class PlayfairTest{ @Mock private Logger logger; //Fields - private static final String decodedString = "Hide the gold in - the@tree+stump"; - private static final String decodedStringPadded = "Hide the gold in - the@trexe+stump"; - private static final String decodedStringClean = "HIDETHEGOLDINTHETREXESTUMP"; - private static final String encodedString = "Bmod zbx dnab ek - udm@uixmm+ouvif"; - private static final String encodedStringClean = "BMODZBXDNABEKUDMUIXMMOUVIF"; - private static final String keyword = "Play-fair@Exam ple"; - private static final String keywordClean = "PLAYFIREXMBCDGHKNOQSTUVWZ"; - private static final char[][] grid = new char[][]{ + private static final String DECODED_STRING = "Hide the gold in - the@tree+stump"; + private static final String DECODED_STRING_PADDED = "Hide the gold in - the@trexe+stump"; + private static final String DECODED_STRING_CLEAN = "HIDETHEGOLDINTHETREXESTUMP"; + private static final String ENCODED_STRING = "Bmod zbx dnab ek - udm@uixmm+ouvif"; + private static final String ENCODED_STRING_CLEAN = "BMODZBXDNABEKUDMUIXMMOUVIF"; + private static final String KEYWORD = "Play-fair@Exam ple"; + private static final String KEYWORD_CLEAN = "PLAYFIREXMBCDGHKNOQSTUVWZ"; + private static final char[][] GRID = new char[][]{ {'P', 'L', 'A', 'Y', 'F'}, {'I', 'R', 'E', 'X', 'M'}, {'B', 'C', 'D', 'G', 'H'}, @@ -394,11 +390,11 @@ public class PlayfairTest{ @Test public void testCreateGrid(){ String expectedGridString = "[P L A Y F]\n[I R E X M]\n[B C D G H]\n[K N O Q S]\n[T U V W Z]"; - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.createGrid(); - assertArrayEquals(grid, cipher.grid); + assertArrayEquals(GRID, cipher.grid); verify(logger, times(1)).debug("Creating grid from keyword"); verify(logger, times(25)).debug(eq("Letter {} going to position [{}] [{}]"), anyChar(), anyInt(), anyInt()); verify(logger, times(1)).debug("Grid\n{}", expectedGridString); @@ -411,11 +407,11 @@ public class PlayfairTest{ cipher.preserveSymbols = true; cipher.doubled = 'x'; - cipher.setInputString(decodedString, true); + cipher.setInputString(DECODED_STRING, true); - assertEquals(decodedStringPadded, cipher.inputString); + assertEquals(DECODED_STRING_PADDED, cipher.inputString); verify(logger, times(1)).debug("Setting input string"); - verify(logger, times(1)).debug("Original input string {}", decodedString); + verify(logger, times(1)).debug("Original input string {}", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); @@ -428,11 +424,11 @@ public class PlayfairTest{ cipher.preserveSymbols = true; cipher.doubled = 'X'; - cipher.setInputString(decodedString, true); + cipher.setInputString(DECODED_STRING, true); - assertEquals(decodedStringPadded.toUpperCase(), cipher.inputString); + assertEquals(DECODED_STRING_PADDED.toUpperCase(), cipher.inputString); verify(logger, times(1)).debug("Setting input string"); - verify(logger, times(1)).debug("Original input string {}", decodedString); + verify(logger, times(1)).debug("Original input string {}", DECODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); @@ -445,11 +441,11 @@ public class PlayfairTest{ cipher.preserveSymbols = true; cipher.doubled = 'x'; - cipher.setInputString(decodedString, true); + cipher.setInputString(DECODED_STRING, true); - assertEquals(decodedStringPadded.replaceAll("\\s", ""), cipher.inputString); + assertEquals(DECODED_STRING_PADDED.replaceAll("\\s", ""), cipher.inputString); verify(logger, times(1)).debug("Setting input string"); - verify(logger, times(1)).debug("Original input string {}", decodedString); + verify(logger, times(1)).debug("Original input string {}", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); @@ -462,11 +458,11 @@ public class PlayfairTest{ cipher.preserveSymbols = false; cipher.doubled = 'x'; - cipher.setInputString(decodedString, true); + cipher.setInputString(DECODED_STRING, true); - assertEquals(decodedStringPadded.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + assertEquals(DECODED_STRING_PADDED.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); verify(logger, times(1)).debug("Setting input string"); - verify(logger, times(1)).debug("Original input string {}", decodedString); + verify(logger, times(1)).debug("Original input string {}", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); @@ -498,15 +494,15 @@ public class PlayfairTest{ cipher.preserveSymbols = true; cipher.doubled = 'x'; - cipher.setInputString(encodedString, false); + cipher.setInputString(ENCODED_STRING, false); - assertEquals(encodedString, cipher.inputString); + assertEquals(ENCODED_STRING, cipher.inputString); verify(logger, times(1)).debug("Setting input string"); - verify(logger, times(1)).debug("Original input string {}", encodedString); + verify(logger, times(1)).debug("Original input string {}", ENCODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Clean input string '{}'", encodedString); + verify(logger, times(1)).debug("Clean input string '{}'", ENCODED_STRING); } @Test @@ -517,16 +513,16 @@ public class PlayfairTest{ cipher.doubled = 'x'; assertThrows(InvalidCharacterException.class, () -> { - cipher.setInputString(encodedString + cipher.replaced, false); + cipher.setInputString(ENCODED_STRING + cipher.replaced, false); }); assertEquals("", cipher.inputString); verify(logger, times(1)).debug("Setting input string"); - verify(logger, times(1)).debug("Original input string {}", encodedString + Character.toString(cipher.replaced)); + verify(logger, times(1)).debug("Original input string {}", ENCODED_STRING + Character.toString(cipher.replaced)); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, never()).debug("Clean input string '{}'", encodedString); + verify(logger, never()).debug("Clean input string '{}'", ENCODED_STRING); } @Test @@ -537,16 +533,16 @@ public class PlayfairTest{ cipher.doubled = 'x'; assertThrows(InvalidInputException.class, () -> { - cipher.setInputString(encodedString + "a", false); + cipher.setInputString(ENCODED_STRING + "a", false); }); - assertEquals(encodedString + "a", cipher.inputString); + assertEquals(ENCODED_STRING + "a", cipher.inputString); verify(logger, times(1)).debug("Setting input string"); - verify(logger, times(1)).debug("Original input string {}", encodedString + "a"); + verify(logger, times(1)).debug("Original input string {}", ENCODED_STRING + "a"); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Clean input string '{}'", encodedString + "a"); + verify(logger, times(1)).debug("Clean input string '{}'", ENCODED_STRING + "a"); } @Test @@ -593,48 +589,48 @@ public class PlayfairTest{ public void testSetInputStringEncode(){ cipher.doubled = 'x'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringPadded, cipher.inputString); + assertEquals(DECODED_STRING_PADDED, cipher.inputString); verify(logger, times(1)).debug("Cleaning up input string for encoding"); verify(logger, times(1)).debug("Replacing all {} with {}", cipher.replaced, cipher.replacer); verify(logger, times(13)).debug(eq("Starting at character {}"), anyInt()); verify(logger, times(13)).debug(eq("Adding to clean input: {} {} {} {}"), any(StringBuilder.class), anyChar(), any(StringBuilder.class), anyChar()); verify(logger, times(1)).debug("Checking odd characters"); verify(logger, never()).debug("Adding final character to make even"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED); } @Test public void testSetInputStringEncode_odd(){ cipher.doubled = 'x'; - cipher.setInputStringEncode(decodedStringPadded + 'a'); + cipher.setInputStringEncode(DECODED_STRING_PADDED + 'a'); - assertEquals(decodedStringPadded + "ax", cipher.inputString); + assertEquals(DECODED_STRING_PADDED + "ax", cipher.inputString); verify(logger, times(1)).debug("Cleaning up input string for encoding"); verify(logger, times(1)).debug("Replacing all {} with {}", cipher.replaced, cipher.replacer); verify(logger, times(14)).debug(eq("Starting at character {}"), anyInt()); verify(logger, times(14)).debug(eq("Adding to clean input: {} {} {} {}"), any(StringBuilder.class), anyChar(), any(StringBuilder.class), anyChar()); verify(logger, times(1)).debug("Checking odd characters"); verify(logger, times(1)).debug("Adding final character to make even"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded + "ax"); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED + "ax"); } @Test public void testSetInputString_oddEndSymbol(){ cipher.doubled = 'x'; - cipher.setInputStringEncode(decodedStringPadded + "a*"); + cipher.setInputStringEncode(DECODED_STRING_PADDED + "a*"); - assertEquals(decodedStringPadded + "a*x", cipher.inputString); + assertEquals(DECODED_STRING_PADDED + "a*x", cipher.inputString); verify(logger, times(1)).debug("Cleaning up input string for encoding"); verify(logger, times(1)).debug("Replacing all {} with {}", cipher.replaced, cipher.replacer); verify(logger, times(14)).debug(eq("Starting at character {}"), anyInt()); verify(logger, times(14)).debug(eq("Adding to clean input: {} {} {} {}"), any(StringBuilder.class), anyChar(), any(StringBuilder.class), anyChar()); verify(logger, times(1)).debug("Checking odd characters"); verify(logger, times(1)).debug("Adding final character to make even"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded + "a*x"); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED + "a*x"); } @Test @@ -642,41 +638,41 @@ public class PlayfairTest{ cipher.doubled = 'x'; cipher.replacer = 'i'; - cipher.setInputStringEncode(decodedStringPadded + 'x'); + cipher.setInputStringEncode(DECODED_STRING_PADDED + 'x'); - assertEquals(decodedStringPadded + "xi", cipher.inputString); + assertEquals(DECODED_STRING_PADDED + "xi", cipher.inputString); verify(logger, times(1)).debug("Cleaning up input string for encoding"); verify(logger, times(1)).debug("Replacing all {} with {}", cipher.replaced, cipher.replacer); verify(logger, times(14)).debug(eq("Starting at character {}"), anyInt()); verify(logger, times(14)).debug(eq("Adding to clean input: {} {} {} {}"), any(StringBuilder.class), anyChar(), any(StringBuilder.class), anyChar()); verify(logger, times(1)).debug("Checking odd characters"); verify(logger, times(1)).debug("Adding final character to make even"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringPadded + "xi"); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_PADDED + "xi"); } @Test public void testGetPreparedInputString(){ - cipher.inputString = decodedStringPadded; + cipher.inputString = DECODED_STRING_PADDED; String output = cipher.getPreparedInputString(); - assertEquals(decodedStringClean, output); + assertEquals(DECODED_STRING_CLEAN, output); verify(logger, times(1)).debug("Getting input string ready for encoding"); - verify(logger, times(1)).debug("Prepared string '{}'", decodedStringClean); + verify(logger, times(1)).debug("Prepared string '{}'", DECODED_STRING_CLEAN); } @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keywordClean, cipher.keyword); + assertEquals(KEYWORD_CLEAN, cipher.keyword); verify(logger, times(1)).debug("Setting keyword"); - verify(logger, times(1)).debug("Original keyword {}", keyword); + verify(logger, times(1)).debug("Original keyword {}", KEYWORD); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Removing all non-letter characters"); verify(logger, times(1)).debug("Appending the alphabet to the keyword"); verify(logger, times(1)).debug("Replacing {} with {}", cipher.replaced, cipher.replacer); verify(logger, times(1)).debug("Removing duplicate characters"); - verify(logger, times(1)).debug("Cleaned keyword {}", keywordClean); + verify(logger, times(1)).debug("Cleaned keyword {}", KEYWORD_CLEAN); } @Test @@ -698,7 +694,7 @@ public class PlayfairTest{ @Test public void testFindChar(){ - cipher.grid = grid; + cipher.grid = GRID; CharLocation returnedLocation = cipher.findChar('E'); @@ -710,7 +706,7 @@ public class PlayfairTest{ @Test public void testFindChar_invalid(){ - cipher.grid = grid; + cipher.grid = GRID; assertThrows(InvalidInputException.class, () -> { cipher.findChar('J'); @@ -722,61 +718,61 @@ public class PlayfairTest{ @Test public void testGetGridChar(){ - cipher.grid = grid; + cipher.grid = GRID; char output = cipher.getGridChar(1, 1); - assertEquals(grid[1][1], output); + assertEquals(GRID[1][1], output); verify(logger, times(1)).debug("Getting character from grid[{}][{}]", 1, 1); - verify(logger, times(1)).debug("Character {}", grid[1][1]); + verify(logger, times(1)).debug("Character {}", GRID[1][1]); } @Test public void testGetGridChar_large(){ - cipher.grid = grid; + cipher.grid = GRID; char output = cipher.getGridChar(-4, -4); - assertEquals(grid[1][1], output); + assertEquals(GRID[1][1], output); verify(logger, times(1)).debug("Getting character from grid[{}][{}]", -4, -4); - verify(logger, times(1)).debug("Character {}", grid[1][1]); + verify(logger, times(1)).debug("Character {}", GRID[1][1]); } @Test public void testGetGridChar_negative(){ - cipher.grid = grid; + cipher.grid = GRID; char output = cipher.getGridChar(6, 6); - assertEquals(grid[1][1], output); + assertEquals(GRID[1][1], output); verify(logger, times(1)).debug("Getting character from grid[{}][{}]", 6, 6); - verify(logger, times(1)).debug("Character {}", grid[1][1]); + verify(logger, times(1)).debug("Character {}", GRID[1][1]); } @Test public void testAddCharactersToCleanString(){ - cipher.inputString = decodedStringPadded; + cipher.inputString = DECODED_STRING_PADDED; - cipher.addCharactersToCleanString(encodedStringClean); + cipher.addCharactersToCleanString(ENCODED_STRING_CLEAN); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Formatting output string"); verify(logger, times(34)).debug(eq("Working character {}"), anyChar()); verify(logger, times(1)).debug("Appending uppercase"); verify(logger, times(25)).debug("Appending lowercase"); verify(logger, times(8)).debug("Appending symbol"); - verify(logger, times(1)).debug("Formatted output '{}'", encodedString); + verify(logger, times(1)).debug("Formatted output '{}'", ENCODED_STRING); } @Test public void testEncode(){ - cipher.inputString = decodedStringPadded; - cipher.keyword = keywordClean; - cipher.grid = grid; + cipher.inputString = DECODED_STRING_PADDED; + cipher.keyword = KEYWORD_CLEAN; + cipher.grid = GRID; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(13)).debug(eq("Letters {} {}"), anyChar(), anyChar()); verify(logger, times(2)).debug("Row encoding"); @@ -787,13 +783,13 @@ public class PlayfairTest{ @Test public void testDecode(){ - cipher.inputString = encodedString; - cipher.keyword = keywordClean; - cipher.grid = grid; + cipher.inputString = ENCODED_STRING; + cipher.keyword = KEYWORD_CLEAN; + cipher.grid = GRID; cipher.decode(); - assertEquals(decodedStringPadded, cipher.outputString); + assertEquals(DECODED_STRING_PADDED, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(13)).debug(eq("Letters {} {}"), anyChar(), anyChar()); verify(logger, times(2)).debug("Row decoding"); @@ -804,10 +800,10 @@ public class PlayfairTest{ @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; - cipher.grid = grid; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; + cipher.grid = GRID; cipher.reset(); @@ -820,14 +816,14 @@ public class PlayfairTest{ @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; - cipher.grid = grid; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; + cipher.grid = GRID; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); - assertEquals(keyword, cipher.getKeyword()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); + assertEquals(KEYWORD, cipher.getKeyword()); assertEquals("[P L A Y F]\n[I R E X M]\n[B C D G H]\n[K N O Q S]\n[T U V W Z]", cipher.getGrid()); assertEquals('J', cipher.getReplaced()); assertEquals('I', cipher.getReplacer()); @@ -839,51 +835,51 @@ public class PlayfairTest{ public void testPracticalEncode(){ cipher = new Playfair(true, true, true); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringPadded, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(DECODED_STRING_PADDED, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalEncode_clean(){ cipher = new Playfair(false, false, false); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalDecode(){ cipher = new Playfair(true, true, true); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedStringPadded, cipher.outputString); - assertEquals(decodedStringPadded, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING_PADDED, cipher.outputString); + assertEquals(DECODED_STRING_PADDED, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalDecode_clean(){ cipher = new Playfair(false, false, false); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); + assertArrayEquals(GRID, cipher.grid); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/PolybiusSquareTest.java b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/PolybiusSquareTest.java index f25c7e8..ff8139c 100644 --- a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/PolybiusSquareTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/PolybiusSquareTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/PolybiusSquareTest.java -//Mattrixwv -// Created: 01-04-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.polysubstitution; @@ -29,20 +25,20 @@ public class PolybiusSquareTest{ @Mock private Logger logger; //Fields - private static final String decodedString = "Message to^encode"; - private static final String decodedStringClean = "M E S S A G E T O E N C O D E"; - private static final String encodedString = "41124545233212 5115^124225152212"; - private static final String encodedStringClean = "41 12 45 45 23 32 12 51 15 12 42 25 15 22 12"; - private static final String keyword = "ke yw*ord"; - private static final String keywordClean = "KEYWORDABCFGHILMNPQSTUVXZ"; - private static final char[][] grid = new char[][]{ + private static final String DECODED_STRING = "Message to^encode"; + private static final String DECODED_STRING_CLEAN = "M E S S A G E T O E N C O D E"; + private static final String ENCODED_STRING = "41124545233212 5115^124225152212"; + private static final String ENCODED_STRING_CLEAN = "41 12 45 45 23 32 12 51 15 12 42 25 15 22 12"; + private static final String KEYWORD = "ke yw*ord"; + private static final String KEYWORD_CLEAN = "KEYWORDABCFGHILMNPQSTUVXZ"; + private static final char[][] GRID = new char[][]{ {'K', 'E', 'Y', 'W', 'O'}, {'R', 'D', 'A', 'B', 'C'}, {'F', 'G', 'H', 'I', 'L'}, {'M', 'N', 'P', 'Q', 'S'}, {'T', 'U', 'V', 'X', 'Z'} }; - private static final String gridString = "[K E Y W O]\n[R D A B C]\n[F G H I L]\n[M N P Q S]\n[T U V X Z]"; + private static final String GRID_STRING = "[K E Y W O]\n[R D A B C]\n[F G H I L]\n[M N P Q S]\n[T U V X Z]"; @Test @@ -191,13 +187,13 @@ public class PolybiusSquareTest{ @Test public void testCreateGrid(){ - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.createGrid(); - assertArrayEquals(grid, cipher.grid); + assertArrayEquals(GRID, cipher.grid); verify(logger, times(1)).debug("Creating grid from keyword"); - verify(logger, times(1)).debug("Created grid\n{}", gridString); + verify(logger, times(1)).debug("Created grid\n{}", GRID_STRING); } @Test @@ -207,16 +203,16 @@ public class PolybiusSquareTest{ cipher.replaced = 'J'; cipher.replacer = 'I'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Setting input string for encoding '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Setting input string for encoding '{}'", DECODED_STRING); verify(logger, times(1)).debug("Checking for digits"); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); verify(logger, times(1)).debug("Replacing {} with {}", cipher.replaced, cipher.replacer); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase()); } @Test @@ -226,16 +222,16 @@ public class PolybiusSquareTest{ cipher.replaced = 'J'; cipher.replacer = 'I'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedString.toUpperCase().replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Setting input string for encoding '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase().replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Setting input string for encoding '{}'", DECODED_STRING); verify(logger, times(1)).debug("Checking for digits"); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); verify(logger, times(1)).debug("Replacing {} with {}", cipher.replaced, cipher.replacer); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase().replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase().replaceAll("\\s", "")); } @Test @@ -245,16 +241,16 @@ public class PolybiusSquareTest{ cipher.replaced = 'J'; cipher.replacer = 'I'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedString.toUpperCase().replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Setting input string for encoding '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase().replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Setting input string for encoding '{}'", DECODED_STRING); verify(logger, times(1)).debug("Checking for digits"); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); verify(logger, times(1)).debug("Replacing {} with {}", cipher.replaced, cipher.replacer); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase().replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase().replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -264,16 +260,16 @@ public class PolybiusSquareTest{ cipher.replaced = 'J'; cipher.replacer = 'I'; - cipher.setInputStringEncode(decodedString); + cipher.setInputStringEncode(DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - verify(logger, times(1)).debug("Setting input string for encoding '{}'", decodedString); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + verify(logger, times(1)).debug("Setting input string for encoding '{}'", DECODED_STRING); verify(logger, times(1)).debug("Checking for digits"); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); verify(logger, times(1)).debug("Replacing {} with {}", cipher.replaced, cipher.replacer); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedStringClean); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING_CLEAN); } @Test @@ -365,14 +361,14 @@ public class PolybiusSquareTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - verify(logger, times(1)).debug("Setting input string for decoding '{}'", encodedString); + assertEquals(ENCODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Setting input string for decoding '{}'", ENCODED_STRING); verify(logger, times(1)).debug("Checking for letters"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING); } @Test @@ -380,14 +376,14 @@ public class PolybiusSquareTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Setting input string for decoding '{}'", encodedString); + assertEquals(ENCODED_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Setting input string for decoding '{}'", ENCODED_STRING); verify(logger, times(1)).debug("Checking for letters"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING.replaceAll("\\s", "")); } @Test @@ -395,14 +391,14 @@ public class PolybiusSquareTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.setInputStringDecode(encodedString); + cipher.setInputStringDecode(ENCODED_STRING); - assertEquals(encodedString.replaceAll("[^0-9\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Setting input string for decoding '{}'", encodedString); + assertEquals(ENCODED_STRING.replaceAll("[^0-9\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Setting input string for decoding '{}'", ENCODED_STRING); verify(logger, times(1)).debug("Checking for letters"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", encodedString.replaceAll("[^0-9\\s]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", ENCODED_STRING.replaceAll("[^0-9\\s]", "")); } @Test @@ -411,11 +407,11 @@ public class PolybiusSquareTest{ cipher.preserveSymbols = true; assertThrows(InvalidInputException.class, () -> { - cipher.setInputStringDecode(encodedString + "a"); + cipher.setInputStringDecode(ENCODED_STRING + "a"); }); assertEquals("", cipher.inputString); - verify(logger, times(1)).debug("Setting input string for decoding '{}'", encodedString + "a"); + verify(logger, times(1)).debug("Setting input string for decoding '{}'", ENCODED_STRING + "a"); verify(logger, times(1)).debug("Checking for letters"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); @@ -428,11 +424,11 @@ public class PolybiusSquareTest{ cipher.preserveSymbols = true; assertThrows(InvalidInputException.class, () -> { - cipher.setInputStringDecode(encodedString + "0"); + cipher.setInputStringDecode(ENCODED_STRING + "0"); }); assertEquals("", cipher.inputString); - verify(logger, times(1)).debug("Setting input string for decoding '{}'", encodedString + "0"); + verify(logger, times(1)).debug("Setting input string for decoding '{}'", ENCODED_STRING + "0"); verify(logger, times(1)).debug("Checking for letters"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); @@ -492,38 +488,38 @@ public class PolybiusSquareTest{ @Test public void testGetPreparedInputStringEncode(){ - cipher.inputString = decodedString; + cipher.inputString = DECODED_STRING; String output = cipher.getPreparedInputStringEncode(); - assertEquals(decodedStringClean.replaceAll("\\s", ""), output); + assertEquals(DECODED_STRING_CLEAN.replaceAll("\\s", ""), output); verify(logger, times(1)).debug("Preparing input string for encoding"); - verify(logger, times(1)).debug("Prepared string '{}'", decodedStringClean.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Prepared string '{}'", DECODED_STRING_CLEAN.replaceAll("\\s", "")); } @Test public void testGetPreparedInputStringDecode(){ - cipher.inputString = encodedString; + cipher.inputString = ENCODED_STRING; String output = cipher.getPreparedInputStringDecode(); - assertEquals(encodedStringClean.replaceAll("\\s", ""), output); + assertEquals(ENCODED_STRING_CLEAN.replaceAll("\\s", ""), output); verify(logger, times(1)).debug("Preparing input string for decoding"); - verify(logger, times(1)).debug("Prepared string '{}'", encodedStringClean.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Prepared string '{}'", ENCODED_STRING_CLEAN.replaceAll("\\s", "")); } @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keywordClean, cipher.keyword); - assertArrayEquals(grid, cipher.grid); - verify(logger, times(1)).debug("Original keyword {}", keyword); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertArrayEquals(GRID, cipher.grid); + verify(logger, times(1)).debug("Original keyword {}", KEYWORD); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Removing all non-letter characters"); verify(logger, times(1)).debug("Appending entire alphabet"); verify(logger, times(1)).debug("Replacing {} with {}", cipher.replaced, cipher.replacer); - verify(logger, times(1)).debug("Cleaned keyword {}", keywordClean); + verify(logger, times(1)).debug("Cleaned keyword {}", KEYWORD_CLEAN); } @Test @@ -566,7 +562,7 @@ public class PolybiusSquareTest{ @Test public void testFindChar(){ - cipher.grid = grid; + cipher.grid = GRID; CharLocation returnedLocation = cipher.findChar('A'); @@ -578,7 +574,7 @@ public class PolybiusSquareTest{ @Test public void testFindChar_invalid(){ - cipher.grid = grid; + cipher.grid = GRID; assertThrows(InvalidInputException.class, () -> { cipher.findChar(cipher.replaced); @@ -590,41 +586,41 @@ public class PolybiusSquareTest{ @Test public void testAddCharactersToCleanStringEncode(){ - cipher.inputString = decodedString; + cipher.inputString = DECODED_STRING; - cipher.addCharactersToCleanStringEncode(encodedStringClean.replaceAll("\\D", "")); + cipher.addCharactersToCleanStringEncode(ENCODED_STRING_CLEAN.replaceAll("\\D", "")); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Formatting output string for encoding"); verify(logger, times(17)).debug(eq("Working character {}"), anyChar()); verify(logger, times(15)).debug("Adding encoded characters"); verify(logger, times(2)).debug("Adding symbols"); - verify(logger, times(1)).debug("Formatted output '{}'", encodedString); + verify(logger, times(1)).debug("Formatted output '{}'", ENCODED_STRING); } @Test public void testAddCharactersToCleanStringDecode(){ - cipher.inputString = encodedString; + cipher.inputString = ENCODED_STRING; - cipher.addCharactersToCleanStringDecode(decodedStringClean.replaceAll("\\s", "")); + cipher.addCharactersToCleanStringDecode(DECODED_STRING_CLEAN.replaceAll("\\s", "")); - assertEquals(decodedString.toUpperCase(), cipher.outputString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.outputString); verify(logger, times(1)).debug("Formatting output string for decoding"); verify(logger, times(17)).debug(eq("Working character {}"), anyChar()); verify(logger, times(15)).debug("Adding decoded characters"); verify(logger, times(2)).debug("Adding symbols"); - verify(logger, times(1)).debug("Formatted output '{}'", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Formatted output '{}'", DECODED_STRING.toUpperCase()); } @Test public void testEncode(){ - cipher.inputString = decodedString.toUpperCase(); - cipher.keyword = keywordClean; - cipher.grid = grid; + cipher.inputString = DECODED_STRING.toUpperCase(); + cipher.keyword = KEYWORD_CLEAN; + cipher.grid = GRID; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(15)).debug(eq("Current working character {}"), anyChar()); verify(logger, times(15)).debug(eq("Location {}, {}"), anyInt(), anyInt()); @@ -632,13 +628,13 @@ public class PolybiusSquareTest{ @Test public void testDecode(){ - cipher.inputString = encodedString; - cipher.keyword = keywordClean; - cipher.grid = grid; + cipher.inputString = ENCODED_STRING; + cipher.keyword = KEYWORD_CLEAN; + cipher.grid = GRID; cipher.decode(); - assertEquals(decodedString.toUpperCase(), cipher.outputString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(15)).debug(eq("Digits to decode {} {}"), anyChar(), anyChar()); verify(logger, times(15)).debug(eq("Decoded letter {}"), anyChar()); @@ -646,14 +642,14 @@ public class PolybiusSquareTest{ @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.keyword = keywordClean; - cipher.outputString = encodedString; - cipher.grid = grid; + cipher.inputString = DECODED_STRING; + cipher.keyword = KEYWORD_CLEAN; + cipher.outputString = ENCODED_STRING; + cipher.grid = GRID; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(keywordClean, cipher.getKeyword()); - assertEquals(encodedString, cipher.getOutputString()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(KEYWORD_CLEAN, cipher.getKeyword()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); assertEquals("[K E Y W O]\n[R D A B C]\n[F G H I L]\n[M N P Q S]\n[T U V X Z]", cipher.getGrid()); assertEquals('J', cipher.getReplaced()); assertEquals('I', cipher.getReplacer()); @@ -661,10 +657,10 @@ public class PolybiusSquareTest{ @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.keyword = keyword; - cipher.outputString = encodedString; - cipher.grid = grid; + cipher.inputString = DECODED_STRING; + cipher.keyword = KEYWORD; + cipher.outputString = ENCODED_STRING; + cipher.grid = GRID; cipher.reset(); @@ -680,51 +676,51 @@ public class PolybiusSquareTest{ public void testPracticalEncode(){ cipher = new PolybiusSquare(true, true); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalEncode_clean(){ cipher = new PolybiusSquare(false, false); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalDecode(){ cipher = new PolybiusSquare(true, true); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedString.toUpperCase(), cipher.outputString); - assertEquals(decodedString.toUpperCase(), output); - assertArrayEquals(grid, cipher.grid); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING.toUpperCase(), cipher.outputString); + assertEquals(DECODED_STRING.toUpperCase(), output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalDecode_clean(){ cipher = new PolybiusSquare(false, false); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedString.replaceAll("\\s", "").replaceAll("[^0-9]", ""), cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedStringClean.replaceAll("\\s", ""), cipher.outputString); - assertEquals(decodedStringClean.replaceAll("\\s", ""), output); - assertArrayEquals(grid, cipher.grid); + assertEquals(ENCODED_STRING.replaceAll("\\s", "").replaceAll("[^0-9]", ""), cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING_CLEAN.replaceAll("\\s", ""), cipher.outputString); + assertEquals(DECODED_STRING_CLEAN.replaceAll("\\s", ""), output); + assertArrayEquals(GRID, cipher.grid); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/RailFenceTest.java b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/RailFenceTest.java index 57f7498..577488a 100644 --- a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/RailFenceTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/RailFenceTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/polysubstitution/RailFenceTest.java -//Mattrixwv -// Created: 03-21-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.polysubstitution; @@ -27,18 +23,18 @@ public class RailFenceTest{ @Mock private Logger logger; //Fields - private static final String decodedString = "Message to^encode"; - private static final String decodedStringClean = "MESSAGETOENCODE"; - private static final String encodedString3 = "Maooesg te^cdsene"; - private static final String encodedString3Clean = "MAOOESGTECDSENE"; - private static final String encodedString5 = "Moetese ne^sgcdao"; - private static final String encodedString5Clean = "MOETESENESGCDAO"; - private static final StringBuilder[] fence3 = new StringBuilder[]{ + private static final String DECODED_STRING = "Message to^encode"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODE"; + private static final String ENCODED_STRING_3 = "Maooesg te^cdsene"; + private static final String ENCODED_STRING_3_CLEAN = "MAOOESGTECDSENE"; + private static final String ENCODED_STRING_5 = "Moetese ne^sgcdao"; + private static final String ENCODED_STRING_5_CLEAN = "MOETESENESGCDAO"; + private static final StringBuilder[] FENCE_3 = new StringBuilder[]{ new StringBuilder("Maoo"), new StringBuilder("esgtecd"), new StringBuilder("sene") }; - private static final StringBuilder[] fence5 = new StringBuilder[]{ + private static final StringBuilder[] FENCE_5 = new StringBuilder[]{ new StringBuilder("Mo"), new StringBuilder("ete"), new StringBuilder("sene"), @@ -101,14 +97,14 @@ public class RailFenceTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Clean input string '{}'", decodedString); + verify(logger, times(1)).debug("Clean input string '{}'", DECODED_STRING); } @Test @@ -117,14 +113,14 @@ public class RailFenceTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Clean input string '{}'", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Clean input string '{}'", DECODED_STRING.toUpperCase()); } @Test @@ -133,14 +129,14 @@ public class RailFenceTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Clean input string '{}'", decodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Clean input string '{}'", DECODED_STRING.replaceAll("\\s", "")); } @Test @@ -149,14 +145,14 @@ public class RailFenceTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z\\s]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Clean input string '{}'", decodedString.replaceAll("[^a-zA-Z\\s]", "")); + verify(logger, times(1)).debug("Clean input string '{}'", DECODED_STRING.replaceAll("[^a-zA-Z\\s]", "")); } @Test @@ -215,43 +211,43 @@ public class RailFenceTest{ @Test public void testGetCleanInputString(){ - cipher.inputString = decodedString; + cipher.inputString = DECODED_STRING; String output = cipher.getCleanInputString(); - assertEquals(decodedString.replaceAll("[^a-zA-Z]", ""), output); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z]", ""), output); verify(logger, times(1)).debug("Getting input string for encoding"); } @Test public void testFormatOutput(){ - cipher.inputString = decodedString; + cipher.inputString = DECODED_STRING; - cipher.formatOutput(encodedString3Clean); + cipher.formatOutput(ENCODED_STRING_3_CLEAN); - assertEquals(encodedString3, cipher.outputString); + assertEquals(ENCODED_STRING_3, cipher.outputString); verify(logger, times(1)).debug("Formatting output string"); verify(logger, times(17)).debug(eq("Working character {}"), anyChar()); verify(logger, times(1)).debug("Formatting uppercase"); verify(logger, times(14)).debug("Formatting lowercase"); verify(logger, times(2)).debug("Inserting symbol"); - verify(logger, times(1)).debug("Formatted output '{}'", encodedString3); + verify(logger, times(1)).debug("Formatted output '{}'", ENCODED_STRING_3); } @Test public void testGetDecodedStringFromFence(){ - cipher.fence = fence3; + cipher.fence = FENCE_3; String output = cipher.getDecodedStringFromFence(); - assertEquals(decodedString.replaceAll("[^a-zA-Z]", ""), output); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z]", ""), output); verify(logger, times(1)).debug("Getting decoded string from the fence"); verify(logger, times(1)).debug(eq("Fence output '{}'"), any(StringBuilder.class)); } @Test public void testEncode(){ - cipher.inputString = decodedString; + cipher.inputString = DECODED_STRING; cipher.fence = new StringBuilder[]{ new StringBuilder(), new StringBuilder(), @@ -260,7 +256,7 @@ public class RailFenceTest{ cipher.encode(); - assertEquals(encodedString3, cipher.outputString); + assertEquals(ENCODED_STRING_3, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(15)).debug(eq("Working character '{}'"), anyChar()); verify(logger, times(9)).debug("Moving up"); @@ -272,7 +268,7 @@ public class RailFenceTest{ @Test public void testDecode(){ - cipher.inputString = encodedString3; + cipher.inputString = ENCODED_STRING_3; cipher.fence = new StringBuilder[]{ new StringBuilder(), new StringBuilder(), @@ -281,14 +277,14 @@ public class RailFenceTest{ cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(1)).debug("Number of characters in the top rail {}", 4); verify(logger, times(1)).debug("Number of characters in the middle rails {}", 8); verify(logger, times(1)).debug("Number of characters in the bottom rail {}", 4); verify(logger, times(1)).debug("Adding characters to the rails"); verify(logger, times(1)).debug("Appending the bottom rail"); - verify(logger, times(1)).debug("Fence output '{}'", decodedString.replaceAll("[^a-zA-Z]", "")); + verify(logger, times(1)).debug("Fence output '{}'", DECODED_STRING.replaceAll("[^a-zA-Z]", "")); } @Test @@ -314,20 +310,20 @@ public class RailFenceTest{ @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString3; - cipher.fence = fence3; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING_3; + cipher.fence = FENCE_3; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString3, cipher.getOutputString()); - assertEquals(fence3.length, cipher.getNumRails()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING_3, cipher.getOutputString()); + assertEquals(FENCE_3.length, cipher.getNumRails()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString3; - cipher.fence = fence3; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING_3; + cipher.fence = FENCE_3; cipher.reset(); @@ -340,127 +336,127 @@ public class RailFenceTest{ public void testPracticalEncoding_3(){ cipher = new RailFence(true, true, true); - String output = cipher.encode(3, decodedString); + String output = cipher.encode(3, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(fence3.length, cipher.fence.length); - assertEquals(fence3[0].toString(), cipher.fence[0].toString()); - assertEquals(fence3[1].toString(), cipher.fence[1].toString()); - assertEquals(fence3[2].toString(), cipher.fence[2].toString()); - assertEquals(encodedString3, cipher.outputString); - assertEquals(encodedString3, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(FENCE_3.length, cipher.fence.length); + assertEquals(FENCE_3[0].toString(), cipher.fence[0].toString()); + assertEquals(FENCE_3[1].toString(), cipher.fence[1].toString()); + assertEquals(FENCE_3[2].toString(), cipher.fence[2].toString()); + assertEquals(ENCODED_STRING_3, cipher.outputString); + assertEquals(ENCODED_STRING_3, output); } @Test public void testPracticalEncoding_3Clean(){ cipher = new RailFence(false, false, false); - String output = cipher.encode(3, decodedString); + String output = cipher.encode(3, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(fence3.length, cipher.fence.length); - assertEquals(fence3[0].toString().toUpperCase(), cipher.fence[0].toString()); - assertEquals(fence3[1].toString().toUpperCase(), cipher.fence[1].toString()); - assertEquals(fence3[2].toString().toUpperCase(), cipher.fence[2].toString()); - assertEquals(encodedString3Clean, cipher.outputString); - assertEquals(encodedString3Clean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(FENCE_3.length, cipher.fence.length); + assertEquals(FENCE_3[0].toString().toUpperCase(), cipher.fence[0].toString()); + assertEquals(FENCE_3[1].toString().toUpperCase(), cipher.fence[1].toString()); + assertEquals(FENCE_3[2].toString().toUpperCase(), cipher.fence[2].toString()); + assertEquals(ENCODED_STRING_3_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_3_CLEAN, output); } @Test public void testPracticalEncoding_5(){ cipher = new RailFence(true, true, true); - String output = cipher.encode(5, decodedString); + String output = cipher.encode(5, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(fence5.length, cipher.fence.length); - assertEquals(fence5[0].toString(), cipher.fence[0].toString()); - assertEquals(fence5[1].toString(), cipher.fence[1].toString()); - assertEquals(fence5[2].toString(), cipher.fence[2].toString()); - assertEquals(fence5[3].toString(), cipher.fence[3].toString()); - assertEquals(fence5[4].toString(), cipher.fence[4].toString()); - assertEquals(encodedString5, cipher.outputString); - assertEquals(encodedString5, output); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(FENCE_5.length, cipher.fence.length); + assertEquals(FENCE_5[0].toString(), cipher.fence[0].toString()); + assertEquals(FENCE_5[1].toString(), cipher.fence[1].toString()); + assertEquals(FENCE_5[2].toString(), cipher.fence[2].toString()); + assertEquals(FENCE_5[3].toString(), cipher.fence[3].toString()); + assertEquals(FENCE_5[4].toString(), cipher.fence[4].toString()); + assertEquals(ENCODED_STRING_5, cipher.outputString); + assertEquals(ENCODED_STRING_5, output); } @Test public void testPracticalEncoding_5Clean(){ cipher = new RailFence(false, false, false); - String output = cipher.encode(5, decodedString); + String output = cipher.encode(5, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(fence5.length, cipher.fence.length); - assertEquals(fence5[0].toString().toUpperCase(), cipher.fence[0].toString()); - assertEquals(fence5[1].toString().toUpperCase(), cipher.fence[1].toString()); - assertEquals(fence5[2].toString().toUpperCase(), cipher.fence[2].toString()); - assertEquals(fence5[3].toString().toUpperCase(), cipher.fence[3].toString()); - assertEquals(fence5[4].toString().toUpperCase(), cipher.fence[4].toString()); - assertEquals(encodedString5Clean, cipher.outputString); - assertEquals(encodedString5Clean, output); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(FENCE_5.length, cipher.fence.length); + assertEquals(FENCE_5[0].toString().toUpperCase(), cipher.fence[0].toString()); + assertEquals(FENCE_5[1].toString().toUpperCase(), cipher.fence[1].toString()); + assertEquals(FENCE_5[2].toString().toUpperCase(), cipher.fence[2].toString()); + assertEquals(FENCE_5[3].toString().toUpperCase(), cipher.fence[3].toString()); + assertEquals(FENCE_5[4].toString().toUpperCase(), cipher.fence[4].toString()); + assertEquals(ENCODED_STRING_5_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_5_CLEAN, output); } @Test public void testPracticalDecoding_3(){ cipher = new RailFence(true, true, true); - String output = cipher.decode(3, encodedString3); + String output = cipher.decode(3, ENCODED_STRING_3); - assertEquals(encodedString3, cipher.inputString); - assertEquals(fence3.length, cipher.fence.length); - assertEquals(fence3[0].toString(), cipher.fence[0].toString()); - assertEquals(fence3[1].toString(), cipher.fence[1].toString()); - assertEquals(fence3[2].toString(), cipher.fence[2].toString()); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING_3, cipher.inputString); + assertEquals(FENCE_3.length, cipher.fence.length); + assertEquals(FENCE_3[0].toString(), cipher.fence[0].toString()); + assertEquals(FENCE_3[1].toString(), cipher.fence[1].toString()); + assertEquals(FENCE_3[2].toString(), cipher.fence[2].toString()); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_3Clean(){ cipher = new RailFence(false, false, false); - String output = cipher.decode(3, encodedString3); + String output = cipher.decode(3, ENCODED_STRING_3); - assertEquals(encodedString3Clean, cipher.inputString); - assertEquals(fence3.length, cipher.fence.length); - assertEquals(fence3[0].toString().toUpperCase(), cipher.fence[0].toString()); - assertEquals(fence3[1].toString().toUpperCase(), cipher.fence[1].toString()); - assertEquals(fence3[2].toString().toUpperCase(), cipher.fence[2].toString()); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_3_CLEAN, cipher.inputString); + assertEquals(FENCE_3.length, cipher.fence.length); + assertEquals(FENCE_3[0].toString().toUpperCase(), cipher.fence[0].toString()); + assertEquals(FENCE_3[1].toString().toUpperCase(), cipher.fence[1].toString()); + assertEquals(FENCE_3[2].toString().toUpperCase(), cipher.fence[2].toString()); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } @Test public void testPracticalDecoding_5(){ cipher = new RailFence(true, true, true); - String output = cipher.decode(5, encodedString5); + String output = cipher.decode(5, ENCODED_STRING_5); - assertEquals(encodedString5, cipher.inputString); - assertEquals(fence5.length, cipher.fence.length); - assertEquals(fence5[0].toString(), cipher.fence[0].toString()); - assertEquals(fence5[1].toString(), cipher.fence[1].toString()); - assertEquals(fence5[2].toString(), cipher.fence[2].toString()); - assertEquals(fence5[3].toString(), cipher.fence[3].toString()); - assertEquals(fence5[4].toString(), cipher.fence[4].toString()); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); + assertEquals(ENCODED_STRING_5, cipher.inputString); + assertEquals(FENCE_5.length, cipher.fence.length); + assertEquals(FENCE_5[0].toString(), cipher.fence[0].toString()); + assertEquals(FENCE_5[1].toString(), cipher.fence[1].toString()); + assertEquals(FENCE_5[2].toString(), cipher.fence[2].toString()); + assertEquals(FENCE_5[3].toString(), cipher.fence[3].toString()); + assertEquals(FENCE_5[4].toString(), cipher.fence[4].toString()); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); } @Test public void testPracticalDecoding_5Clean(){ cipher = new RailFence(false, false, false); - String output = cipher.decode(5, encodedString5); + String output = cipher.decode(5, ENCODED_STRING_5); - assertEquals(encodedString5Clean, cipher.inputString); - assertEquals(fence5.length, cipher.fence.length); - assertEquals(fence5[0].toString().toUpperCase(), cipher.fence[0].toString()); - assertEquals(fence5[1].toString().toUpperCase(), cipher.fence[1].toString()); - assertEquals(fence5[2].toString().toUpperCase(), cipher.fence[2].toString()); - assertEquals(fence5[3].toString().toUpperCase(), cipher.fence[3].toString()); - assertEquals(fence5[4].toString().toUpperCase(), cipher.fence[4].toString()); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); + assertEquals(ENCODED_STRING_5_CLEAN, cipher.inputString); + assertEquals(FENCE_5.length, cipher.fence.length); + assertEquals(FENCE_5[0].toString().toUpperCase(), cipher.fence[0].toString()); + assertEquals(FENCE_5[1].toString().toUpperCase(), cipher.fence[1].toString()); + assertEquals(FENCE_5[2].toString().toUpperCase(), cipher.fence[2].toString()); + assertEquals(FENCE_5[3].toString().toUpperCase(), cipher.fence[3].toString()); + assertEquals(FENCE_5[4].toString().toUpperCase(), cipher.fence[4].toString()); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); } } diff --git a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/TrifidTest.java b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/TrifidTest.java index 7e59960..9cbe257 100644 --- a/src/test/java/com/mattrixwv/cipherstream/polysubstitution/TrifidTest.java +++ b/src/test/java/com/mattrixwv/cipherstream/polysubstitution/TrifidTest.java @@ -1,7 +1,3 @@ -//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/polysubstitution/TrifidTest.java -//Mattrixwv -// Created: 03-03-22 -//Modified: 04-19-24 package com.mattrixwv.cipherstream.polysubstitution; @@ -32,19 +28,19 @@ public class TrifidTest{ @Mock private Logger logger; //Fields - private static final String decodedString = "Message to^encode+"; - private static final String decodedStringClean = "MESSAGETOENCODE+"; - private static final String decodedStringCleanAlt = "MESSAGETOENCODE"; - private static final String encodedString = "Gqdokxy eg^ranmoqr"; - private static final String encodedStringAlt = "Gqdokpd od^ljvflf+"; - private static final String encodedString3 = "Gpjqdvd of^odlklf+"; - private static final String encodedStringClean = "GQDOKXYEGRANMOQR"; - private static final String encodedStringCleanAlt = "GQDOKPDODLJVFLF"; - private static final String encodedStringClean3 = "GPJQDVDOFODLKLF+"; - private static final String keyword = "ke yw*ord"; - private static final String keywordClean = "KEYWORDABCFGHIJLMNPQSTUVXZ+"; - private static final String keywordCleanAlt = "KEYWORDABCFGHIJLMNPQSTUVXZ="; - private static final char[][][] grid = new char[][][]{ + private static final String DECODED_STRING = "Message to^encode+"; + private static final String DECODED_STRING_CLEAN = "MESSAGETOENCODE+"; + private static final String DECODED_STRING_CLEAN_ALT = "MESSAGETOENCODE"; + private static final String ENCODED_STRING = "Gqdokxy eg^ranmoqr"; + private static final String ENCODED_STRING_ALT = "Gqdokpd od^ljvflf+"; + private static final String ENCODED_STRING_3 = "Gpjqdvd of^odlklf+"; + private static final String ENCODED_STRING_CLEAN = "GQDOKXYEGRANMOQR"; + private static final String ENCODED_STRING_CLEAN_ALT = "GQDOKPDODLJVFLF"; + private static final String ENCODED_STRING_CLEAN_3 = "GPJQDVDOFODLKLF+"; + private static final String KEYWORD = "ke yw*ord"; + private static final String KEYWORD_CLEAN = "KEYWORDABCFGHIJLMNPQSTUVXZ+"; + private static final String KEYWORD_CLEAN_ALT = "KEYWORDABCFGHIJLMNPQSTUVXZ="; + private static final char[][][] GRID = new char[][][]{ { {'K', 'E', 'Y'}, {'W', 'O', 'R'}, @@ -61,8 +57,8 @@ public class TrifidTest{ {'X', 'Z', '+'} } }; - private static final String gridString = "[K E Y]\n[W O R]\n[D A B]\n\n[C F G]\n[H I J]\n[L M N]\n\n[P Q S]\n[T U V]\n[X Z +]"; - private static final char[][][] gridAlt = new char[][][]{ + private static final String GRID_STRING = "[K E Y]\n[W O R]\n[D A B]\n\n[C F G]\n[H I J]\n[L M N]\n\n[P Q S]\n[T U V]\n[X Z +]"; + private static final char[][][] GRID_ALT = new char[][][]{ { {'K', 'E', 'Y'}, {'W', 'O', 'R'}, @@ -226,16 +222,16 @@ public class TrifidTest{ @Test public void testSetKeyword(){ - cipher.setKeyword(keyword); + cipher.setKeyword(KEYWORD); - assertEquals(keywordClean, cipher.keyword); - assertArrayEquals(grid, cipher.grid); - verify(logger, times(1)).debug("Original keyword {}", keyword); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertArrayEquals(GRID, cipher.grid); + verify(logger, times(1)).debug("Original keyword {}", KEYWORD); verify(logger, times(1)).debug("Removing case"); verify(logger, times(1)).debug("Removing all invalid characters"); verify(logger, times(1)).debug("Appending entire alphabet to keyword"); verify(logger, times(1)).debug("Removing duplicate characters"); - verify(logger, times(1)).debug("Cleaned keyword {}", keywordClean); + verify(logger, times(1)).debug("Cleaned keyword {}", KEYWORD_CLEAN); } @Test @@ -287,13 +283,13 @@ public class TrifidTest{ @Test public void setCreateGrid(){ - cipher.keyword = keywordClean; + cipher.keyword = KEYWORD_CLEAN; cipher.createGrid(); - assertArrayEquals(grid, cipher.grid); + assertArrayEquals(GRID, cipher.grid); verify(logger, times(1)).debug("Creating grid from keyword"); - verify(logger, times(1)).debug("Completed grid\n{}", gridString); + verify(logger, times(1)).debug("Completed grid\n{}", GRID_STRING); } @Test @@ -320,14 +316,14 @@ public class TrifidTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING, cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING); } @Test @@ -336,14 +332,14 @@ public class TrifidTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.toUpperCase(), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.toUpperCase(), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, times(1)).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase()); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.toUpperCase()); } @Test @@ -352,14 +348,14 @@ public class TrifidTest{ cipher.preserveWhitespace = false; cipher.preserveSymbols = true; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("\\s", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("\\s", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, times(1)).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("\\s", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("\\s", "")); } @Test @@ -370,11 +366,11 @@ public class TrifidTest{ cipher.fillIn = ' '; assertThrows(InvalidInputException.class, () -> { - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); }); assertEquals("", cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, never()).debug("Removing symbols"); @@ -387,14 +383,14 @@ public class TrifidTest{ cipher.preserveWhitespace = true; cipher.preserveSymbols = false; - cipher.setInputString(decodedString); + cipher.setInputString(DECODED_STRING); - assertEquals(decodedString.replaceAll("[^a-zA-Z\\s+]", ""), cipher.inputString); - verify(logger, times(1)).debug("Original input string '{}'", decodedString); + assertEquals(DECODED_STRING.replaceAll("[^a-zA-Z\\s+]", ""), cipher.inputString); + verify(logger, times(1)).debug("Original input string '{}'", DECODED_STRING); verify(logger, never()).debug("Removing case"); verify(logger, never()).debug("Removing whitespace"); verify(logger, times(1)).debug("Removing symbols"); - verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("[^a-zA-Z\\s+]", "")); + verify(logger, times(1)).debug("Cleaned input string '{}'", DECODED_STRING.replaceAll("[^a-zA-Z\\s+]", "")); } @Test @@ -435,17 +431,17 @@ public class TrifidTest{ @Test public void testGetCleanInputString(){ - cipher.inputString = decodedString; + cipher.inputString = DECODED_STRING; String returnedInput = cipher.getCleanInputString(); - assertEquals(decodedStringClean, returnedInput); + assertEquals(DECODED_STRING_CLEAN, returnedInput); verify(logger, times(1)).debug("Cleaning input string for encoding"); } @Test public void testFindChar(){ - cipher.grid = grid; + cipher.grid = GRID; CharLocation returnedLocation = cipher.findChar('G'); @@ -456,7 +452,7 @@ public class TrifidTest{ @Test public void testFindChar_invalid(){ - cipher.grid = grid; + cipher.grid = GRID; assertThrows(InvalidCharacterException.class, () -> { cipher.findChar('='); @@ -468,7 +464,7 @@ public class TrifidTest{ @Test public void testGetChar(){ - cipher.grid = grid; + cipher.grid = GRID; char returnedChar = cipher.getChar(cipher.new CharLocation(0, 1, 2)); @@ -483,7 +479,7 @@ public class TrifidTest{ "0, 1, 3" }) public void testGetChar_invalidLocation(int x, int y, int z){ - cipher.grid = grid; + cipher.grid = GRID; CharLocation location = cipher.new CharLocation(x, y, z); assertThrows(InvalidCharacterException.class, () -> { @@ -496,47 +492,47 @@ public class TrifidTest{ @Test public void testFormatOutput(){ cipher.preserveCapitals = true; - cipher.inputString = decodedString; + cipher.inputString = DECODED_STRING; - cipher.formatOutput(encodedStringClean); + cipher.formatOutput(ENCODED_STRING_CLEAN); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Formatting output"); verify(logger, times(18)).debug(eq("Working character {}"), anyChar()); verify(logger, times(1)).debug("Formatting uppercase"); verify(logger, times(14)).debug("Formatting lowercase"); verify(logger, times(1)).debug("Adding fillIn"); verify(logger, times(2)).debug("Appending symbol"); - verify(logger, times(1)).debug("Formatted output '{}'", encodedString); + verify(logger, times(1)).debug("Formatted output '{}'", ENCODED_STRING); } @Test public void testFormatOutput_noCapitals(){ cipher.preserveCapitals = false; - cipher.inputString = decodedString.toUpperCase(); + cipher.inputString = DECODED_STRING.toUpperCase(); - cipher.formatOutput(encodedStringClean); + cipher.formatOutput(ENCODED_STRING_CLEAN); - assertEquals(encodedString.toUpperCase(), cipher.outputString); + assertEquals(ENCODED_STRING.toUpperCase(), cipher.outputString); verify(logger, times(1)).debug("Formatting output"); verify(logger, times(18)).debug(eq("Working character {}"), anyChar()); verify(logger, times(15)).debug("Formatting uppercase"); verify(logger, never()).debug("Formatting lowercase"); verify(logger, times(1)).debug("Adding fillIn"); verify(logger, times(2)).debug("Appending symbol"); - verify(logger, times(1)).debug("Formatted output '{}'", encodedString.toUpperCase()); + verify(logger, times(1)).debug("Formatted output '{}'", ENCODED_STRING.toUpperCase()); } @Test public void testEncode(){ cipher.preserveCapitals = true; - cipher.inputString = decodedString; - cipher.keyword = keywordClean; - cipher.grid = grid; + cipher.inputString = DECODED_STRING; + cipher.keyword = KEYWORD_CLEAN; + cipher.grid = GRID; cipher.encode(); - assertEquals(encodedString, cipher.outputString); + assertEquals(ENCODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(1)).debug("Converting letters to coordinates"); verify(logger, times(1)).debug("Splitting locations into groups"); @@ -548,14 +544,14 @@ public class TrifidTest{ @Test public void testEncode_3(){ cipher.preserveCapitals = true; - cipher.inputString = decodedString; - cipher.keyword = keywordClean; - cipher.grid = grid; + cipher.inputString = DECODED_STRING; + cipher.keyword = KEYWORD_CLEAN; + cipher.grid = GRID; cipher.groupSize = 3; cipher.encode(); - assertEquals(encodedString3, cipher.outputString); + assertEquals(ENCODED_STRING_3, cipher.outputString); verify(logger, times(1)).debug("Encoding"); verify(logger, times(1)).debug("Converting letters to coordinates"); verify(logger, times(1)).debug("Splitting locations into groups"); @@ -567,13 +563,13 @@ public class TrifidTest{ @Test public void testDecode(){ cipher.preserveCapitals = true; - cipher.inputString = encodedString; - cipher.keyword = keywordClean; - cipher.grid = grid; + cipher.inputString = ENCODED_STRING; + cipher.keyword = KEYWORD_CLEAN; + cipher.grid = GRID; cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(1)).debug("Converting letters to coordinates"); verify(logger, times(1)).debug("Splitting locations into groups"); @@ -585,14 +581,14 @@ public class TrifidTest{ @Test public void testDecode_3(){ cipher.preserveCapitals = true; - cipher.inputString = encodedString3; - cipher.keyword = keywordClean; - cipher.grid = grid; + cipher.inputString = ENCODED_STRING_3; + cipher.keyword = KEYWORD_CLEAN; + cipher.grid = GRID; cipher.groupSize = 3; cipher.decode(); - assertEquals(decodedString, cipher.outputString); + assertEquals(DECODED_STRING, cipher.outputString); verify(logger, times(1)).debug("Decoding"); verify(logger, times(1)).debug("Converting letters to coordinates"); verify(logger, times(1)).debug("Splitting locations into groups"); @@ -603,28 +599,28 @@ public class TrifidTest{ @Test public void testGetters(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keywordClean; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD_CLEAN; cipher.groupSize = 3; cipher.fillIn = '='; - cipher.grid = grid; + cipher.grid = GRID; - assertEquals(decodedString, cipher.getInputString()); - assertEquals(encodedString, cipher.getOutputString()); - assertEquals(keywordClean, cipher.getKeyword()); + assertEquals(DECODED_STRING, cipher.getInputString()); + assertEquals(ENCODED_STRING, cipher.getOutputString()); + assertEquals(KEYWORD_CLEAN, cipher.getKeyword()); assertEquals(3, cipher.getGroupSize()); assertEquals('=', cipher.getFillIn()); - assertEquals(gridString, cipher.getGrid()); + assertEquals(GRID_STRING, cipher.getGrid()); } @Test public void testReset(){ - cipher.inputString = decodedString; - cipher.outputString = encodedString; - cipher.keyword = keyword; + cipher.inputString = DECODED_STRING; + cipher.outputString = ENCODED_STRING; + cipher.keyword = KEYWORD; cipher.groupSize = 3; - cipher.grid = grid; + cipher.grid = GRID; cipher.reset(); @@ -639,155 +635,155 @@ public class TrifidTest{ public void testPracticalEncoding(){ cipher = new Trifid(true, true, true); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedString, cipher.outputString); - assertEquals(encodedString, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING, cipher.outputString); + assertEquals(ENCODED_STRING, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalEncoding_3(){ cipher = new Trifid(true, true, true); - String output = cipher.encode(keyword, 3, decodedString); + String output = cipher.encode(KEYWORD, 3, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedString3, cipher.outputString); - assertEquals(encodedString3, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING_3, cipher.outputString); + assertEquals(ENCODED_STRING_3, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalEncoding_fill(){ cipher = new Trifid(true, true, true, '='); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedString, cipher.inputString); - assertEquals(keywordCleanAlt, cipher.keyword); - assertEquals(encodedStringAlt, cipher.outputString); - assertEquals(encodedStringAlt, output); - assertArrayEquals(gridAlt, cipher.grid); + assertEquals(DECODED_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN_ALT, cipher.keyword); + assertEquals(ENCODED_STRING_ALT, cipher.outputString); + assertEquals(ENCODED_STRING_ALT, output); + assertArrayEquals(GRID_ALT, cipher.grid); } @Test public void testPracticalEncoding_clean(){ cipher = new Trifid(false, false, false); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedStringClean, cipher.outputString); - assertEquals(encodedStringClean, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalEncoding_clean3(){ cipher = new Trifid(false, false, false); - String output = cipher.encode(keyword, 3, decodedString); + String output = cipher.encode(KEYWORD, 3, DECODED_STRING); - assertEquals(decodedStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(encodedStringClean3, cipher.outputString); - assertEquals(encodedStringClean3, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(DECODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN_3, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN_3, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalEncoding_cleanFill(){ cipher = new Trifid(false, false, false, '='); - String output = cipher.encode(keyword, decodedString); + String output = cipher.encode(KEYWORD, DECODED_STRING); - assertEquals(decodedStringCleanAlt, cipher.inputString); - assertEquals(keywordCleanAlt, cipher.keyword); - assertEquals(encodedStringCleanAlt, cipher.outputString); - assertEquals(encodedStringCleanAlt, output); - assertArrayEquals(gridAlt, cipher.grid); + assertEquals(DECODED_STRING_CLEAN_ALT, cipher.inputString); + assertEquals(KEYWORD_CLEAN_ALT, cipher.keyword); + assertEquals(ENCODED_STRING_CLEAN_ALT, cipher.outputString); + assertEquals(ENCODED_STRING_CLEAN_ALT, output); + assertArrayEquals(GRID_ALT, cipher.grid); } @Test public void testPracticalDecoding(){ cipher = new Trifid(true, true, true); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedString, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(ENCODED_STRING, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalDecoding_3(){ cipher = new Trifid(true, true, true); - String output = cipher.decode(keyword, 3, encodedString3); + String output = cipher.decode(KEYWORD, 3, ENCODED_STRING_3); - assertEquals(encodedString3, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(ENCODED_STRING_3, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalDecoding_fill(){ cipher = new Trifid(true, true, true, '='); - String output = cipher.decode(keyword, encodedStringAlt); + String output = cipher.decode(KEYWORD, ENCODED_STRING_ALT); - assertEquals(encodedStringAlt, cipher.inputString); - assertEquals(keywordCleanAlt, cipher.keyword); - assertEquals(decodedString, cipher.outputString); - assertEquals(decodedString, output); - assertArrayEquals(gridAlt, cipher.grid); + assertEquals(ENCODED_STRING_ALT, cipher.inputString); + assertEquals(KEYWORD_CLEAN_ALT, cipher.keyword); + assertEquals(DECODED_STRING, cipher.outputString); + assertEquals(DECODED_STRING, output); + assertArrayEquals(GRID_ALT, cipher.grid); } @Test public void testpracticalDecoding_clean(){ cipher = new Trifid(false, false, false); - String output = cipher.decode(keyword, encodedString); + String output = cipher.decode(KEYWORD, ENCODED_STRING); - assertEquals(encodedStringClean, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(ENCODED_STRING_CLEAN, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalDecoding_clean3(){ cipher = new Trifid(false, false, false); - String output = cipher.decode(keyword, 3, encodedString3); + String output = cipher.decode(KEYWORD, 3, ENCODED_STRING_3); - assertEquals(encodedStringClean3, cipher.inputString); - assertEquals(keywordClean, cipher.keyword); - assertEquals(decodedStringClean, cipher.outputString); - assertEquals(decodedStringClean, output); - assertArrayEquals(grid, cipher.grid); + assertEquals(ENCODED_STRING_CLEAN_3, cipher.inputString); + assertEquals(KEYWORD_CLEAN, cipher.keyword); + assertEquals(DECODED_STRING_CLEAN, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN, output); + assertArrayEquals(GRID, cipher.grid); } @Test public void testPracticalDecoding_cleanFill(){ cipher = new Trifid(false, false, false, '='); - String output = cipher.decode(keyword, encodedStringAlt); + String output = cipher.decode(KEYWORD, ENCODED_STRING_ALT); - assertEquals(encodedStringCleanAlt, cipher.inputString); - assertEquals(keywordCleanAlt, cipher.keyword); - assertEquals(decodedStringCleanAlt, cipher.outputString); - assertEquals(decodedStringCleanAlt, output); - assertArrayEquals(gridAlt, cipher.grid); + assertEquals(ENCODED_STRING_CLEAN_ALT, cipher.inputString); + assertEquals(KEYWORD_CLEAN_ALT, cipher.keyword); + assertEquals(DECODED_STRING_CLEAN_ALT, cipher.outputString); + assertEquals(DECODED_STRING_CLEAN_ALT, output); + assertArrayEquals(GRID_ALT, cipher.grid); } }