CipherStream/CipherStreamJava
1
0
Fork 0
Code Issues 2 Packages Projects Releases 1 Wiki Activity

Fix sonarqube issues

Browse Source
This commit is contained in:
Matthew Ellison
2026-01-26 22:23:05 -05:00
parent 1943f19b4e
commit 8e41b0a2ad
34 changed files with 1885 additions and 2081 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
pom.xml
View File

@@ -26,7 +26,7 @@
<groupId>com.mattrixwv</groupId>
<artifactId>cipher-stream-java</artifactId>
<version>1.3.10-SNAPSHOT</version>
<version>1.4.0-SNAPSHOT</version>
<name>CipherStreamJava</name>
<description>A library to encrypt and decrypt simple ciphers</description>
@@ -54,13 +54,13 @@
<dependency>
<groupId>com.mattrixwv</groupId>
<artifactId>myClasses</artifactId>
<version>1.3.9</version>
<version>1.4.1</version>
</dependency>
<dependency>
<groupId>com.mattrixwv</groupId>
<artifactId>matrix</artifactId>
<version>1.2.3</version>
<version>1.3.1</version>
</dependency>
<dependency>

20
src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidBaseException.java
View File

@@ -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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.cipherstream.exceptions;

20
src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidCharacterException.java
View File

@@ -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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.cipherstream.exceptions;

20
src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidInputException.java
View File

@@ -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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.cipherstream.exceptions;

20
src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidKeyException.java
View File

@@ -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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.cipherstream.exceptions;

20
src/main/java/com/mattrixwv/cipherstream/exceptions/InvalidKeywordException.java
View File

@@ -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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.cipherstream.exceptions;

13
src/main/java/com/mattrixwv/cipherstream/monosubstitution/Caesar.java
View File

@@ -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");

156
src/test/java/com/mattrixwv/cipherstream/combination/ADFGVXTest.java
View File

@@ -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);
}
}

156
src/test/java/com/mattrixwv/cipherstream/combination/ADFGXTest.java
View File

@@ -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);
}
}

24
src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidBaseExceptionTest.java
View File

@@ -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());
}
}

24
src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidCharacterExceptionTest.java
View File

@@ -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());
}
}

24
src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidInputExceptionTest.java
View File

@@ -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());
}
}

24
src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidKeyExceptionTest.java
View File

@@ -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());
}
}

24
src/test/java/com/mattrixwv/cipherstream/exceptions/InvalidKeywordExceptionTest.java
View File

@@ -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());
}
}

172
src/test/java/com/mattrixwv/cipherstream/monosubstitution/AffineTest.java
View File

@@ -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);
}
}

96
src/test/java/com/mattrixwv/cipherstream/monosubstitution/AtbashTest.java
View File

@@ -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);
}
}

94
src/test/java/com/mattrixwv/cipherstream/monosubstitution/AutokeyTest.java
View File

@@ -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<Integer> 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<Integer> 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);
}
}

116
src/test/java/com/mattrixwv/cipherstream/monosubstitution/BaconianTest.java
View File

@@ -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);
}
}

134
src/test/java/com/mattrixwv/cipherstream/monosubstitution/BaseXTest.java
View File

@@ -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);
}
}

122
src/test/java/com/mattrixwv/cipherstream/monosubstitution/BeaufortTest.java
View File

@@ -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);
}
}

180
src/test/java/com/mattrixwv/cipherstream/monosubstitution/CaesarTest.java
View File

@@ -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);
}
}

108
src/test/java/com/mattrixwv/cipherstream/monosubstitution/OneTimePadTest.java
View File

@@ -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<Integer> 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<Integer> 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);
}
}

142
src/test/java/com/mattrixwv/cipherstream/monosubstitution/PortaTest.java
View File

@@ -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);
}
}

210
src/test/java/com/mattrixwv/cipherstream/monosubstitution/SubstitutionTest.java
View File

@@ -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);
}
}

155
src/test/java/com/mattrixwv/cipherstream/monosubstitution/VigenereTest.java
View File

@@ -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<Integer> 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<Integer> 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);
}
}

138
src/test/java/com/mattrixwv/cipherstream/polysubstitution/BifidTest.java
View File

@@ -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);
}
}

274
src/test/java/com/mattrixwv/cipherstream/polysubstitution/ColumnarTest.java
View File

@@ -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<ArrayList<Character>> 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<Integer> alphaLocations = new ArrayList<>(List.of(6, 1, 0, 4, 5, 3, 2));
cipher.keyword = keywordClean;
cipher.keyword = KEYWORD_CLEAN;
ArrayList<Integer> returnedLocations = cipher.getKeywordAlphaLocations();
@@ -735,7 +731,7 @@ public class ColumnarTest{
public void testGetKeywordOriginalLocations(){
ArrayList<Integer> orderedLocations = new ArrayList<>(List.of(2, 1, 6, 5, 3, 4, 0));
cipher.keyword = keywordClean;
cipher.keyword = KEYWORD_CLEAN;
ArrayList<Integer> 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);
}
}

268
src/test/java/com/mattrixwv/cipherstream/polysubstitution/HillTest.java
View File

@@ -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<ModMatrix> returnedVectors = cipher.getInputVectors();
@@ -593,29 +589,29 @@ public class HillTest{
@Test
public void testGetOutputFromVectors(){
ArrayList<ModMatrix> 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);
}
}

144
src/test/java/com/mattrixwv/cipherstream/polysubstitution/LargePolybiusSquareTest.java
View File

@@ -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);
}
}

66
src/test/java/com/mattrixwv/cipherstream/polysubstitution/MorseTest.java
View File

@@ -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);
}
}

224
src/test/java/com/mattrixwv/cipherstream/polysubstitution/PlayfairTest.java
View File

@@ -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);
}
}

218
src/test/java/com/mattrixwv/cipherstream/polysubstitution/PolybiusSquareTest.java
View File

@@ -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);
}
}

240
src/test/java/com/mattrixwv/cipherstream/polysubstitution/RailFenceTest.java
View File

@@ -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);
}
}

314
src/test/java/com/mattrixwv/cipherstream/polysubstitution/TrifidTest.java
View File

@@ -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);
}
}