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

Added logging

Browse Source
This commit is contained in:
Mattrixwv
2022-07-09 16:55:32 -04:00
parent e9c8397b86
commit 2d7382ba8f
44 changed files with 2341 additions and 1265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
src/test/java/com/mattrixwv/cipherstream/combination/TestADFGVX.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/combination/TestADFGVX.java
//Mattrixwv
// Created: 01-26-22
//Modified: 01-26-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.combination;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
@@ -25,14 +25,14 @@ public class TestADFGVX{
String keyword = "keyword";
String correctOutput = "axgvdavfxgagfaafagaaxdxfgdagda";
String output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "AXGVDAVFXGAGFAAFAGAAXDXFGDAGDA";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -40,7 +40,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "axgvdavfxgagfa afag aaxdxfgdagda";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
@@ -48,7 +48,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "axgvdavfxgagfa*afag+aaxdxfgdagda";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to-encode";
@@ -56,7 +56,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "AXgvdavfxgagfa afag-aaxdxfgdagda";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -68,14 +68,14 @@ public class TestADFGVX{
String keyword = "keyword";
String correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
String output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -83,7 +83,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXD AXDX ADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -91,7 +91,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXD*AXDX+ADAFAFXDDGDF-";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
@@ -99,7 +99,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXD AXDX^ADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital mixed case, whitesapce, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -111,14 +111,14 @@ public class TestADFGVX{
String keyword = "keyword";
String correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
String output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -126,7 +126,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -134,7 +134,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "aagagadfagaxxd*axdx+adafafxddgdf-";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
@@ -142,7 +142,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "AAgagadfagaxxdaxdx^adafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace mixed case, whitesapce, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -154,14 +154,14 @@ public class TestADFGVX{
String keyword = "keyword";
String correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
String output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -169,7 +169,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "aagagadfagaxxd axdx adafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -177,7 +177,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
@@ -185,7 +185,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "AAgagadfagaxxd axdxadafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol mixed case, whitesapce, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -197,14 +197,14 @@ public class TestADFGVX{
String keyword = "keyword";
String correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
String output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -212,7 +212,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -220,7 +220,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
@@ -228,7 +228,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed secure mixed case, whitesapce, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -242,14 +242,14 @@ public class TestADFGVX{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "AXGVDAVFXGAGFAAFAGAAXDXFGDAGDA";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "axgvdavfxgagfa afag aaxdxfgdagda";
@@ -257,7 +257,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "axgvdavfxgagfa*afag+aaxdxfgdagda-";
@@ -265,7 +265,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "message*to+encode-";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "AXgvdavfxgagfa afag^aaxdxfgdagda";
@@ -273,7 +273,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "Message to^encode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -285,14 +285,14 @@ public class TestADFGVX{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "AXGVDAVFXGAGFAAFAGAAXDXFGDAGDA";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "axgvdavfxgagfa afag aaxdxfgdagda";
@@ -300,7 +300,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "axgvdavfxgagfa*afag+aaxdxfgdagda-";
@@ -308,7 +308,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "MESSAGE*TO+ENCODE-";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "AXgvdavfxgagfa afag^aaxdxfgdagda";
@@ -316,7 +316,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no capital mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -328,14 +328,14 @@ public class TestADFGVX{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "AXGVDAVFXGAGFAAFAGAAXDXFGDAGDA";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "axgvdavfxgagfa afag aaxdxfgdagda";
@@ -343,7 +343,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "axgvdavfxgagfa*afag+aaxdxfgdagda-";
@@ -351,7 +351,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "message*to+encode-";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "AXgvdavfxgagfa afag^aaxdxfgdagda";
@@ -359,7 +359,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "Messageto^encode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no whitespace mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -371,14 +371,14 @@ public class TestADFGVX{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "AXGVDAVFXGAGFAAFAGAAXDXFGDAGDA";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "axgvdavfxgagfa afag aaxdxfgdagda";
@@ -386,7 +386,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "axgvdavfxgagfa*afag+aaxdxfgdagda-";
@@ -394,7 +394,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "AXgvdavfxgagfa afag^aaxdxfgdagda";
@@ -402,7 +402,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "Message toencode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed no symbol mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -414,14 +414,14 @@ public class TestADFGVX{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "AXGVDAVFXGAGFAAFAGAAXDXFGDAGDA";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "axgvdavfxgagfa afag aaxdxfgdagda";
@@ -429,7 +429,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "axgvdavfxgagfa*afag+aaxdxfgdagda-";
@@ -437,7 +437,7 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "AXgvdavfxgagfa afag^aaxdxfgdagda";
@@ -445,6 +445,6 @@ public class TestADFGVX{
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGVX failed secure mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

106
src/test/java/com/mattrixwv/cipherstream/combination/TestADFGX.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamjava/combination/TestADFGX.java
//Mattrixwv
// Created: 01-25-22
//Modified: 01-25-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.combination;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
@@ -25,14 +25,14 @@ public class TestADFGX{
String keyword = "keyword";
String correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
String output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -40,7 +40,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "aagagadfagaxxd axdx adafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -48,7 +48,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "aagagadfagaxxd*axdx+adafafxddgdf-";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
@@ -56,7 +56,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "AAgagadfagaxxd axdx^adafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed mixed case, whitesapce, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -68,14 +68,14 @@ public class TestADFGX{
String keyword = "keyword";
String correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
String output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -83,7 +83,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXD AXDX ADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -91,7 +91,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXD*AXDX+ADAFAFXDDGDF-";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
@@ -99,7 +99,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXD AXDX^ADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital mixed case, whitesapce, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -111,14 +111,14 @@ public class TestADFGX{
String keyword = "keyword";
String correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
String output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -126,7 +126,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -134,7 +134,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "aagagadfagaxxd*axdx+adafafxddgdf-";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
@@ -142,7 +142,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "AAgagadfagaxxdaxdx^adafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace mixed case, whitesapce, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -154,14 +154,14 @@ public class TestADFGX{
String keyword = "keyword";
String correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
String output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -169,7 +169,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "aagagadfagaxxd axdx adafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -177,7 +177,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
@@ -185,7 +185,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "AAgagadfagaxxd axdxadafafxddgdf";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol mixed case, whitesapce, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -197,14 +197,14 @@ public class TestADFGX{
String keyword = "keyword";
String correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
String output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -212,7 +212,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -220,7 +220,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
@@ -228,7 +228,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
output = cipher.encode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed mixed case, whitesapce, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -242,14 +242,14 @@ public class TestADFGX{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "aagagadfagaxxd axdx adafafxddgdf";
@@ -257,7 +257,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "aagagadfagaxxd*axdx+adafafxddgdf-";
@@ -265,7 +265,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "message*to+encode-";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "AAgagadfagaxxd axdx^adafafxddgdf";
@@ -273,7 +273,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "Message to^encode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed mixed case, whitesapce, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -285,14 +285,14 @@ public class TestADFGX{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "aagagadfagaxxd axdx adafafxddgdf";
@@ -300,7 +300,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "aagagadfagaxxd*axdx+adafafxddgdf-";
@@ -308,7 +308,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "MESSAGE*TO+ENCODE-";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "AAgagadfagaxxd axdx^adafafxddgdf";
@@ -316,7 +316,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no capital mixed case, whitesapce, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -328,14 +328,14 @@ public class TestADFGX{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "aagagadfagaxxd axdx adafafxddgdf";
@@ -343,7 +343,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "aagagadfagaxxd*axdx+adafafxddgdf-";
@@ -351,7 +351,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "message*to+encode-";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "AAgagadfagaxxd axdx^adafafxddgdf";
@@ -359,7 +359,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "Messageto^encode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no whitespace mixed case, whitesapce, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -371,14 +371,14 @@ public class TestADFGX{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "aagagadfagaxxd axdx adafafxddgdf";
@@ -386,7 +386,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "aagagadfagaxxd*axdx+adafafxddgdf-";
@@ -394,7 +394,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "AAgagadfagaxxd axdx^adafafxddgdf";
@@ -402,7 +402,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "Message toencode";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed no symbol mixed case, whitesapce, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -414,14 +414,14 @@ public class TestADFGX{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
squareKeyword = "SquareKeyword";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "aagagadfagaxxd axdx adafafxddgdf";
@@ -429,7 +429,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "aagagadfagaxxd*axdx+adafafxddgdf-";
@@ -437,7 +437,7 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "AAgagadfagaxxd axdx^adafafxddgdf";
@@ -445,6 +445,6 @@ public class TestADFGX{
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(squareKeyword, keyword, inputString);
assertEquals("ADFGX failed secure mixed case, whitesapce, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

106
src/test/java/com/mattrixwv/cipherstream/monosubstitution/TestAffine.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/polySubstitution/TestAffine.java
//Mattrixwv
// Created: 01-26-22
//Modified: 01-26-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.monosubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
@@ -24,14 +24,14 @@ public class TestAffine{
int key2 = 7;
String correctOutput = "pbtthlbyzburzwb";
String output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key1 = 5;
key2 = 7;
correctOutput = "PBTTHLBYZBURZWB";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -39,7 +39,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlb yz burzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -47,7 +47,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlb*yz+burzwb-";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
@@ -55,7 +55,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "Pbtthlb yz^burzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalEncode() throws InvalidKeywordException, InvalidInputException{
@@ -67,14 +67,14 @@ public class TestAffine{
int key2 = 7;
String correctOutput = "pbtthlbyzburzwb";
String output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key1 = 5;
key2 = 7;
correctOutput = "pbtthlbyzburzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -82,7 +82,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlb yz burzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -90,7 +90,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlb*yz+burzwb-";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
@@ -98,7 +98,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlb yz^burzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no capital mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceEncode() throws InvalidKeywordException, InvalidInputException{
@@ -110,14 +110,14 @@ public class TestAffine{
int key2 = 7;
String correctOutput = "pbtthlbyzburzwb";
String output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key1 = 5;
key2 = 7;
correctOutput = "PBTTHLBYZBURZWB";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -125,7 +125,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlbyzburzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -133,7 +133,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlb*yz+burzwb-";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
@@ -141,7 +141,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "Pbtthlbyz^burzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no whitespace mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolEncode() throws InvalidKeywordException, InvalidInputException{
@@ -153,14 +153,14 @@ public class TestAffine{
int key2 = 7;
String correctOutput = "pbtthlbyzburzwb";
String output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key1 = 5;
key2 = 7;
correctOutput = "PBTTHLBYZBURZWB";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -168,7 +168,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlb yz burzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -176,7 +176,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlbyzburzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
@@ -184,7 +184,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "Pbtthlb yzburzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed no symbol mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidKeywordException, InvalidInputException{
@@ -196,14 +196,14 @@ public class TestAffine{
int key2 = 7;
String correctOutput = "pbtthlbyzburzwb";
String output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key1 = 5;
key2 = 7;
correctOutput = "pbtthlbyzburzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
@@ -211,7 +211,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlbyzburzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode-";
@@ -219,7 +219,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlbyzburzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
@@ -227,7 +227,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "pbtthlbyzburzwb";
output = cipher.encode(key1, key2, inputString);
assertEquals("Affine failed secure mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -241,14 +241,14 @@ public class TestAffine{
int key2 = 7;
String correctOutput = "messagetoencode";
String output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppsercase decoding
inputString = "PBTTHLBYZBURZWB";
key1 = 5;
key2 = 7;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "pbtthlb yz burzwb";
@@ -256,7 +256,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "message to encode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "pbtthlb*yz+burzwb-";
@@ -264,7 +264,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "message*to+encode-";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Pbtthlb yz^burzwb";
@@ -272,7 +272,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "Message to^encode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalDecode() throws InvalidKeywordException, InvalidInputException{
@@ -284,14 +284,14 @@ public class TestAffine{
int key2 = 7;
String correctOutput = "messagetoencode";
String output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppsercase decoding
inputString = "PBTTHLBYZBURZWB";
key1 = 5;
key2 = 7;
correctOutput = "messagetoencode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "pbtthlb yz burzwb";
@@ -299,7 +299,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "message to encode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "pbtthlb*yz+burzwb-";
@@ -307,7 +307,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "message*to+encode-";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Pbtthlb yz^burzwb";
@@ -315,7 +315,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "message to^encode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no capital mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceDecode() throws InvalidKeywordException, InvalidInputException{
@@ -327,14 +327,14 @@ public class TestAffine{
int key2 = 7;
String correctOutput = "messagetoencode";
String output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppsercase decoding
inputString = "PBTTHLBYZBURZWB";
key1 = 5;
key2 = 7;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "pbtthlb yz burzwb";
@@ -342,7 +342,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "messagetoencode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "pbtthlb*yz+burzwb-";
@@ -350,7 +350,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "message*to+encode-";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Pbtthlb yz^burzwb";
@@ -358,7 +358,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "Messageto^encode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no whitespace mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolDecode() throws InvalidKeywordException, InvalidInputException{
@@ -370,14 +370,14 @@ public class TestAffine{
int key2 = 7;
String correctOutput = "messagetoencode";
String output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppsercase decoding
inputString = "PBTTHLBYZBURZWB";
key1 = 5;
key2 = 7;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "pbtthlb yz burzwb";
@@ -385,7 +385,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "message to encode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "pbtthlb*yz+burzwb-";
@@ -393,7 +393,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "messagetoencode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Pbtthlb yz^burzwb";
@@ -401,7 +401,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "Message toencode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed no symbol mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidKeywordException, InvalidInputException{
@@ -413,14 +413,14 @@ public class TestAffine{
int key2 = 7;
String correctOutput = "messagetoencode";
String output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppsercase decoding
inputString = "PBTTHLBYZBURZWB";
key1 = 5;
key2 = 7;
correctOutput = "messagetoencode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "pbtthlb yz burzwb";
@@ -428,7 +428,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "messagetoencode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "pbtthlb*yz+burzwb-";
@@ -436,7 +436,7 @@ public class TestAffine{
key2 = 7;
correctOutput = "messagetoencode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Pbtthlb yz^burzwb";
@@ -444,6 +444,6 @@ public class TestAffine{
key2 = 7;
correctOutput = "messagetoencode";
output = cipher.decode(key1, key2, inputString);
assertEquals("Affine failed secure mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

106
src/test/java/com/mattrixwv/cipherstream/monosubstitution/TestAtbash.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestAtbash.java
//Mattrixwv
// Created: 07-25-21
//Modified: 02-22-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.monosubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
@@ -21,30 +21,30 @@ public class TestAtbash{
String inputString = "messagetoencode";
String correctOutput = "nvhhztvglvmxlwv";
String output = cipher.encode(inputString);
assertEquals("Atbash failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
correctOutput = "NVHHZTVGLVMXLWV";
output = cipher.encode(inputString);
assertEquals("Atbash failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
correctOutput = "nvhhztv gl vmxlwv";
output = cipher.encode(inputString);
assertEquals("Atbash failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
correctOutput = "nvhhztv*gl+vmxlwv";
output = cipher.encode(inputString);
assertEquals("Atbash failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
correctOutput = "Nvhhztv gl^vmxlwv";
output = cipher.encode(inputString);
assertEquals("Atbash failed mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -55,30 +55,30 @@ public class TestAtbash{
String inputString = "messagetoencode";
String correctOutput = "NVHHZTVGLVMXLWV";
String output = cipher.encode(inputString);
assertEquals("Atbash failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
correctOutput = "NVHHZTVGLVMXLWV";
output = cipher.encode(inputString);
assertEquals("Atbash failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
correctOutput = "NVHHZTV GL VMXLWV";
output = cipher.encode(inputString);
assertEquals("Atbash failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
correctOutput = "NVHHZTV*GL+VMXLWV";
output = cipher.encode(inputString);
assertEquals("Atbash failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
correctOutput = "NVHHZTV GL^VMXLWV";
output = cipher.encode(inputString);
assertEquals("Atbash failed no capital mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -89,30 +89,30 @@ public class TestAtbash{
String inputString = "messagetoencode";
String correctOutput = "nvhhztvglvmxlwv";
String output = cipher.encode(inputString);
assertEquals("Atbash failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
correctOutput = "NVHHZTVGLVMXLWV";
output = cipher.encode(inputString);
assertEquals("Atbash failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
correctOutput = "nvhhztvglvmxlwv";
output = cipher.encode(inputString);
assertEquals("Atbash failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
correctOutput = "nvhhztv*gl+vmxlwv";
output = cipher.encode(inputString);
assertEquals("Atbash failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
correctOutput = "Nvhhztvgl^vmxlwv";
output = cipher.encode(inputString);
assertEquals("Atbash failed no whitespace mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -123,30 +123,30 @@ public class TestAtbash{
String inputString = "messagetoencode";
String correctOutput = "nvhhztvglvmxlwv";
String output = cipher.encode(inputString);
assertEquals("Atbash failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
correctOutput = "NVHHZTVGLVMXLWV";
output = cipher.encode(inputString);
assertEquals("Atbash failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
correctOutput = "nvhhztv gl vmxlwv";
output = cipher.encode(inputString);
assertEquals("Atbash failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
correctOutput = "nvhhztvglvmxlwv";
output = cipher.encode(inputString);
assertEquals("Atbash failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
correctOutput = "Nvhhztv glvmxlwv";
output = cipher.encode(inputString);
assertEquals("Atbash failed no symbol mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -157,30 +157,30 @@ public class TestAtbash{
String inputString = "messagetoencode";
String correctOutput = "NVHHZTVGLVMXLWV";
String output = cipher.encode(inputString);
assertEquals("Atbash failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
correctOutput = "NVHHZTVGLVMXLWV";
output = cipher.encode(inputString);
assertEquals("Atbash failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
correctOutput = "NVHHZTVGLVMXLWV";
output = cipher.encode(inputString);
assertEquals("Atbash failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
correctOutput = "NVHHZTVGLVMXLWV";
output = cipher.encode(inputString);
assertEquals("Atbash failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
correctOutput = "NVHHZTVGLVMXLWV";
output = cipher.encode(inputString);
assertEquals("Atbash failed secure mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -192,30 +192,30 @@ public class TestAtbash{
String inputString = "nvhhztvglvmxlwv";
String correctOutput = "messagetoencode";
String output = cipher.encode(inputString);
assertEquals("Atbash failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "NVHHZTVGLVMXLWV";
correctOutput = "MESSAGETOENCODE";
output = cipher.encode(inputString);
assertEquals("Atbash failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "nvhhztv gl vmxlwv";
correctOutput = "message to encode";
output = cipher.encode(inputString);
assertEquals("Atbash failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "nvhhztv*gl+vmxlwv";
correctOutput = "message*to+encode";
output = cipher.encode(inputString);
assertEquals("Atbash failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "Nvhhztv gl^vmxlwv";
correctOutput = "Message to^encode";
output = cipher.encode(inputString);
assertEquals("Atbash failed mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -226,30 +226,30 @@ public class TestAtbash{
String inputString = "nvhhztvglvmxlwv";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.encode(inputString);
assertEquals("Atbash failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "NVHHZTVGLVMXLWV";
correctOutput = "MESSAGETOENCODE";
output = cipher.encode(inputString);
assertEquals("Atbash failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "nvhhztv gl vmxlwv";
correctOutput = "MESSAGE TO ENCODE";
output = cipher.encode(inputString);
assertEquals("Atbash failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "nvhhztv*gl+vmxlwv";
correctOutput = "MESSAGE*TO+ENCODE";
output = cipher.encode(inputString);
assertEquals("Atbash failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "Nvhhztv gl^vmxlwv";
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.encode(inputString);
assertEquals("Atbash failed no capital mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -260,30 +260,30 @@ public class TestAtbash{
String inputString = "nvhhztvglvmxlwv";
String correctOutput = "messagetoencode";
String output = cipher.encode(inputString);
assertEquals("Atbash failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "NVHHZTVGLVMXLWV";
correctOutput = "MESSAGETOENCODE";
output = cipher.encode(inputString);
assertEquals("Atbash failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "nvhhztv gl vmxlwv";
correctOutput = "messagetoencode";
output = cipher.encode(inputString);
assertEquals("Atbash failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "nvhhztv*gl+vmxlwv";
correctOutput = "message*to+encode";
output = cipher.encode(inputString);
assertEquals("Atbash failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "Nvhhztv gl^vmxlwv";
correctOutput = "Messageto^encode";
output = cipher.encode(inputString);
assertEquals("Atbash failed no whitespace mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -294,30 +294,30 @@ public class TestAtbash{
String inputString = "nvhhztvglvmxlwv";
String correctOutput = "messagetoencode";
String output = cipher.encode(inputString);
assertEquals("Atbash failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "NVHHZTVGLVMXLWV";
correctOutput = "MESSAGETOENCODE";
output = cipher.encode(inputString);
assertEquals("Atbash failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "nvhhztv gl vmxlwv";
correctOutput = "message to encode";
output = cipher.encode(inputString);
assertEquals("Atbash failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "nvhhztv*gl+vmxlwv";
correctOutput = "messagetoencode";
output = cipher.encode(inputString);
assertEquals("Atbash failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "Nvhhztv gl^vmxlwv";
correctOutput = "Message toencode";
output = cipher.encode(inputString);
assertEquals("Atbash failed no symbol mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -328,29 +328,29 @@ public class TestAtbash{
String inputString = "nvhhztvglvmxlwv";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.encode(inputString);
assertEquals("Atbash failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "NVHHZTVGLVMXLWV";
correctOutput = "MESSAGETOENCODE";
output = cipher.encode(inputString);
assertEquals("Atbash failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "nvhhztv gl vmxlwv";
correctOutput = "MESSAGETOENCODE";
output = cipher.encode(inputString);
assertEquals("Atbash failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "nvhhztv*gl+vmxlwv";
correctOutput = "MESSAGETOENCODE";
output = cipher.encode(inputString);
assertEquals("Atbash failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "Nvhhztv gl^vmxlwv";
correctOutput = "MESSAGETOENCODE";
output = cipher.encode(inputString);
assertEquals("Atbash failed secure mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

114
src/test/java/com/mattrixwv/cipherstream/monosubstitution/TestAutokey.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestAutokey.java
//Mattrixwv
// Created: 07-26-21
//Modified: 02-22-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.monosubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
@@ -23,34 +23,34 @@ public class TestAutokey{
String keyword = "keyword";
String correctOutput = "wiqooxhfswfcuhx";
String output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "WIQOOXHFSWFCUHX";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "wiqooxh fs wfcuhx";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "wiqooxh*fs+wfcuhx";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Wiqooxh fs^wfcuhx";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -62,34 +62,34 @@ public class TestAutokey{
String keyword = "keyword";
String correctOutput = "WIQOOXHFSWFCUHX";
String output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "WIQOOXHFSWFCUHX";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "WIQOOXH FS WFCUHX";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "WIQOOXH*FS+WFCUHX";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "WIQOOXH FS^WFCUHX";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no capital mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -101,34 +101,34 @@ public class TestAutokey{
String keyword = "keyword";
String correctOutput = "wiqooxhfswfcuhx";
String output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "WIQOOXHFSWFCUHX";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "wiqooxhfswfcuhx";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "wiqooxh*fs+wfcuhx";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Wiqooxhfs^wfcuhx";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no whitespace mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -140,34 +140,34 @@ public class TestAutokey{
String keyword = "keyword";
String correctOutput = "wiqooxhfswfcuhx";
String output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "WIQOOXHFSWFCUHX";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "wiqooxh fs wfcuhx";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "wiqooxhfswfcuhx";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Wiqooxh fswfcuhx";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed no symbol mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -179,34 +179,34 @@ public class TestAutokey{
String keyword = "keyword";
String correctOutput = "WIQOOXHFSWFCUHX";
String output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "WIQOOXHFSWFCUHX";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "WIQOOXHFSWFCUHX";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "WIQOOXHFSWFCUHX";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "WIQOOXHFSWFCUHX";
output = cipher.encode(keyword, inputString);
assertEquals("Autokey failed secure mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -219,34 +219,34 @@ public class TestAutokey{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHFSWFCUHX";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh fs wfcuhx";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*fs+wfcuhx";
keyword = "keyword";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Wiqooxh fs^wfcuhx";
keyword = "keyword";
correctOutput = "Message to^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -258,34 +258,34 @@ public class TestAutokey{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHFSWFCUHX";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "WIQOOXH FS WFCUHX";
keyword = "keyword";
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "WIQOOXH*FS+WFCUHX";
keyword = "keyword";
correctOutput = "MESSAGE*TO+ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "WIQOOXH FS^WFCUHX";
keyword = "keyword";
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no capital mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -297,34 +297,34 @@ public class TestAutokey{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHFSWFCUHX";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh fs wfcuhx";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*fs+wfcuhx";
keyword = "keyword";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Wiqooxh fs^wfcuhx";
keyword = "keyword";
correctOutput = "Messageto^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no whitespace mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -336,34 +336,34 @@ public class TestAutokey{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHFSWFCUHX";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh fs wfcuhx";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*fs+wfcuhx";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Wiqooxh fs^wfcuhx";
keyword = "keyword";
correctOutput = "Message toencode";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed no symbol mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -375,34 +375,34 @@ public class TestAutokey{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHFSWFCUHX";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "WIQOOXH FS WFCUHX";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "WIQOOXH*FS+WFCUHX";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "WIQOOXH FS^WFCUHX";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Autokey failed secure mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -415,7 +415,7 @@ public class TestAutokey{
String correctOutput = "XYZ";
cipher.setKeyword(keyword);
String output = cipher.getKeyword();
assertEquals("Autokey failed keyword with whitespace.", correctOutput, output);
assertEquals(correctOutput, output);
//Test keyword with symbol
@@ -423,7 +423,7 @@ public class TestAutokey{
correctOutput = "XYZ";
cipher.setKeyword(keyword);
output = cipher.getKeyword();
assertEquals("Autokey failed keyword with symbol.", correctOutput, output);
assertEquals(correctOutput, output);
//Test keyword with mixed case
@@ -431,13 +431,13 @@ public class TestAutokey{
correctOutput = "XYZ";
cipher.setKeyword(keyword);
output = cipher.getKeyword();
assertEquals("Autokey failed keyword with mixed case.", correctOutput, output);
assertEquals(correctOutput, output);
//Test keyword with whitespace, symbol and keyword
keyword = "x Y%z ";
correctOutput = "XYZ";
cipher.setKeyword(keyword);
output = cipher.getKeyword();
assertEquals("Autokey failed keyword with space, symbol, and mixed case.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

30
src/test/java/com/mattrixwv/cipherstream/monosubstitution/TestBaconian.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/TestBaconian.java
//Mattrixwv
// Created: 01-12-22
//Modified: 01-12-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.monosubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
@@ -22,18 +22,18 @@ public class TestBaconian{
String inputString = "messagetoencode";
String correctOutput = "ababb aabaa baaab baaab aaaaa aabba aabaa baaba abbab aabaa abbaa aaaba abbab aaabb aabaa";
String output = cipher.encode(inputString);
assertEquals("Baconian failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
correctOutput = "ABABB AABAA BAAAB BAAAB AAAAA AABBA AABAA BAABA ABBAB AABAA ABBAA AAABA ABBAB AAABB AABAA";
output = cipher.encode(inputString);
assertEquals("Baconian failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to-encode";
correctOutput = "ABABB aabaa baaab baaab aaaaa aabba aabaa baaba abbab aabaa abbaa aaaba abbab aaabb aabaa";
output = cipher.encode(inputString);
assertEquals("Baconian failed mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testEncodeNoCapital() throws InvalidInputException{
@@ -43,18 +43,18 @@ public class TestBaconian{
String inputString = "messagetoencode";
String correctOutput = "ababb aabaa baaab baaab aaaaa aabba aabaa baaba abbab aabaa abbaa aaaba abbab aaabb aabaa";
String output = cipher.encode(inputString);
assertEquals("Baconian failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
correctOutput = "ababb aabaa baaab baaab aaaaa aabba aabaa baaba abbab aabaa abbaa aaaba abbab aaabb aabaa";
output = cipher.encode(inputString);
assertEquals("Baconian failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to-encode";
correctOutput = "ababb aabaa baaab baaab aaaaa aabba aabaa baaba abbab aabaa abbaa aaaba abbab aaabb aabaa";
output = cipher.encode(inputString);
assertEquals("Baconian failed no capital mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -66,18 +66,18 @@ public class TestBaconian{
String inputString = "ababb aabaa baaab baaab aaaaa aabba aabaa baaba abbab aabaa abbaa aaaba abbab aaabb aabaa";
String correctOutput = "messagetoencode";
String output = cipher.decode(inputString);
assertEquals("Baconian failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "ABABB AABAA BAAAB BAAAB AAAAA AABBA AABAA BAABA ABBAB AABAA ABBAA AAABA ABBAB AAABB AABAA";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(inputString);
assertEquals("Baconian failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "ABABB aabaa baaab baaab aaaaa aabba aabaa baaba abbab aabaa abbaa aaaba abbab aaabb aabaa";
correctOutput = "Messagetoencode";
output = cipher.decode(inputString);
assertEquals("Baconian failed mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testDecodeNoCapital() throws InvalidCharacterException, InvalidInputException{
@@ -87,17 +87,17 @@ public class TestBaconian{
String inputString = "ababb aabaa baaab baaab aaaaa aabba aabaa baaba abbab aabaa abbaa aaaba abbab aaabb aabaa";
String correctOutput = "messagetoencode";
String output = cipher.decode(inputString);
assertEquals("Baconian failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "ABABB AABAA BAAAB BAAAB AAAAA AABBA AABAA BAABA ABBAB AABAA ABBAA AAABA ABBAB AAABB AABAA";
correctOutput = "messagetoencode";
output = cipher.decode(inputString);
assertEquals("Baconian failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "ABABB aabaa baaab baaab aaaaa aabba aabaa baaba abbab aabaa abbaa aaaba abbab aaabb aabaa";
correctOutput = "messagetoencode";
output = cipher.decode(inputString);
assertEquals("Baconian failed no capital mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

86
src/test/java/com/mattrixwv/cipherstream/monosubstitution/TestBaseX.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestBaseX.java
//Mattrixwv
// Created: 01-08-22
//Modified: 01-09-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.monosubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidBaseException;
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
@@ -23,30 +23,30 @@ public class TestBaseX{
String inputString = "a";
String correctOutput = "1100001";
String output = cipher.encode(inputString);
assertEquals("Binary failed binary lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "A";
correctOutput = "1000001";
output = cipher.encode(inputString);
assertEquals("Binary failed binary uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "A B\tC\n";
correctOutput = "1000001 100000 1000010 1001 1000011 1010";
output = cipher.encode(inputString);
assertEquals("Binary failed binary whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "A@B-C+";
correctOutput = "1000001 1000000 1000010 101101 1000011 101011";
output = cipher.encode(inputString);
assertEquals("Binary failed binary symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "A+B@C d\te\nf";
correctOutput = "1000001 101011 1000010 1000000 1000011 100000 1100100 1001 1100101 1010 1100110";
output = cipher.encode(inputString);
assertEquals("Binary failed binary mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testOctalEncode() throws InvalidBaseException, InvalidInputException{
@@ -56,30 +56,30 @@ public class TestBaseX{
String inputString = "a";
String correctOutput = "141";
String output = cipher.encode(inputString);
assertEquals("Binary failed octal lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "A";
correctOutput = "101";
output = cipher.encode(inputString);
assertEquals("Binary failed octal uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "A B\tC\n";
correctOutput = "101 40 102 11 103 12";
output = cipher.encode(inputString);
assertEquals("Binary failed octal whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "A@B-C+";
correctOutput = "101 100 102 55 103 53";
output = cipher.encode(inputString);
assertEquals("Binary failed octal symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "A+B@C d\te\nf";
correctOutput = "101 53 102 100 103 40 144 11 145 12 146";
output = cipher.encode(inputString);
assertEquals("Binary failed octal mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testDecimalEncode() throws InvalidBaseException, InvalidInputException{
@@ -89,30 +89,30 @@ public class TestBaseX{
String inputString = "a";
String correctOutput = "97";
String output = cipher.encode(inputString);
assertEquals("Binary failed decimal lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "A";
correctOutput = "65";
output = cipher.encode(inputString);
assertEquals("Binary failed decimal uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "A B\tC\n";
correctOutput = "65 32 66 9 67 10";
output = cipher.encode(inputString);
assertEquals("Binary failed decimal whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "A@B-C+";
correctOutput = "65 64 66 45 67 43";
output = cipher.encode(inputString);
assertEquals("Binary failed decimal symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "A+B@C d\te\nf";
correctOutput = "65 43 66 64 67 32 100 9 101 10 102";
output = cipher.encode(inputString);
assertEquals("Binary failed decimal mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testHexEncode() throws InvalidBaseException, InvalidInputException{
@@ -122,30 +122,30 @@ public class TestBaseX{
String correctOutput = "61";
String inputString = "a";
String output = cipher.encode(inputString);
assertEquals("Binary failed hex lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "A";
correctOutput = "41";
output = cipher.encode(inputString);
assertEquals("Binary failed hex uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "A B\tC\n";
correctOutput = "41 20 42 9 43 A";
output = cipher.encode(inputString);
assertEquals("Binary failed hex whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "A@B-C+";
correctOutput = "41 40 42 2D 43 2B";
output = cipher.encode(inputString);
assertEquals("Binary failed hex symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "A+B@C d\te\nf";
correctOutput = "41 2B 42 40 43 20 64 9 65 A 66";
output = cipher.encode(inputString);
assertEquals("Binary failed hex mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -157,30 +157,30 @@ public class TestBaseX{
String inputString = "1100001";
String correctOutput = "a";
String output = cipher.decode(inputString);
assertEquals("Binary failed binary lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "1000001";
correctOutput = "A";
output = cipher.decode(inputString);
assertEquals("Binary failed binary uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "1000001 100000 1000010 1001 1000011 1010";
correctOutput = "A B\tC\n";
output = cipher.decode(inputString);
assertEquals("Binary failed binary whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "1000001 1000000 1000010 101101 1000011 101011";
correctOutput = "A@B-C+";
output = cipher.decode(inputString);
assertEquals("Binary failed binary symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "1000001 101011 1000010 1000000 1000011 100000 1100100 1001 1100101 1010 1100110";
correctOutput = "A+B@C d\te\nf";
output = cipher.decode(inputString);
assertEquals("Binary failed binary mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testOctalDecode() throws InvalidCharacterException, InvalidBaseException, InvalidInputException{
@@ -190,30 +190,30 @@ public class TestBaseX{
String inputString = "141";
String correctOutput = "a";
String output = cipher.decode(inputString);
assertEquals("Binary failed octal lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "101";
correctOutput = "A";
output = cipher.decode(inputString);
assertEquals("Binary failed octal uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "101 40 102 11 103 12";
correctOutput = "A B\tC\n";
output = cipher.decode(inputString);
assertEquals("Binary failed octal whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "101 100 102 55 103 53";
correctOutput = "A@B-C+";
output = cipher.decode(inputString);
assertEquals("Binary failed octal symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "101 53 102 100 103 40 144 11 145 12 146";
correctOutput = "A+B@C d\te\nf";
output = cipher.decode(inputString);
assertEquals("Binary failed octal mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testDecimalDecode() throws InvalidCharacterException, InvalidBaseException, InvalidInputException{
@@ -223,30 +223,30 @@ public class TestBaseX{
String inputString = "97";
String correctOutput = "a";
String output = cipher.decode(inputString);
assertEquals("Binary failed decimal lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "65";
correctOutput = "A";
output = cipher.decode(inputString);
assertEquals("Binary failed decimal uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "65 32 66 9 67 10";
correctOutput = "A B\tC\n";
output = cipher.decode(inputString);
assertEquals("Binary failed decimal whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "65 64 66 45 67 43";
correctOutput = "A@B-C+";
output = cipher.decode(inputString);
assertEquals("Binary failed decimal symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "65 43 66 64 67 32 100 9 101 10 102";
correctOutput = "A+B@C d\te\nf";
output = cipher.decode(inputString);
assertEquals("Binary failed decimal mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testHexDecode() throws InvalidCharacterException, InvalidBaseException, InvalidInputException{
@@ -256,29 +256,29 @@ public class TestBaseX{
String inputString = "61";
String correctOutput = "a";
String output = cipher.decode(inputString);
assertEquals("Binary failed hex lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "41";
correctOutput = "A";
output = cipher.decode(inputString);
assertEquals("Binary failed hex uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "41 20 42 9 43 A";
correctOutput = "A B\tC\n";
output = cipher.decode(inputString);
assertEquals("Binary failed hex whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "41 40 42 2D 43 2B";
correctOutput = "A@B-C+";
output = cipher.decode(inputString);
assertEquals("Binary failed hex symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "41 2B 42 40 43 20 64 9 65 A 66";
correctOutput = "A+B@C d\te\nf";
output = cipher.decode(inputString);
assertEquals("Binary failed hex mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

106
src/test/java/com/mattrixwv/cipherstream/monosubstitution/TestBeaufort.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestBeaufort.java
//Mattrixwv
// Created: 02-23-22
//Modified: 02-23-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.monosubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
@@ -23,34 +23,34 @@ public class TestBeaufort{
String keyword = "keyword";
String correctOutput = "yageolzrqujmdag";
String output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "YAGEOLZRQUJMDAG";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "yageolz rq ujmdag";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "yageolz*rq+ujmdag";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Yageolz rq^ujmdag";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -62,34 +62,34 @@ public class TestBeaufort{
String keyword = "keyword";
String correctOutput = "YAGEOLZRQUJMDAG";
String output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "YAGEOLZRQUJMDAG";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "YAGEOLZ RQ UJMDAG";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "YAGEOLZ*RQ+UJMDAG";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "YAGEOLZ RQ^UJMDAG";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no capital mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -101,34 +101,34 @@ public class TestBeaufort{
String keyword = "keyword";
String correctOutput = "yageolzrqujmdag";
String output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "YAGEOLZRQUJMDAG";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "yageolzrqujmdag";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "yageolz*rq+ujmdag";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Yageolzrq^ujmdag";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no whitespace mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -140,34 +140,34 @@ public class TestBeaufort{
String keyword = "keyword";
String correctOutput = "yageolzrqujmdag";
String output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "YAGEOLZRQUJMDAG";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "yageolz rq ujmdag";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "yageolzrqujmdag";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Yageolz rqujmdag";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed no symbol mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -179,34 +179,34 @@ public class TestBeaufort{
String keyword = "keyword";
String correctOutput = "YAGEOLZRQUJMDAG";
String output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "YAGEOLZRQUJMDAG";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "YAGEOLZRQUJMDAG";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "YAGEOLZRQUJMDAG";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "YAGEOLZRQUJMDAG";
output = cipher.encode(keyword, inputString);
assertEquals("Beaufort failed secure mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -219,34 +219,34 @@ public class TestBeaufort{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "YAGEOLZRQUJMDAG";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "yageolz rq ujmdag";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "yageolz*rq+ujmdag";
keyword = "keyword";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Yageolz rq^ujmdag";
keyword = "keyword";
correctOutput = "Message to^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -258,34 +258,34 @@ public class TestBeaufort{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "YAGEOLZRQUJMDAG";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "yageolz rq ujmdag";
keyword = "keyword";
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "yageolz*rq+ujmdag";
keyword = "keyword";
correctOutput = "MESSAGE*TO+ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Yageolz rq^ujmdag";
keyword = "keyword";
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no capital mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -297,34 +297,34 @@ public class TestBeaufort{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "YAGEOLZRQUJMDAG";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "yageolz rq ujmdag";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "yageolz*rq+ujmdag";
keyword = "keyword";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Yageolz rq^ujmdag";
keyword = "keyword";
correctOutput = "Messageto^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no whitespace mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -336,34 +336,34 @@ public class TestBeaufort{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "YAGEOLZRQUJMDAG";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "yageolz rq ujmdag";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "yageolz*rq+ujmdag";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Yageolz rq^ujmdag";
keyword = "keyword";
correctOutput = "Message toencode";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed no symbol mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -375,33 +375,33 @@ public class TestBeaufort{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "YAGEOLZRQUJMDAG";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "yageolz rq ujmdag";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "yageolz*rq+ujmdag";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Yageolz rq^ujmdag";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Beaufort failed secure mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

166
src/test/java/com/mattrixwv/cipherstream/monosubstitution/TestCaesar.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/TestCaesar.java
//Matthew Ellison
// Created: 07-25-21
//Modified: 01-04-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.monosubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
@@ -22,13 +22,13 @@ public class TestCaesar{
int shift = 3;
String correctOutput = "def";
String output = cipher.encode(shift, input);
assertEquals("Caesar failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
input = "ABC";
shift = 3;
correctOutput = "DEF";
output = cipher.encode(shift, input);
assertEquals("Ceasar failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift encoding
@@ -36,13 +36,13 @@ public class TestCaesar{
shift = 29;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Caesar failed out of bounds shift encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift encoding negative
input = "abc";
shift = -23;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Causar failed out of bounds shift negative encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
@@ -50,7 +50,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "def ghi";
output = cipher.encode(shift, input);
assertEquals("Caesar failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
@@ -58,7 +58,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "def-ghi@";
output = cipher.encode(shift, input);
assertEquals("Caesar failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
@@ -66,13 +66,13 @@ public class TestCaesar{
shift = 23;
correctOutput = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
output = cipher.encode(shift, input);
assertEquals("Caesar failed mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding with negative shift
input = "The quick brown fox jumps over - the lazy dog";
shift = -3;
correctOutput = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
output = cipher.encode(shift, input);
assertEquals("Caesar failed mixed case, whitespace, and symbol encoding with negative shift.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalEncode() throws InvalidInputException{
@@ -83,13 +83,13 @@ public class TestCaesar{
int shift = 3;
String correctOutput = "def";
String output = cipher.encode(shift, input);
assertEquals("Caesar failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
input = "ABC";
shift = 3;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Ceasar failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift encoding
@@ -97,13 +97,13 @@ public class TestCaesar{
shift = 29;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no capital out of bounds shift encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift encoding negative
input = "abc";
shift = -23;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no capital out of bounds shift negative encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
@@ -111,7 +111,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "def ghi";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
@@ -119,7 +119,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "def-ghi@";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
@@ -127,13 +127,13 @@ public class TestCaesar{
shift = 23;
correctOutput = "qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no capital mixed case, whitespace, and symbol ecoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding with negative shift
input = "The quick brown fox jumps over - the lazy dog";
shift = -3;
correctOutput = "qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no capital mixed case, whitespace, and symbol encoding with negative shift.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceEncode() throws InvalidInputException{
@@ -144,13 +144,13 @@ public class TestCaesar{
int shift = 3;
String correctOutput = "def";
String output = cipher.encode(shift, input);
assertEquals("Caesar failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
input = "ABC";
shift = 3;
correctOutput = "DEF";
output = cipher.encode(shift, input);
assertEquals("Ceasar failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift encoding
@@ -158,13 +158,13 @@ public class TestCaesar{
shift = 29;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no whitespace out of bounds shift encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift encoding negative
input = "abc";
shift = -23;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no whitespace out of bounds shift negative encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
@@ -172,7 +172,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "defghi";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
@@ -180,7 +180,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "def-ghi@";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Testing mixed case, whitespace, and symbol encoding
@@ -188,13 +188,13 @@ public class TestCaesar{
shift = 23;
correctOutput = "Qebnrfzhyoltkclugrjmplsbo-qebixwvald";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no whitespace mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Testing mixed case, whitespace, and symbol encoding
input = "The quick brown fox jumps over - the lazy dog";
shift = -3;
correctOutput = "Qebnrfzhyoltkclugrjmplsbo-qebixwvald";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no whitespace mixed case, whitespace, and symbol encoding with negative shift.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolEncode() throws InvalidInputException{
@@ -205,13 +205,13 @@ public class TestCaesar{
int shift = 3;
String correctOutput = "def";
String output = cipher.encode(shift, input);
assertEquals("Caesar failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
input = "ABC";
shift = 3;
correctOutput = "DEF";
output = cipher.encode(shift, input);
assertEquals("Ceasar failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift encoding
@@ -219,13 +219,13 @@ public class TestCaesar{
shift = 29;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no symbol out of bounds shift encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift encoding negative
input = "abc";
shift = -23;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no symbol out of bounds shift negative encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
@@ -233,7 +233,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "def ghi";
output = cipher.encode(shift, input);
assertEquals("Caesar failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
@@ -241,7 +241,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "defghi";
output = cipher.encode(shift, input);
assertEquals("Caesar failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
@@ -249,13 +249,13 @@ public class TestCaesar{
shift = 23;
correctOutput = "Qeb nrfzh yoltk clu grjmp lsbo qeb ixwv ald";
output = cipher.encode(shift, input);
assertEquals("Caesar failed mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//test mixed case, whitespace, and symbol encoding with negative shift
input = "The quick brown fox jumps over - the lazy dog";
shift = -3;
correctOutput = "Qeb nrfzh yoltk clu grjmp lsbo qeb ixwv ald";
output = cipher.encode(shift, input);
assertEquals("Caesar failed mixed case, whitespace, and symbol encoding with negative shift.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidInputException{
@@ -266,13 +266,13 @@ public class TestCaesar{
int shift = 3;
String correctOutput = "def";
String output = cipher.encode(shift, input);
assertEquals("Caesar failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
input = "ABC";
shift = 3;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Ceasar failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift encoding
@@ -280,13 +280,13 @@ public class TestCaesar{
shift = 29;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Caesar failed secure out of bounds shift encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift encoding negative
input = "abc";
shift = 29;
correctOutput = "def";
output = cipher.encode(shift, input);
assertEquals("Caesar failed secure out of bounds shift negative encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
@@ -294,7 +294,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "defghi";
output = cipher.encode(shift, input);
assertEquals("Caesar failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
@@ -302,7 +302,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "defghi";
output = cipher.encode(shift, input);
assertEquals("Caesar failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
@@ -310,13 +310,13 @@ public class TestCaesar{
shift = 23;
correctOutput = "qebnrfzhyoltkclugrjmplsboqebixwvald";
output = cipher.encode(shift, input);
assertEquals("Caesar failed secure mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding with negative shift
input = "The quick brown fox jumps over - the lazy dog";
shift = -3;
correctOutput = "qebnrfzhyoltkclugrjmplsboqebixwvald";
output = cipher.encode(shift, input);
assertEquals("Caesar failed secure mixed case, whitespace, and symbol encoding with negative shift.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -329,13 +329,13 @@ public class TestCaesar{
int shift = 3;
String correctOutput = "abc";
String output = cipher.decode(shift, input);
assertEquals("Caesar failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
input = "DEF";
shift = 3;
correctOutput = "ABC";
output = cipher.decode(shift, input);
assertEquals("Caesar failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift decoding
@@ -343,13 +343,13 @@ public class TestCaesar{
shift = 29;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed out of bounds shift decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift negative decoding
input = "def";
shift = -23;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed out of bounds shift negative decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
@@ -357,7 +357,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "abc def";
output = cipher.decode(shift, input);
assertEquals("Caesar failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
@@ -365,7 +365,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "abc-def@";
output = cipher.decode(shift, input);
assertEquals("Caesar failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
@@ -373,13 +373,13 @@ public class TestCaesar{
shift = 23;
correctOutput = "The quick brown fox jumps over - the lazy dog";
output = cipher.decode(shift, input);
assertEquals("Caesar failed mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding with negative shift
input = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
shift = -3;
correctOutput = "The quick brown fox jumps over - the lazy dog";
output = cipher.decode(shift, input);
assertEquals("Caesar failed mixed case, whitespace, and symbol decoding with negative shift.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalDecode() throws InvalidInputException{
@@ -390,13 +390,13 @@ public class TestCaesar{
int shift = 3;
String correctOutput = "abc";
String output = cipher.decode(shift, input);
assertEquals("Caesar failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
input = "DEF";
shift = 3;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift decoding
@@ -404,13 +404,13 @@ public class TestCaesar{
shift = 29;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no capital out of bounds shift decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift negative decoding
input = "def";
shift = -23;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no capital out of bounds shift negative decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
@@ -418,7 +418,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "abc def";
output = cipher.decode(shift, input);
assertEquals("Caesare failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
@@ -426,7 +426,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "abc-def@";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
@@ -434,13 +434,13 @@ public class TestCaesar{
shift = 23;
correctOutput = "the quick brown fox jumps over - the lazy dog";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no capital mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol with negative shift
input = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
shift = -3;
correctOutput = "the quick brown fox jumps over - the lazy dog";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no capital mixed case, whitespace, and symbol decoding with negative shift.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceDecode() throws InvalidInputException{
@@ -451,13 +451,13 @@ public class TestCaesar{
int shift = 3;
String correctOutput = "abc";
String output = cipher.decode(shift, input);
assertEquals("Caesar failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
input = "DEF";
shift = 3;
correctOutput = "ABC";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift decoding
@@ -465,13 +465,13 @@ public class TestCaesar{
shift = 29;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no whitespace out of bounds shift decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift negative decoding
input = "def";
shift = -23;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no whitespace out of bounds shift negative decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
@@ -479,7 +479,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "abcdef";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
@@ -487,7 +487,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "abc-def@";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
@@ -495,13 +495,13 @@ public class TestCaesar{
shift = 23;
correctOutput = "Thequickbrownfoxjumpsover-thelazydog";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no whitespace mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding with negative shift
input = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
shift = -3;
correctOutput = "Thequickbrownfoxjumpsover-thelazydog";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no whitespace mixed case, whitespace, and symbol decoding with negative shift.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolDecode() throws InvalidInputException{
@@ -512,13 +512,13 @@ public class TestCaesar{
int shift = 3;
String correctOutput = "abc";
String output = cipher.decode(shift, input);
assertEquals("Caesar failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
input = "DEF";
shift = 3;
correctOutput = "ABC";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift decoding
@@ -526,13 +526,13 @@ public class TestCaesar{
shift = 29;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no symbol out of bounds shift decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift negative decoding
input = "def";
shift = -23;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no symbol out of bounds shift negative decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitepace decoding
@@ -540,7 +540,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "abc def";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
@@ -548,7 +548,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "abcdef";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
@@ -556,13 +556,13 @@ public class TestCaesar{
shift = 23;
correctOutput = "The quick brown fox jumps over the lazy dog";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no symbol mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding with negative shift
input = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
shift = -3;
correctOutput = "The quick brown fox jumps over the lazy dog";
output = cipher.decode(shift, input);
assertEquals("Caesar failed no symbol mixed case, whitespace, and symbol decoding with negative shift.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidInputException{
@@ -573,13 +573,13 @@ public class TestCaesar{
int shift = 3;
String correctOutput = "abc";
String output = cipher.decode(shift, input);
assertEquals("Caesar failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
input = "DEF";
shift = 3;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift decoding
@@ -587,13 +587,13 @@ public class TestCaesar{
shift = 29;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed secure out of bounds shift decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test out of bounds shift negative decoding
input = "def";
shift = -23;
correctOutput = "abc";
output = cipher.decode(shift, input);
assertEquals("Caesar failed secure out of bounds shift negative decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
@@ -601,7 +601,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "abcdef";
output = cipher.decode(shift, input);
assertEquals("Caesar failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
@@ -609,7 +609,7 @@ public class TestCaesar{
shift = 3;
correctOutput = "abcdef";
output = cipher.decode(shift, input);
assertEquals("Caesar failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
@@ -617,12 +617,12 @@ public class TestCaesar{
shift = 23;
correctOutput = "thequickbrownfoxjumpsoverthelazydog";
output = cipher.decode(shift, input);
assertEquals("Caesar failed secure mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding with negative shift
input = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
shift = -3;
correctOutput = "thequickbrownfoxjumpsoverthelazydog";
output = cipher.decode(shift, input);
assertEquals("Caesar failed secure mixed case, whitespace, and symbol decoding with negative shift.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

106
src/test/java/com/mattrixwv/cipherstream/monosubstitution/TestOneTimePad.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestOneTimePad.java
//Mattrixwv
// Created: 02-23-22
//Modified: 02-23-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.monosubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
@@ -23,34 +23,34 @@ public class TestOneTimePad{
String keyword = "keywordThatIsTotallyRandom";
String correctOutput = "wiqooxhmvegkgws";
String output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "WIQOOXHMVEGKGWS";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "wiqooxh mv egkgws";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "wiqooxh*mv+egkgws";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol encoding
inputString = "Message to^encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "Wiqooxh mv^egkgws";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -62,34 +62,34 @@ public class TestOneTimePad{
String keyword = "keywordThatIsTotallyRandom";
String correctOutput = "WIQOOXHMVEGKGWS";
String output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "WIQOOXHMVEGKGWS";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "WIQOOXH MV EGKGWS";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "WIQOOXH*MV+EGKGWS";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol encoding
inputString = "Message to^encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "WIQOOXH MV^EGKGWS";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no capital mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -101,34 +101,34 @@ public class TestOneTimePad{
String keyword = "keywordThatIsTotallyRandom";
String correctOutput = "wiqooxhmvegkgws";
String output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "WIQOOXHMVEGKGWS";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "wiqooxhmvegkgws";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "wiqooxh*mv+egkgws";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol encoding
inputString = "Message to^encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "Wiqooxhmv^egkgws";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no whitespace mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -140,34 +140,34 @@ public class TestOneTimePad{
String keyword = "keywordThatIsTotallyRandom";
String correctOutput = "wiqooxhmvegkgws";
String output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "WIQOOXHMVEGKGWS";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "wiqooxh mv egkgws";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "wiqooxhmvegkgws";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol encoding
inputString = "Message to^encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "Wiqooxh mvegkgws";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed no symbol mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -179,34 +179,34 @@ public class TestOneTimePad{
String keyword = "keywordThatIsTotallyRandom";
String correctOutput = "WIQOOXHMVEGKGWS";
String output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "WIQOOXHMVEGKGWS";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "WIQOOXHMVEGKGWS";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "WIQOOXHMVEGKGWS";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol encoding
inputString = "Message to^encode";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "WIQOOXHMVEGKGWS";
output = cipher.encode(keyword, inputString);
assertEquals("OneTimePad failed secure mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -219,34 +219,34 @@ public class TestOneTimePad{
String keyword = "keywordThatIsTotallyRandom";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHMVEGKGWS";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh mv egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*mv+egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding
inputString = "Wiqooxh mv^egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "Message to^encode";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -258,34 +258,34 @@ public class TestOneTimePad{
String keyword = "keywordThatIsTotallyRandom";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHMVEGKGWS";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh mv egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*mv+egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "MESSAGE*TO+ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding
inputString = "Wiqooxh mv^egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no capital mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -297,34 +297,34 @@ public class TestOneTimePad{
String keyword = "keywordThatIsTotallyRandom";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHMVEGKGWS";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh mv egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*mv+egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding
inputString = "Wiqooxh mv^egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "Messageto^encode";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no whitespace mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -336,34 +336,34 @@ public class TestOneTimePad{
String keyword = "keywordThatIsTotallyRandom";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHMVEGKGWS";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh mv egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*mv+egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding
inputString = "Wiqooxh mv^egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "Message toencode";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed no symbol mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -375,33 +375,33 @@ public class TestOneTimePad{
String keyword = "keywordThatIsTotallyRandom";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHMVEGKGWS";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh mv egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*mv+egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding
inputString = "Wiqooxh mv^egkgws";
keyword = "keywordThatIsTotallyRandom";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("OneTimePad failed secure mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

106
src/test/java/com/mattrixwv/cipherstream/monosubstitution/TestPorta.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestPorta.java
//Mattrixwv
// Created: 02-28-22
//Modified: 02-28-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.monosubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
@@ -23,34 +23,34 @@ public class TestPorta{
String keyword = "keyword";
String correctOutput = "rtghuosbmqcwgrw";
String output = cipher.encode(keyword, inputString);
assertEquals("Porta failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "RTGHUOSBMQCWGRW";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "rtghuos bm qcwgrw";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "rtghuos*bm+qcwgrw";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Rtghuos bm^qcwgrw";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -62,34 +62,34 @@ public class TestPorta{
String keyword = "keyword";
String correctOutput = "RTGHUOSBMQCWGRW";
String output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "RTGHUOSBMQCWGRW";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "RTGHUOS BM QCWGRW";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "RTGHUOS*BM+QCWGRW";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "RTGHUOS BM^QCWGRW";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no capital mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -101,34 +101,34 @@ public class TestPorta{
String keyword = "keyword";
String correctOutput = "rtghuosbmqcwgrw";
String output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "RTGHUOSBMQCWGRW";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "rtghuosbmqcwgrw";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "rtghuos*bm+qcwgrw";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Rtghuosbm^qcwgrw";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no whitespace mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -140,34 +140,34 @@ public class TestPorta{
String keyword = "keyword";
String correctOutput = "rtghuosbmqcwgrw";
String output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "RTGHUOSBMQCWGRW";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "rtghuos bm qcwgrw";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "rtghuosbmqcwgrw";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Rtghuos bmqcwgrw";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed no symbol mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -179,34 +179,34 @@ public class TestPorta{
String keyword = "keyword";
String correctOutput = "RTGHUOSBMQCWGRW";
String output = cipher.encode(keyword, inputString);
assertEquals("Porta failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "RTGHUOSBMQCWGRW";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "RTGHUOSBMQCWGRW";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "RTGHUOSBMQCWGRW";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "RTGHUOSBMQCWGRW";
output = cipher.encode(keyword, inputString);
assertEquals("Porta failed secure mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -219,34 +219,34 @@ public class TestPorta{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Porta failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "RTGHUOSBMQCWGRW";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "rtghuos bm qcwgrw";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "rtghuos*bm+qcwgrw";
keyword = "keyword";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Rtghuos bm^qcwgrw";
keyword = "keyword";
correctOutput = "Message to^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -258,34 +258,34 @@ public class TestPorta{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Porta failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "RTGHUOSBMQCWGRW";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "rtghuos bm qcwgrw";
keyword = "keyword";
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "rtghuos*bm+qcwgrw";
keyword = "keyword";
correctOutput = "MESSAGE*TO+ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Rtghuos bm^qcwgrw";
keyword = "keyword";
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed no capital mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -297,34 +297,34 @@ public class TestPorta{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Porta failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "RTGHUOSBMQCWGRW";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "rtghuos bm qcwgrw";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "rtghuos*bm+qcwgrw";
keyword = "keyword";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Rtghuos bm^qcwgrw";
keyword = "keyword";
correctOutput = "Messageto^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed no whitespace mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -336,34 +336,34 @@ public class TestPorta{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Porta failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "RTGHUOSBMQCWGRW";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "rtghuos bm qcwgrw";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "rtghuos*bm+qcwgrw";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Rtghuos bm^qcwgrw";
keyword = "keyword";
correctOutput = "Message toencode";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -375,33 +375,33 @@ public class TestPorta{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Porta failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "RTGHUOSBMQCWGRW";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "rtghuos bm qcwgrw";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "rtghuos*bm+qcwgrw";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Rtghuos bm^qcwgrw";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Porta failed secure mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

126
src/test/java/com/mattrixwv/cipherstream/monosubstitution/TestSubstitution.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestSubstitution.java
//Mattrixwv
// Created: 02-22-22
//Modified: 02-22-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.monosubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
@@ -23,40 +23,40 @@ public class TestSubstitution{
String key = "cdefghijklmnopqrstuvwxyzab";
String correctOutput = "oguucigvqgpeqfg";
String output = cipher.encode(key, inputString);
assertEquals("Substitution failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "OGUUCIGVQGPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "oguucig vq gpeqfg";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "oguucig*vq+gpeqfg";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "Oguucig vq^gpeqfg";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol, number encoding with long key
inputString = "Message to&encode 123";
key = "cdefghijklmnopqrstuvwxyzab9876543210";
correctOutput = "Oguucig vq&gpeqfg 876";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed mixed case, whitespace, symbol, number encoding with long key.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -68,40 +68,40 @@ public class TestSubstitution{
String key = "cdefghijklmnopqrstuvwxyzab";
String correctOutput = "OGUUCIGVQGPEQFG";
String output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "OGUUCIGVQGPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "OGUUCIG VQ GPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "OGUUCIG*VQ+GPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "OGUUCIG VQ^GPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol, number encoding with long key
inputString = "Message to&encode 123";
key = "cdefghijklmnopqrstuvwxyzab9876543210";
correctOutput = "OGUUCIG VQ&GPEQFG 876";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital mixed case, whitespace, symbol, number encoding with long key.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -113,40 +113,40 @@ public class TestSubstitution{
String key = "cdefghijklmnopqrstuvwxyzab";
String correctOutput = "oguucigvqgpeqfg";
String output = cipher.encode(key, inputString);
assertEquals("Substitution failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "OGUUCIGVQGPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "oguucigvqgpeqfg";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "oguucig*vq+gpeqfg";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "Oguucigvq^gpeqfg";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no whitespace mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol, number encoding with long key
inputString = "Message to&encode 123";
key = "cdefghijklmnopqrstuvwxyzab9876543210";
correctOutput = "Oguucigvq&gpeqfg876";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no whitespace mixed case, whitespace, symbol, number encoding with long key.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -158,40 +158,40 @@ public class TestSubstitution{
String key = "cdefghijklmnopqrstuvwxyzab";
String correctOutput = "oguucigvqgpeqfg";
String output = cipher.encode(key, inputString);
assertEquals("Substitution failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "OGUUCIGVQGPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "oguucig vq gpeqfg";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "oguucigvqgpeqfg";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "Oguucig vqgpeqfg";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no symbol mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol, number encoding with long key
inputString = "Message to&encode 123";
key = "cdefghijklmnopqrstuvwxyzab9876543210";
correctOutput = "Oguucig vqgpeqfg ";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no symbol mixed case, whitespace, symbol, number encoding with long key.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -203,40 +203,40 @@ public class TestSubstitution{
String key = "cdefghijklmnopqrstuvwxyzab";
String correctOutput = "OGUUCIGVQGPEQFG";
String output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "OGUUCIGVQGPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "OGUUCIGVQGPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "OGUUCIGVQGPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "OGUUCIGVQGPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol, number encoding with long key
inputString = "Message to&encode 123";
key = "cdefghijklmnopqrstuvwxyzab9876543210";
correctOutput = "OGUUCIGVQGPEQFG";
output = cipher.encode(key, inputString);
assertEquals("Substitution failed no capital mixed case, whitespace, symbol, number encoding with long key.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -249,40 +249,40 @@ public class TestSubstitution{
String key = "cdefghijklmnopqrstuvwxyzab";
String correctOutput = "messagetoencode";
String output = cipher.decode(key, inputString);
assertEquals("Substitution failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "OGUUCIGVQGPEQFG";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "oguucig vq gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "message to encode";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "oguucig*vq+gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "message*to+encode";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Oguucig vq^gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "Message to^encode";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol, number decoding with long key
inputString = "Oguucig vq&gpeqfg 876";
key = "cdefghijklmnopqrstuvwxyzab9876543210";
correctOutput = "Message to&encode 123";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed mixed case, whitespace, symbol, number decoding with long key.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -294,40 +294,40 @@ public class TestSubstitution{
String key = "cdefghijklmnopqrstuvwxyzab";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(key, inputString);
assertEquals("Substitution failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "OGUUCIGVQGPEQFG";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "oguucig vq gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "oguucig*vq+gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "MESSAGE*TO+ENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Oguucig vq^gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no capital mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol, number decoding with long key
inputString = "Oguucig vq&gpeqfg 876";
key = "cdefghijklmnopqrstuvwxyzab9876543210";
correctOutput = "MESSAGE TO&ENCODE 123";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no capital mixed case, whitespace, symbol, number decoding with long key.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -339,40 +339,40 @@ public class TestSubstitution{
String key = "cdefghijklmnopqrstuvwxyzab";
String correctOutput = "messagetoencode";
String output = cipher.decode(key, inputString);
assertEquals("Substitution failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "OGUUCIGVQGPEQFG";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "oguucig vq gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "messagetoencode";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "oguucig*vq+gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "message*to+encode";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Oguucig vq^gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "Messageto^encode";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no whitespace mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol, number decoding with long key
inputString = "Oguucig vq&gpeqfg 876";
key = "cdefghijklmnopqrstuvwxyzab9876543210";
correctOutput = "Messageto&encode123";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no whitespace mixed case, whitespace, symbol, number decoding with long key.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -384,40 +384,40 @@ public class TestSubstitution{
String key = "cdefghijklmnopqrstuvwxyzab";
String correctOutput = "messagetoencode";
String output = cipher.decode(key, inputString);
assertEquals("Substitution failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "OGUUCIGVQGPEQFG";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "oguucig vq gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "message to encode";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "oguucig*vq+gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "messagetoencode";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Oguucig vq^gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "Message toencode";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed mixed no symbol case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol, number decoding with long key
inputString = "Oguucig vq&gpeqfg 876";
key = "cdefghijklmnopqrstuvwxyzab9876543210";
correctOutput = "Message toencode ";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed no symbol mixed case, whitespace, symbol, number decoding with long key.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -429,39 +429,39 @@ public class TestSubstitution{
String key = "cdefghijklmnopqrstuvwxyzab";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(key, inputString);
assertEquals("Substitution failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "OGUUCIGVQGPEQFG";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "oguucig vq gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "oguucig*vq+gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Oguucig vq^gpeqfg";
key = "cdefghijklmnopqrstuvwxyzab";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed secure mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol, number decoding with long key
inputString = "Oguucig vq&gpeqfg 876";
key = "cdefghijklmnopqrstuvwxyzab9876543210";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Substitution failed secure mixed case, whitespace, symbol, number decoding with long key.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

106
src/test/java/com/mattrixwv/cipherstream/monosubstitution/TestVigenere.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestVigenere.java
//Mattrixwv
// Created: 07-25-21
//Modified: 02-22-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.monosubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
@@ -23,34 +23,34 @@ public class TestVigenere{
String keyword = "keyword";
String correctOutput = "wiqooxhdscjqfgo";
String output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "WIQOOXHDSCJQFGO";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "wiqooxh ds cjqfgo";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "wiqooxh*ds+cjqfgo";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Wiqooxh ds^cjqfgo";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -62,34 +62,34 @@ public class TestVigenere{
String keyword = "keyword";
String correctOutput = "WIQOOXHDSCJQFGO";
String output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "WIQOOXHDSCJQFGO";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "WIQOOXH DS CJQFGO";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "WIQOOXH*DS+CJQFGO";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "WIQOOXH DS^CJQFGO";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no capital mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -101,34 +101,34 @@ public class TestVigenere{
String keyword = "keyword";
String correctOutput = "wiqooxhdscjqfgo";
String output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "WIQOOXHDSCJQFGO";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "wiqooxhdscjqfgo";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "wiqooxh*ds+cjqfgo";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Wiqooxhds^cjqfgo";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no whitespace mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -140,34 +140,34 @@ public class TestVigenere{
String keyword = "keyword";
String correctOutput = "wiqooxhdscjqfgo";
String output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "WIQOOXHDSCJQFGO";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "wiqooxh ds cjqfgo";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "wiqooxhdscjqfgo";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Wiqooxh dscjqfgo";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed no symbol mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -179,34 +179,34 @@ public class TestVigenere{
String keyword = "keyword";
String correctOutput = "WIQOOXHDSCJQFGO";
String output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "WIQOOXHDSCJQFGO";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "WIQOOXHDSCJQFGO";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "WIQOOXHDSCJQFGO";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "WIQOOXHDSCJQFGO";
output = cipher.encode(keyword, inputString);
assertEquals("Vigenere failed secure mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -219,34 +219,34 @@ public class TestVigenere{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHDSCJQFGO";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh ds cjqfgo";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*ds+cjqfgo";
keyword = "keyword";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Wiqooxh ds^cjqfgo";
keyword = "keyword";
correctOutput = "Message to^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -258,34 +258,34 @@ public class TestVigenere{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHDSCJQFGO";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh ds cjqfgo";
keyword = "keyword";
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*ds+cjqfgo";
keyword = "keyword";
correctOutput = "MESSAGE*TO+ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Wiqooxh ds^cjqfgo";
keyword = "keyword";
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no capital mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -297,34 +297,34 @@ public class TestVigenere{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHDSCJQFGO";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh ds cjqfgo";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*ds+cjqfgo";
keyword = "keyword";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Wiqooxh ds^cjqfgo";
keyword = "keyword";
correctOutput = "Messageto^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no whitespace mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -336,34 +336,34 @@ public class TestVigenere{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHDSCJQFGO";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh ds cjqfgo";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*ds+cjqfgo";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Wiqooxh ds^cjqfgo";
keyword = "keyword";
correctOutput = "Message toencode";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed no symbol mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -375,33 +375,33 @@ public class TestVigenere{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "WIQOOXHDSCJQFGO";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "wiqooxh ds cjqfgo";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "wiqooxh*ds+cjqfgo";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Wiqooxh ds^cjqfgo";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Vigenere failed secure mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

106
src/test/java/com/mattrixwv/cipherstream/polysubstitution/TestBifid.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/polySubstitution/TestBifid.java
//Mattrixwv
// Created: 03-03-22
//Modified: 03-03-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.polysubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
@@ -24,34 +24,34 @@ public class TestBifid{
String keyword = "keyword";
String correctOutput = "mqaoknekcvdodzd";
String output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "MQAOKNEKCVDODZD";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "mqaokne kc vdodzd";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "mqaokne*kc+vdodzd";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Mqaokne kc^vdodzd";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -63,34 +63,34 @@ public class TestBifid{
String keyword = "keyword";
String correctOutput = "MQAOKNEKCVDODZD";
String output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "MQAOKNEKCVDODZD";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "MQAOKNE KC VDODZD";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "MQAOKNE*KC+VDODZD";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "MQAOKNE KC^VDODZD";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no capital mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -102,34 +102,34 @@ public class TestBifid{
String keyword = "keyword";
String correctOutput = "mqaoknekcvdodzd";
String output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "MQAOKNEKCVDODZD";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "mqaoknekcvdodzd";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "mqaokne*kc+vdodzd";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Mqaoknekc^vdodzd";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no whitespace mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -141,34 +141,34 @@ public class TestBifid{
String keyword = "keyword";
String correctOutput = "mqaoknekcvdodzd";
String output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "MQAOKNEKCVDODZD";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "mqaokne kc vdodzd";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "mqaoknekcvdodzd";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Mqaokne kcvdodzd";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed no symbol mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -180,34 +180,34 @@ public class TestBifid{
String keyword = "keyword";
String correctOutput = "MQAOKNEKCVDODZD";
String output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "MQAOKNEKCVDODZD";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "MQAOKNEKCVDODZD";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
keyword = "keyword";
correctOutput = "MQAOKNEKCVDODZD";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "MQAOKNEKCVDODZD";
output = cipher.encode(keyword, inputString);
assertEquals("Bifid failed secure mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -220,34 +220,34 @@ public class TestBifid{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MQAOKNEKCVDODZD";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "mqaokne kc vdodzd";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "mqaokne*kc+vdodzd";
keyword = "keyword";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Mqaokne kc^vdodzd";
keyword = "keyword";
correctOutput = "Message to^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -259,34 +259,34 @@ public class TestBifid{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MQAOKNEKCVDODZD";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "mqaokne kc vdodzd";
keyword = "keyword";
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "mqaokne*kc+vdodzd";
keyword = "keyword";
correctOutput = "MESSAGE*TO+ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Mqaokne kc^vdodzd";
keyword = "keyword";
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no capital mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -298,34 +298,34 @@ public class TestBifid{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MQAOKNEKCVDODZD";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "mqaokne kc vdodzd";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "mqaokne*kc+vdodzd";
keyword = "keyword";
correctOutput = "message*to+encode";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Mqaokne kc^vdodzd";
keyword = "keyword";
correctOutput = "Messageto^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no whitespace mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -337,34 +337,34 @@ public class TestBifid{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MQAOKNEKCVDODZD";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "mqaokne kc vdodzd";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "mqaokne*kc+vdodzd";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Mqaokne kc^vdodzd";
keyword = "keyword";
correctOutput = "Message toencode";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed no symbol mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -376,33 +376,33 @@ public class TestBifid{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MQAOKNEKCVDODZD";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "mqaokne kc vdodzd";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "mqaokne*kc+vdodzd";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Mqaokne kc^vdodzd";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Bifid failed secure mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

126
src/test/java/com/mattrixwv/cipherstream/polysubstitution/TestColumnar.java
View File

@@ -1,13 +1,13 @@
//Mattrixwv/src/test/java/com/mattrixwv/CipherStreamJava/polySubstitution/TestColumnar.java
//Mattrixwv
// Created: 01-16-22
//Modified: 03-03-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.polysubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
@@ -24,34 +24,34 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "edxeoxmteacxgoxsnxsex";
String output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "EDXEOXMTEACXGOXsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "edxeoxm te acxgoxsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message@to-encode";
keyword = "keyword";
correctOutput = "edxeoxm@te-acxgoxsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to*encode";
keyword = "keyword";
correctOutput = "Edxeoxm te*acxgoxsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -62,34 +62,34 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "EDXEOXMTEACXGOXSNXSEX";
String output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no capitals lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "EDXEOXMTEACXGOXSNXSEX";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no capitals uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "EDXEOXM TE ACXGOXSNXSEX";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no capitals whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message@to-encode";
keyword = "keyword";
correctOutput = "EDXEOXM@TE-ACXGOXSNXSEX";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no capitals symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to*encode";
keyword = "keyword";
correctOutput = "EDXEOXM TE*ACXGOXSNXSEX";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no capitals mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -100,34 +100,34 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "edxeoxmteacxgoxsnxsex";
String output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "EDXEOXMTEACXGOXsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "edxeoxmteacxgoxsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message@to-encode";
keyword = "keyword";
correctOutput = "edxeoxm@te-acxgoxsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to*encode";
keyword = "keyword";
correctOutput = "Edxeoxmte*acxgoxsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no whitespace mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -138,34 +138,34 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "edxeoxmteacxgoxsnxsex";
String output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "EDXEOXMTEACXGOXsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "edxeoxm te acxgoxsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message@to-encode";
keyword = "keyword";
correctOutput = "edxeoxmteacxgoxsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to*encode";
keyword = "keyword";
correctOutput = "Edxeoxm teacxgoxsnxsex";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no symbol mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoPaddingEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -176,34 +176,34 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "edeomteacgosnse";
String output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no padding lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "EDEOMTEACGOSNSE";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no padding uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "edeomte ac gosnse";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no padding whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message@to-encode";
keyword = "keyword";
correctOutput = "edeomte@ac-gosnse";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no padding symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message To*encode";
keyword = "keyword";
correctOutput = "Edeomte Ac*gosnse";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed no padding mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -214,34 +214,34 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "EDXEOXMTEACXGOXSNXSEX";
String output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "EDXEOXMTEACXGOXSNXSEX";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "EDXEOXMTEACXGOXSNXSEX";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message@to-encode";
keyword = "keyword";
correctOutput = "EDXEOXMTEACXGOXSNXSEX";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to*encode";
keyword = "keyword";
correctOutput = "EDXEOXMTEACXGOXSNXSEX";
output = cipher.encode(keyword, inputString);
assertEquals("Columnar failed secure mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -254,34 +254,34 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "messagetoencodexxxxxx";
String output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "EDXEOXMTEACXGOXsnxsex";
keyword = "keyword";
correctOutput = "MESSAGETOENCODExxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "edxeoxm te acxgoxsnxsex";
keyword = "keyword";
correctOutput = "message to encodexxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "edxeoxm@te-acxgoxsnxsex";
keyword = "keyword";
correctOutput = "message@to-encodexxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Edxeoxm te*acxgoxsnxsex";
keyword = "keyword";
correctOutput = "Message to*encodexxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -292,34 +292,34 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODEXXXXXX";
String output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "EDXEOXMTEACXGOXsnxsex";
keyword = "keyword";
correctOutput = "MESSAGETOENCODEXXXXXX";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "edxeoxm te acxgoxsnxsex";
keyword = "keyword";
correctOutput = "MESSAGE TO ENCODEXXXXXX";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "edxeoxm@te-acxgoxsnxsex";
keyword = "keyword";
correctOutput = "MESSAGE@TO-ENCODEXXXXXX";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Edxeoxm te*acxgoxsnxsex";
keyword = "keyword";
correctOutput = "MESSAGE TO*ENCODEXXXXXX";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no capital mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -330,34 +330,34 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "messagetoencodexxxxxx";
String output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "EDXEOXMTEACXGOXsnxsex";
keyword = "keyword";
correctOutput = "MESSAGETOENCODExxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "edxeoxm te acxgoxsnxsex";
keyword = "keyword";
correctOutput = "messagetoencodexxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "edxeoxm@te-acxgoxsnxsex";
keyword = "keyword";
correctOutput = "message@to-encodexxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Edxeoxm te*acxgoxsnxsex";
keyword = "keyword";
correctOutput = "Messageto*encodexxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no whitespace mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -368,34 +368,34 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "messagetoencodexxxxxx";
String output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "EDXEOXMTEACXGOXsnxsex";
keyword = "keyword";
correctOutput = "MESSAGETOENCODExxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "edxeoxm te acxgoxsnxsex";
keyword = "keyword";
correctOutput = "message to encodexxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "edxeoxm@te-acxgoxsnxsex";
keyword = "keyword";
correctOutput = "messagetoencodexxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Edxeoxm te*acxgoxsnxsex";
keyword = "keyword";
correctOutput = "Message toencodexxxxxx";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no symbol mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoPaddingDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -406,34 +406,34 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no padding lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "EDEOMTEACGOSNSE";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no padding uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "edeomte ac gosnse";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no padding whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "edeomte@ac-gosnse";
keyword = "keyword";
correctOutput = "message@to-encode";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no padding symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Edeomte ac*gosnse";
keyword = "keyword";
correctOutput = "Message to*encode";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed no padding mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
@@ -444,33 +444,33 @@ public class TestColumnar{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODEXXXXXX";
String output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "EDXEOXMTEACXGOXsnxsex";
keyword = "keyword";
correctOutput = "MESSAGETOENCODEXXXXXX";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "edxeoxm te acxgoxsnxsex";
keyword = "keyword";
correctOutput = "MESSAGETOENCODEXXXXXX";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "edxeoxm@te-acxgoxsnxsex";
keyword = "keyword";
correctOutput = "MESSAGETOENCODEXXXXXX";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Edxeoxm te*acxgoxsnxsex";
keyword = "keyword";
correctOutput = "MESSAGETOENCODEXXXXXX";
output = cipher.decode(keyword, inputString);
assertEquals("Columnar failed secure mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

141
src/test/java/com/mattrixwv/cipherstream/polysubstitution/TestHill.java
View File

@@ -1,18 +1,17 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamjava/polySubstitution/TestHill.java
//Mattrixwv
// Created: 01-31-22
//Modified: 02-17-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.polysubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.security.InvalidKeyException;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
import com.mattrixwv.cipherstream.exceptions.InvalidKeyException;
public class TestHill{
@@ -25,41 +24,41 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "mgkeqgeulikhisp";
String output = cipher.encode(key, inputString);
assertEquals("Hill failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGEULIKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqge ul ikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqge*ul+ikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test padding encoding
inputString = "messagetoencod";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqgeulikhul";
output = cipher.encode(key, inputString);
assertEquals("Hill failed padding encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "Mgkeqge ul^ikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -71,41 +70,41 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "MGKEQGEULIKHISP";
String output = cipher.encode(key, inputString);
assertEquals("Hill failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGEULIKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGE UL IKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGE*UL+IKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test padding encoding
inputString = "messagetoencod";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGEULIKHUL";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no capital padding encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGE UL^IKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no capital mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -117,41 +116,41 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "mgkeqgeulikhisp";
String output = cipher.encode(key, inputString);
assertEquals("Hill failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGEULIKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqgeulikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqge*ul+ikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test padding encoding
inputString = "messagetoencod";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqgeulikhul";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no whitespace padding encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "Mgkeqgeul^ikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no whitespace mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -163,41 +162,41 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "mgkeqgeulikhisp";
String output = cipher.encode(key, inputString);
assertEquals("Hill failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGEULIKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqge ul ikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqgeulikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test padding encoding
inputString = "messagetoencod";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqgeulikhul";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no symbol padding encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "Mgkeqge ulikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no symbol mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -209,41 +208,41 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "mgkeqgeulikhisp";
String output = cipher.encode(key, inputString);
assertEquals("Hill failed no padding lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGEULIKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no padding uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqge ul ikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no padding whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqge*ul+ikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no padding symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test padding encoding
inputString = "messagetoencod";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "mgkeqgeulikhulb";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no padding padding encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "Mgkeqge ul^ikhisp";
output = cipher.encode(key, inputString);
assertEquals("Hill failed no padding mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -255,41 +254,41 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "MGKEQGEULIKHISP";
String output = cipher.encode(key, inputString);
assertEquals("Hill failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGEULIKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGEULIKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGEULIKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test padding encoding
inputString = "messagetoencod";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGEULIKHULB";
output = cipher.encode(key, inputString);
assertEquals("Hill failed secure padding encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol encoding
inputString = "Message to^encode";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MGKEQGEULIKHISP";
output = cipher.encode(key, inputString);
assertEquals("Hill failed secure mixed case, whitespace, and symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -302,34 +301,34 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "messagetoencode";
String output = cipher.decode(key, inputString);
assertEquals("Hill failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MGKEQGEULIKHISP";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "mgkeqge ul ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "message to encode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "mgkeqge*ul+ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "message*to+encode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "Mgkeqge ul^ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "Message to^encode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -341,34 +340,34 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(key, inputString);
assertEquals("Hill failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MGKEQGEULIKHISP";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "mgkeqge ul ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "mgkeqge*ul+ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGE*TO+ENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "Mgkeqge ul^ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no capital mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -380,34 +379,34 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "messagetoencode";
String output = cipher.decode(key, inputString);
assertEquals("Hill failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MGKEQGEULIKHISP";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "mgkeqge ul ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "messagetoencode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "mgkeqge*ul+ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "message*to+encode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "Mgkeqge ul^ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "Messageto^encode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no whitespace mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -419,34 +418,34 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "messagetoencode";
String output = cipher.decode(key, inputString);
assertEquals("Hill failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MGKEQGEULIKHISP";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "mgkeqge ul ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "message to encode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "mgkeqge*ul+ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "messagetoencode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "Mgkeqge ul^ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "Message toencode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no symbol mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -458,34 +457,34 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "messagetoencode";
String output = cipher.decode(key, inputString);
assertEquals("Hill failed no padding lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MGKEQGEULIKHISP";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no padding uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "mgkeqge ul ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "message to encode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no padding whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "mgkeqge*ul+ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "message*to+encode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no padding symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "Mgkeqge ul^ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "Message to^encode";
output = cipher.decode(key, inputString);
assertEquals("Hill failed no padding mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -497,33 +496,33 @@ public class TestHill{
int[][] key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(key, inputString);
assertEquals("Hill failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MGKEQGEULIKHISP";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "mgkeqge ul ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "mgkeqge*ul+ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, and symbol decoding
inputString = "Mgkeqge ul^ikhisp";
key = new int[][]{{1, 4, 2}, {2, 4, 1}, {4, 1, 2}};
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(key, inputString);
assertEquals("Hill failed secure mixed case, whitespace, and symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

18
src/test/java/com/mattrixwv/cipherstream/polysubstitution/TestMorse.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/main/java/com/mattrixwv/CipherStreamJava/TestMorse.java
//Matthew Ellison
// Created: 07-28-21
//Modified: 01-04-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.polysubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class TestMorse{
@@ -19,19 +19,19 @@ public class TestMorse{
String input = "sos";
String correctOutput = "... --- ...";
String output = cipher.encode(input);
assertEquals("Morse Encoding failed the first test", correctOutput, output);
assertEquals(correctOutput, output);
//Test 2
input = "MORSE, CODE";
correctOutput = "-- --- .-. ... . -.-. --- -.. .";
output = cipher.encode(input);
assertEquals("Morse Encoding failed the second test", correctOutput, output);
assertEquals(correctOutput, output);
//Test 3
input = "1.23 987";
correctOutput = ".---- ..--- ...-- ----. ---.. --...";
output = cipher.encode(input);
assertEquals("Morse Encoding failed the third test", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testDecode(){
@@ -41,18 +41,18 @@ public class TestMorse{
String input = "... --- ...";
String correctOutput = "SOS";
String output = cipher.decode(input);
assertEquals("Morse Decoding failed the first test", correctOutput, output);
assertEquals(correctOutput, output);
//Test 2
input = "-- --- .-. ... . -.-. --- -.. .";
correctOutput = "MORSECODE";
output = cipher.decode(input);
assertEquals("Morse Decoding failed the second test", correctOutput, output);
assertEquals(correctOutput, output);
//Test 3
input = ".---- ..--- ...-- ----. ---.. --...";
correctOutput = "123987";
output = cipher.decode(input);
assertEquals("Morse Decoding failed the third test", correctOutput, output);
assertEquals(correctOutput, output);
}
}

146
src/test/java/com/mattrixwv/cipherstream/polysubstitution/TestPlayfair.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/main/java/com/mattrixwv/CipherStreamJava/TestPlayfair.java
//Matthew Ellison
// Created: 07-30-21
//Modified: 01-04-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.polysubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
@@ -23,46 +23,46 @@ public class TestPlayfair{
String keyword = "Playfair Example";
String correctOutput = "bmodzbxdnabekudmuixMmouvif";
String output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "HIDETHEGOLDINTHETREESTUMP";
keyword = "Playfair Example";
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test odd letter count encoding
inputString = "hidethegoldinthetrexestum";
keyword = "Playfair Example";
correctOutput = "bmodzbxdnabekudmuixmmouviM";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed odd letter count encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "hide the gold in the tree stump";
keyword = "Playfair Example";
correctOutput = "bmod zbx dnab ek udm uixMm ouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "hidethegoldin-the@tree+stump";
keyword = "Playfair Example";
correctOutput = "bmodzbxdnabek-udm@uixMm+ouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Hide the gold in - the@tree+stump";
keyword = "Playfair Example";
correctOutput = "Bmod zbx dnab ek - udm@uixMm+ouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding with mangled keyword
inputString = "Hide the gold in - the@tree+stump";
keyword = "Play-fair@Exam ple";
correctOutput = "Bmod zbx dnab ek - udm@uixMm+ouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidInputException{
@@ -73,46 +73,46 @@ public class TestPlayfair{
String keyword = "Playfair Example";
String correctOutput = "bmodzbxdnabekudmuixMmouvif";
String output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "HIDETHEGOLDINTHETREESTUMP";
keyword = "Playfair Example";
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test odd letter count encoding
inputString = "hidethegoldinthetreestum";
keyword = "Playfair Example";
correctOutput = "bmodzbxdnabekudmuixMmouviM";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no whitespace odd letter count encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "hide the gold in the tree stump";
keyword = "Playfair Example";
correctOutput = "bmodzbxdnabekudmuixMmouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "hidethegoldin-the@tree+stump";
keyword = "Playfair Example";
correctOutput = "bmodzbxdnabek-udm@uixMm+ouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Hide the gold in - the@tree+stump";
keyword = "Playfair Example";
correctOutput = "Bmodzbxdnabek-udm@uixMm+ouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding with mangled keyword
inputString = "Hide the gold in - the@tree+stump";
keyword = "Play-fair@Exam ple";
correctOutput = "Bmodzbxdnabek-udm@uixMm+ouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalEncode() throws InvalidCharacterException, InvalidInputException{
@@ -123,46 +123,46 @@ public class TestPlayfair{
String keyword = "Playfair Example";
String correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
String output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "HIDETHEGOLDINTHETREESTUMP";
keyword = "Playfair Example";
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test odd letter count encoding
inputString = "hidethegoldinthetreestum";
keyword = "Playfair Example";
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIM";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no capital odd letter count encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "hide the gold in the tree stump";
keyword = "Playfair Example";
correctOutput = "BMOD ZBX DNAB EK UDM UIXMM OUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "hidethegoldin-the@tree+stump";
keyword = "Playfair Example";
correctOutput = "BMODZBXDNABEK-UDM@UIXMM+OUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Hide the gold in - the@tree+stump";
keyword = "Playfair Example";
correctOutput = "BMOD ZBX DNAB EK - UDM@UIXMM+OUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no capital mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding with mangled keyword
inputString = "Hide the gold in - the@tree+stump";
keyword = "Play-fair@Exam ple";
correctOutput = "BMOD ZBX DNAB EK - UDM@UIXMM+OUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no capital mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidInputException{
@@ -173,46 +173,46 @@ public class TestPlayfair{
String keyword = "Playfair Example";
String correctOutput = "bmodzbxdnabekudmuixMmouvif";
String output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "HIDETHEGOLDINTHETREESTUMP";
keyword = "Playfair Example";
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test odd letter count encoding
inputString = "hidethegoldinthetreestum";
keyword = "Playfair Example";
correctOutput = "bmodzbxdnabekudmuixMmouviM";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no symbol odd letter count encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "hide the gold in the tree stump";
keyword = "Playfair Example";
correctOutput = "bmod zbx dnab ek udm uixMm ouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "hidethegoldin-the@tree+stump";
keyword = "Playfair Example";
correctOutput = "bmodzbxdnabekudmuixMmouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Hide the gold in - the@tree+stump";
keyword = "Playfair Example";
correctOutput = "Bmod zbx dnab ek udmuixMmouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no symbol mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding with mangled keyword
inputString = "Hide the gold in - the@tree+stump";
keyword = "Play-fair@Exam ple";
correctOutput = "Bmod zbx dnab ek udmuixMmouvif";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed no symbol mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidInputException{
@@ -223,46 +223,46 @@ public class TestPlayfair{
String keyword = "Playfair Example";
String correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
String output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "HIDETHEGOLDINTHETREESTUMP";
keyword = "Playfair Example";
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test odd letter count encoding
inputString = "hidethegoldinthetreestum";
keyword = "Playfair Example";
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIM";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed secure odd letter count encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "hide the gold in the tree stump";
keyword = "Playfair Example";
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "hidethegoldin-the@tree+stump";
keyword = "Playfair Example";
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Hide the gold in - the@tree+stump";
keyword = "Playfair Example";
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed secure mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding with mangled keyword
inputString = "Hide the gold in - the@tree+stump";
keyword = "Play-fair@Exam ple";
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
output = cipher.encode(keyword, inputString);
assertEquals("Playfair failed secure mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testDecode() throws InvalidCharacterException, InvalidInputException{
@@ -273,46 +273,46 @@ public class TestPlayfair{
String keyword = "Playfair Example";
String correctOutput = "hidethegoldinthetrexestump";
String output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "BMODZBXDNABEKUDMUIXMMOUVIF";
keyword = "Playfair Example";
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test odd letter count decoding
inputString = "bmodzbxdnabekudmuixmmouvim";
keyword = "Playfair Example";
correctOutput = "hidethegoldinthetrexestumx";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed odd letter count decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "bmod zbx dnab ek udm uixmm ouvif";
keyword = "Playfair Example";
correctOutput = "hide the gold in the trexe stump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "bmodzbxdnabek-udm@uixmm+ouvif";
keyword = "Playfair Example";
correctOutput = "hidethegoldin-the@trexe+stump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
keyword = "Playfair Example";
correctOutput = "Hide the gold in - the@trexe+stump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding with mangled keyword
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
keyword = "Play-fair@Exam ple";
correctOutput = "Hide the gold in - the@trexe+stump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidInputException{
@@ -323,46 +323,46 @@ public class TestPlayfair{
String keyword = "Playfair Example";
String correctOutput = "hidethegoldinthetrexestump";
String output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "BMODZBXDNABEKUDMUIXMMOUVIF";
keyword = "Playfair Example";
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test odd letter count decoding
inputString = "bmodzbxdnabekudmuixmmouvim";
keyword = "Playfair Example";
correctOutput = "hidethegoldinthetrexestumx";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no whitespace odd letter count decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "bmodzbxdnabekudmuixmmouvif";
keyword = "Playfair Example";
correctOutput = "hidethegoldinthetrexestump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "bmodzbxdnabek-udm@uixmm+ouvif";
keyword = "Playfair Example";
correctOutput = "hidethegoldin-the@trexe+stump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding
inputString = "Bmodzbxdnabek-udm@uixmm+ouvif";
keyword = "Playfair Example";
correctOutput = "Hidethegoldin-the@trexe+stump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding with mangled keyword
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
keyword = "Play-fair@Exam ple";
correctOutput = "Hidethegoldin-the@trexe+stump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalDecode() throws InvalidCharacterException, InvalidInputException{
@@ -373,46 +373,46 @@ public class TestPlayfair{
String keyword = "Playfair Example";
String correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
String output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "BMODZBXDNABEKUDMUIXMMOUVIF";
keyword = "Playfair Example";
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test odd letter count decoding
inputString = "bmodzbxdnabekudmuixmmouvim";
keyword = "Playfair Example";
correctOutput = "HIDETHEGOLDINTHETREXESTUMX";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no capital odd letter count decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "bmod zbx dnab ek udm uixmm ouvif";
keyword = "Playfair Example";
correctOutput = "HIDE THE GOLD IN THE TREXE STUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "bmodzbxdnabek-udm@uixmm+ouvif";
keyword = "Playfair Example";
correctOutput = "HIDETHEGOLDIN-THE@TREXE+STUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
keyword = "Playfair Example";
correctOutput = "HIDE THE GOLD IN - THE@TREXE+STUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no capital mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding with mangled keyword
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
keyword = "Play-fair@Exam ple";
correctOutput = "HIDE THE GOLD IN - THE@TREXE+STUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no capital mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolDecode() throws InvalidCharacterException, InvalidInputException{
@@ -423,46 +423,46 @@ public class TestPlayfair{
String keyword = "Playfair Example";
String correctOutput = "hidethegoldinthetrexestump";
String output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "BMODZBXDNABEKUDMUIXMMOUVIF";
keyword = "Playfair Example";
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test odd letter count decoding
inputString = "bmodzbxdnabekudmuixmmouvim";
keyword = "Playfair Example";
correctOutput = "hidethegoldinthetrexestumx";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no symbol odd letter count decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "bmod zbx dnab ek udm uixmm ouvif";
keyword = "Playfair Example";
correctOutput = "hide the gold in the trexe stump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "bmodzbxdnabek-udm@uixmm+ouvif";
keyword = "Playfair Example";
correctOutput = "hidethegoldinthetrexestump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
keyword = "Playfair Example";
correctOutput = "Hide the gold in thetrexestump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no symbol mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding with mangled keyword
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
keyword = "Play-fair@Exam ple";
correctOutput = "Hide the gold in thetrexestump";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed no symbol mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidInputException{
@@ -473,45 +473,45 @@ public class TestPlayfair{
String keyword = "Playfair Example";
String correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
String output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "BMODZBXDNABEKUDMUIXMMOUVIF";
keyword = "Playfair Example";
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test odd letter count decoding
inputString = "bmodzbxdnabekudmuixmmouvim";
keyword = "Playfair Example";
correctOutput = "HIDETHEGOLDINTHETREXESTUMX";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed secure odd letter count decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "bmod zbx dnab ek udm uixmm ouvif";
keyword = "Playfair Example";
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "bmodzbxdnabek-udm@uixmm+ouvif";
keyword = "Playfair Example";
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
keyword = "Playfair Example";
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed secure mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whtiespace, symbol decoding with mangled keyword
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
keyword = "Play-fair@Exam ple";
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
output = cipher.decode(keyword, inputString);
assertEquals("Playfair failed secure mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

86
src/test/java/com/mattrixwv/cipherstream/polysubstitution/TestPolybiusSquare.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/TestPolybiusSquare.java
//Mattrixwv
// Created: 01-04-22
//Modified: 01-09-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.polysubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
@@ -23,34 +23,34 @@ public class TestPolybiusSquare{
String keyword = "";
String correctOutput = "121144";
String output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed simple encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "B A T";
keyword = "";
correctOutput = "12 11 44";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "B@A+T-";
keyword = "";
correctOutput = "12@11+44-";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding
inputString = "B A-T";
keyword = "";
correctOutput = "12 11-44";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding with mangled keyword
inputString = "B A-T";
keyword = "Z Y+ X-";
correctOutput = "15 14-52";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed whitespace, symbol encoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidInputException{
@@ -61,34 +61,34 @@ public class TestPolybiusSquare{
String keyword = "";
String correctOutput = "121144";
String output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed no whitespace simple encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "B A T";
keyword = "";
correctOutput = "121144";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "B@A+T-";
keyword = "";
correctOutput = "12@11+44-";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding
inputString = "B A-T";
keyword = "";
correctOutput = "1211-44";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed no whitespace whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding with mangled keyword
inputString = "B A-T";
keyword = "Z Y+ X-";
correctOutput = "1514-52";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed no whitespace whitespace, symbol encoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidInputException{
@@ -99,34 +99,34 @@ public class TestPolybiusSquare{
String keyword = "";
String correctOutput = "121144";
String output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed no symbol simple encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "B A T";
keyword = "";
correctOutput = "12 11 44";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "B@A+T-";
keyword = "";
correctOutput = "121144";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding
inputString = "B A-T";
keyword = "";
correctOutput = "12 1144";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding with mangled keyword
inputString = "B A-T";
keyword = "Z Y+ X-";
correctOutput = "15 1452";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed no symbol whitespace, symbol encoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidInputException{
@@ -137,13 +137,13 @@ public class TestPolybiusSquare{
String keyword = "";
String correctOutput = "12 11 44";
String output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed secure simple encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "B A T";
keyword = "";
correctOutput = "12 11 44";
assertEquals("PolybiusSquare failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
output = cipher.encode(keyword, inputString);
//Test symbol encoding
@@ -151,20 +151,20 @@ public class TestPolybiusSquare{
keyword = "";
correctOutput = "12 11 44";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding
inputString = "B A-T";
keyword = "";
correctOutput = "12 11 44";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed secure whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding with mangled keyword
inputString = "B A-T";
keyword = "Z Y+ X-";
correctOutput = "15 14 52";
output = cipher.encode(keyword, inputString);
assertEquals("PolybiusSquare failed secure whitespace, symbol encoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testDecode() throws InvalidCharacterException, InvalidInputException{
@@ -175,34 +175,34 @@ public class TestPolybiusSquare{
String keyword = "";
String correctOutput = "BAT";
String output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed simple decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "12 11 44";
keyword = "";
correctOutput = "B A T";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "12@11+44-";
keyword = "";
correctOutput = "B@A+T-";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding
inputString = "12 11-44";
keyword = "";
correctOutput = "B A-T";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding with mangled keyword
inputString = "15 14-52";
keyword = "Z Y+ X-";
correctOutput = "B A-T";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed whitespace, symbol decoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidInputException{
@@ -213,34 +213,34 @@ public class TestPolybiusSquare{
String keyword = "";
String correctOutput = "BAT";
String output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed no whitespace simple decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "12 11 44";
keyword = "";
correctOutput = "BAT";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "12@11+44-";
keyword = "";
correctOutput = "B@A+T-";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding
inputString = "12 11-44";
keyword = "";
correctOutput = "BA-T";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed no whitespace whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding with mangled keyword
inputString = "15 14-52";
keyword = "Z Y+ X-";
correctOutput = "BA-T";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed no whitespace whitespace, symbol decoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoSymbolDeocde() throws InvalidCharacterException, InvalidInputException{
@@ -251,34 +251,34 @@ public class TestPolybiusSquare{
String keyword = "";
String correctOutput = "BAT";
String output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed no symbol simple decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "12 11 44";
keyword = "";
correctOutput = "B A T";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "12@11+44-";
keyword = "";
correctOutput = "BAT";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding
inputString = "12 11-44";
keyword = "";
correctOutput = "B AT";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed no symbol whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding with mangled keyword
inputString = "15 14-52";
keyword = "Z Y+ X-";
correctOutput = "B AT";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed no symbol whitespace, symbol decoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
public void testNoWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidInputException{
@@ -289,33 +289,33 @@ public class TestPolybiusSquare{
String keyword = "";
String correctOutput = "BAT";
String output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed secure simple decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "12 11 44";
keyword = "";
correctOutput = "BAT";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "12@11+44-";
keyword = "";
correctOutput = "BAT";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding
inputString = "12 11-44";
keyword = "";
correctOutput = "BAT";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed secure whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace, symbol decoding with mangled keyword
inputString = "15 14-52";
keyword = "Z Y+ X-";
correctOutput = "BAT";
output = cipher.decode(keyword, inputString);
assertEquals("PolybiusSquare failed secure whitespace, symbol decoding with mangled keyword.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

146
src/test/java/com/mattrixwv/cipherstream/polysubstitution/TestRailFence.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/polySubstitution/TestRailFence.java
//Mattrixwv
// Created: 03-21-22
//Modified: 03-22-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.polysubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidBaseException;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
@@ -23,47 +23,47 @@ public class TestRailFence{
int numRails = 3;
String correctOutput = "maooesgtecdsene";
String output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
numRails = 3;
correctOutput = "MAOOESGTECDSENE";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test rail length encoding
inputString = "messagetoencode";
numRails = 5;
correctOutput = "moetesenesgcdao";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed rail length encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
numRails = 3;
correctOutput = "maooesg te cdsene";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
numRails = 3;
correctOutput = "maooesg*te+cdsene";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
numRails = 3;
correctOutput = "Maooesg te^cdsene";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed mixedCase, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in rail length for good measure
inputString = "Message to^encode";
numRails = 5;
correctOutput = "Moetese ne^sgcdao";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed mixedCase, whitespace, symbol, railLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -75,47 +75,47 @@ public class TestRailFence{
int numRails = 3;
String correctOutput = "MAOOESGTECDSENE";
String output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
numRails = 3;
correctOutput = "MAOOESGTECDSENE";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test rail length encoding
inputString = "messagetoencode";
numRails = 5;
correctOutput = "MOETESENESGCDAO";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no capital rail length encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
numRails = 3;
correctOutput = "MAOOESG TE CDSENE";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
numRails = 3;
correctOutput = "MAOOESG*TE+CDSENE";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
numRails = 3;
correctOutput = "MAOOESG TE^CDSENE";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no capital mixedCase, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in rail length for good measure
inputString = "Message to^encode";
numRails = 5;
correctOutput = "MOETESE NE^SGCDAO";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no capital mixedCase, whitespace, symbol, railLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -127,47 +127,47 @@ public class TestRailFence{
int numRails = 3;
String correctOutput = "maooesgtecdsene";
String output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
numRails = 3;
correctOutput = "MAOOESGTECDSENE";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test rail length encoding
inputString = "messagetoencode";
numRails = 5;
correctOutput = "moetesenesgcdao";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no whitespace rail length encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
numRails = 3;
correctOutput = "maooesgtecdsene";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
numRails = 3;
correctOutput = "maooesg*te+cdsene";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
numRails = 3;
correctOutput = "Maooesgte^cdsene";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no whitespace mixedCase, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in rail length for good measure
inputString = "Message to^encode";
numRails = 5;
correctOutput = "Moetesene^sgcdao";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no whitespace mixedCase, whitespace, symbol, railLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -179,47 +179,47 @@ public class TestRailFence{
int numRails = 3;
String correctOutput = "maooesgtecdsene";
String output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
numRails = 3;
correctOutput = "MAOOESGTECDSENE";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test rail length encoding
inputString = "messagetoencode";
numRails = 5;
correctOutput = "moetesenesgcdao";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no symbol rail length encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
numRails = 3;
correctOutput = "maooesg te cdsene";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
numRails = 3;
correctOutput = "maooesgtecdsene";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
numRails = 3;
correctOutput = "Maooesg tecdsene";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no symbol mixedCase, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in rail length for good measure
inputString = "Message to^encode";
numRails = 5;
correctOutput = "Moetese nesgcdao";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed no symbol mixedCase, whitespace, symbol, railLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -231,47 +231,47 @@ public class TestRailFence{
int numRails = 3;
String correctOutput = "MAOOESGTECDSENE";
String output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
numRails = 3;
correctOutput = "MAOOESGTECDSENE";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test rail length encoding
inputString = "messagetoencode";
numRails = 5;
correctOutput = "MOETESENESGCDAO";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed secure rail length encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
numRails = 3;
correctOutput = "MAOOESGTECDSENE";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to+encode";
numRails = 3;
correctOutput = "MAOOESGTECDSENE";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
numRails = 3;
correctOutput = "MAOOESGTECDSENE";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed secure mixedCase, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in rail length for good measure
inputString = "Message to^encode";
numRails = 5;
correctOutput = "MOETESENESGCDAO";
output = cipher.encode(numRails, inputString);
assertEquals("RailFence failed secure mixedCase, whitespace, symbol, railLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -284,47 +284,47 @@ public class TestRailFence{
int numRails = 3;
String correctOutput = "messagetoencode";
String output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MAOOESGTECDSENE";
numRails = 3;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test rail length decoding
inputString = "moetesenesgcdao";
numRails = 5;
correctOutput = "messagetoencode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed rail length decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "maooesg te cdsene";
numRails = 3;
correctOutput = "message to encode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "maooesg*te+cdsene";
numRails = 3;
correctOutput = "message*to+encode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Maooesg te^cdsene";
numRails = 3;
correctOutput = "Message to^encode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed mixedCase, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in rail length for good measure
inputString = "Moetese ne^sgcdao";
numRails = 5;
correctOutput = "Message to^encode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed mixedCase, whitespace, symbol, railLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -336,47 +336,47 @@ public class TestRailFence{
int numRails = 3;
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MAOOESGTECDSENE";
numRails = 3;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test rail length decoding
inputString = "moetesenesgcdao";
numRails = 5;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no capital rail length decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "maooesg te cdsene";
numRails = 3;
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "maooesg*te+cdsene";
numRails = 3;
correctOutput = "MESSAGE*TO+ENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Maooesg te^cdsene";
numRails = 3;
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no capital mixedCase, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in rail length for good measure
inputString = "Moetese ne^sgcdao";
numRails = 5;
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no capital mixedCase, whitespace, symbol, railLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -388,47 +388,47 @@ public class TestRailFence{
int numRails = 3;
String correctOutput = "messagetoencode";
String output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MAOOESGTECDSENE";
numRails = 3;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test rail length decoding
inputString = "moetesenesgcdao";
numRails = 5;
correctOutput = "messagetoencode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no whitespace rail length decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "maooesg te cdsene";
numRails = 3;
correctOutput = "messagetoencode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "maooesg*te+cdsene";
numRails = 3;
correctOutput = "message*to+encode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Maooesg te^cdsene";
numRails = 3;
correctOutput = "Messageto^encode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no whitespace mixedCase, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in rail length for good measure
inputString = "Moetese ne^sgcdao";
numRails = 5;
correctOutput = "Messageto^encode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no whitespace mixedCase, whitespace, symbol, railLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -440,47 +440,47 @@ public class TestRailFence{
int numRails = 3;
String correctOutput = "messagetoencode";
String output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MAOOESGTECDSENE";
numRails = 3;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test rail length decoding
inputString = "moetesenesgcdao";
numRails = 5;
correctOutput = "messagetoencode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no symbol rail length decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "maooesg te cdsene";
numRails = 3;
correctOutput = "message to encode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "maooesg*te+cdsene";
numRails = 3;
correctOutput = "messagetoencode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Maooesg te^cdsene";
numRails = 3;
correctOutput = "Message toencode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no symbol mixedCase, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in rail length for good measure
inputString = "Moetese ne^sgcdao";
numRails = 5;
correctOutput = "Message toencode";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed no symbol mixedCase, whitespace, symbol, railLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -492,46 +492,46 @@ public class TestRailFence{
int numRails = 3;
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "MAOOESGTECDSENE";
numRails = 3;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test rail length decoding
inputString = "moetesenesgcdao";
numRails = 5;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed secure rail length decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "maooesg te cdsene";
numRails = 3;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "maooesg*te+cdsene";
numRails = 3;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Maooesg te^cdsene";
numRails = 3;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed secure mixedCase, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in rail length for good measure
inputString = "Moetese ne^sgcdao";
numRails = 5;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(numRails, inputString);
assertEquals("RailFence failed secure mixedCase, whitespace, symbol, railLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}

146
src/test/java/com/mattrixwv/cipherstream/polysubstitution/TestTrifid.java
View File

@@ -1,13 +1,13 @@
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/polySubstitution/TestTrifid.java
//Mattrixwv
// Created: 03-03-22
//Modified: 03-03-22
//Modified: 07-09-22
package com.mattrixwv.cipherstream.polysubstitution;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import com.mattrixwv.cipherstream.exceptions.InvalidBaseException;
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
@@ -25,13 +25,13 @@ public class TestTrifid{
String keyword = "keyword";
String correctOutput = "gqdokpdodljvflf";
String output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "GQDOKPDODLJVFLF";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test groupLength encoding
inputString = "messagetoencode";
@@ -39,35 +39,35 @@ public class TestTrifid{
int groupLength = 3;
correctOutput = "gpjqdvdofodlklf";
output = cipher.encode(keyword, groupLength, inputString);
assertEquals("Trifid failed groupLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "gqdokpd od ljvflf";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to-encode";
keyword = "keyword";
correctOutput = "gqdokpd*od-ljvflf";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Gqdokpd od^ljvflf";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in groupLength for good measure
inputString = "Message to^encode";
keyword = "keyword";
groupLength = 3;
correctOutput = "Gpjqdvd of^odlklf";
output = cipher.encode(keyword, groupLength, inputString);
assertEquals("Trifid failed mixed case, whitespace, symbol, groupLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -79,13 +79,13 @@ public class TestTrifid{
String keyword = "keyword";
String correctOutput = "GQDOKPDODLJVFLF";
String output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no capital lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "GQDOKPDODLJVFLF";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no capital uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test groupLength encoding
inputString = "messagetoencode";
@@ -93,35 +93,35 @@ public class TestTrifid{
int groupLength = 3;
correctOutput = "GPJQDVDOFODLKLF";
output = cipher.encode(keyword, groupLength, inputString);
assertEquals("Trifid failed no capital groupLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "GQDOKPD OD LJVFLF";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no capital whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to-encode";
keyword = "keyword";
correctOutput = "GQDOKPD*OD-LJVFLF";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no capital symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "GQDOKPD OD^LJVFLF";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no capital mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in groupLength for good measure
inputString = "Message to^encode";
keyword = "keyword";
groupLength = 3;
correctOutput = "GPJQDVD OF^ODLKLF";
output = cipher.encode(keyword, groupLength, inputString);
assertEquals("Trifid failed no capital mixed case, whitespace, symbol, groupLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -133,13 +133,13 @@ public class TestTrifid{
String keyword = "keyword";
String correctOutput = "gqdokpdodljvflf";
String output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no whitespace lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "GQDOKPDODLJVFLF";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no whitespace uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test groupLength encoding
inputString = "messagetoencode";
@@ -147,35 +147,35 @@ public class TestTrifid{
int groupLength = 3;
correctOutput = "gpjqdvdofodlklf";
output = cipher.encode(keyword, groupLength, inputString);
assertEquals("Trifid failed no whitespace groupLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "gqdokpdodljvflf";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no whitespace whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to-encode";
keyword = "keyword";
correctOutput = "gqdokpd*od-ljvflf";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no whitespace symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Gqdokpdod^ljvflf";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no whitespace mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in groupLength for good measure
inputString = "Message to^encode";
keyword = "keyword";
groupLength = 3;
correctOutput = "Gpjqdvdof^odlklf";
output = cipher.encode(keyword, groupLength, inputString);
assertEquals("Trifid failed no whitespace mixed case, whitespace, symbol, groupLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -187,13 +187,13 @@ public class TestTrifid{
String keyword = "keyword";
String correctOutput = "gqdokpdodljvflf";
String output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no symbol lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "GQDOKPDODLJVFLF";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no symbol uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test groupLength encoding
inputString = "messagetoencode";
@@ -201,35 +201,35 @@ public class TestTrifid{
int groupLength = 3;
correctOutput = "gpjqdvdofodlklf";
output = cipher.encode(keyword, groupLength, inputString);
assertEquals("Trifid failed no symbol groupLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "gqdokpd od ljvflf";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no symbol whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to-encode";
keyword = "keyword";
correctOutput = "gqdokpdodljvflf";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no symbol symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "Gqdokpd odljvflf";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed no symbol mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in groupLength for good measure
inputString = "Message to^encode";
keyword = "keyword";
groupLength = 3;
correctOutput = "Gpjqdvd ofodlklf";
output = cipher.encode(keyword, groupLength, inputString);
assertEquals("Trifid failed no symbol mixed case, whitespace, symbol, groupLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -241,13 +241,13 @@ public class TestTrifid{
String keyword = "keyword";
String correctOutput = "GQDOKPDODLJVFLF";
String output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed secure lowercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase encoding
inputString = "MESSAGETOENCODE";
keyword = "keyword";
correctOutput = "GQDOKPDODLJVFLF";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed secure uppercase encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test groupLength encoding
inputString = "messagetoencode";
@@ -255,35 +255,35 @@ public class TestTrifid{
int groupLength = 3;
correctOutput = "GPJQDVDOFODLKLF";
output = cipher.encode(keyword, groupLength, inputString);
assertEquals("Trifid failed secure groupLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace encoding
inputString = "message to encode";
keyword = "keyword";
correctOutput = "GQDOKPDODLJVFLF";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed secure whitespace encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol encoding
inputString = "message*to-encode";
keyword = "keyword";
correctOutput = "GQDOKPDODLJVFLF";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed secure symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol encoding
inputString = "Message to^encode";
keyword = "keyword";
correctOutput = "GQDOKPDODLJVFLF";
output = cipher.encode(keyword, inputString);
assertEquals("Trifid failed secure mixed case, whitespace, symbol encoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in groupLength for good measure
inputString = "Message to^encode";
keyword = "keyword";
groupLength = 3;
correctOutput = "GPJQDVDOFODLKLF";
output = cipher.encode(keyword, groupLength, inputString);
assertEquals("Trifid failed secure mixed case, whitespace, symbol, groupLength encoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@@ -296,13 +296,13 @@ public class TestTrifid{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "GQDOKPDODLJVFLF";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test groupLength decoding
inputString = "gpjqdvdofodlklf";
@@ -310,35 +310,35 @@ public class TestTrifid{
int groupLength = 3;
correctOutput = "messagetoencode";
output = cipher.decode(keyword, groupLength, inputString);
assertEquals("Trifid failed groupLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "gqdokpd od ljvflf";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "gqdokpd*od-ljvflf";
keyword = "keyword";
correctOutput = "message*to-encode";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Gqdokpd od^ljvflf";
keyword = "keyword";
correctOutput = "Message to^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in groupLength for good measure
inputString = "Gpjqdvd of^odlklf";
keyword = "keyword";
groupLength = 3;
correctOutput = "Message to^encode";
output = cipher.decode(keyword, groupLength, inputString);
assertEquals("Trifid failed mixed case, whitespace, symbol, groupLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -350,13 +350,13 @@ public class TestTrifid{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no capital lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "GQDOKPDODLJVFLF";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no capital uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test groupLength decoding
inputString = "gpjqdvdofodlklf";
@@ -364,35 +364,35 @@ public class TestTrifid{
int groupLength = 3;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, groupLength, inputString);
assertEquals("Trifid failed no capital groupLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "gqdokpd od ljvflf";
keyword = "keyword";
correctOutput = "MESSAGE TO ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no capital whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "gqdokpd*od-ljvflf";
keyword = "keyword";
correctOutput = "MESSAGE*TO-ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no capital symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Gqdokpd od^ljvflf";
keyword = "keyword";
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no capital mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in groupLength for good measure
inputString = "Gpjqdvd of^odlklf";
keyword = "keyword";
groupLength = 3;
correctOutput = "MESSAGE TO^ENCODE";
output = cipher.decode(keyword, groupLength, inputString);
assertEquals("Trifid failed no capital mixed case, whitespace, symbol, groupLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -404,13 +404,13 @@ public class TestTrifid{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no whitespace lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "GQDOKPDODLJVFLF";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no whitespace uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test groupLength decoding
inputString = "gpjqdvdofodlklf";
@@ -418,35 +418,35 @@ public class TestTrifid{
int groupLength = 3;
correctOutput = "messagetoencode";
output = cipher.decode(keyword, groupLength, inputString);
assertEquals("Trifid failed no whitespace groupLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "gqdokpd od ljvflf";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no whitespace whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "gqdokpd*od-ljvflf";
keyword = "keyword";
correctOutput = "message*to-encode";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no whitespace symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Gqdokpd od^ljvflf";
keyword = "keyword";
correctOutput = "Messageto^encode";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no whitespace mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in groupLength for good measure
inputString = "Gpjqdvd of^odlklf";
keyword = "keyword";
groupLength = 3;
correctOutput = "Messageto^encode";
output = cipher.decode(keyword, groupLength, inputString);
assertEquals("Trifid failed no whitespace mixed case, whitespace, symbol, groupLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -458,13 +458,13 @@ public class TestTrifid{
String keyword = "keyword";
String correctOutput = "messagetoencode";
String output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no symbol lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "GQDOKPDODLJVFLF";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no symbol uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test groupLength decoding
inputString = "gpjqdvdofodlklf";
@@ -472,35 +472,35 @@ public class TestTrifid{
int groupLength = 3;
correctOutput = "messagetoencode";
output = cipher.decode(keyword, groupLength, inputString);
assertEquals("Trifid failed no symbol groupLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "gqdokpd od ljvflf";
keyword = "keyword";
correctOutput = "message to encode";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no symbol whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "gqdokpd*od-ljvflf";
keyword = "keyword";
correctOutput = "messagetoencode";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no symbol symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Gqdokpd od^ljvflf";
keyword = "keyword";
correctOutput = "Message toencode";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed no symbol mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in groupLength for good measure
inputString = "Gpjqdvd of^odlklf";
keyword = "keyword";
groupLength = 3;
correctOutput = "Message toencode";
output = cipher.decode(keyword, groupLength, inputString);
assertEquals("Trifid failed no symbol mixed case, whitespace, symbol, groupLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
@Test
@@ -512,13 +512,13 @@ public class TestTrifid{
String keyword = "keyword";
String correctOutput = "MESSAGETOENCODE";
String output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed secure lowercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test uppercase decoding
inputString = "GQDOKPDODLJVFLF";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed secure uppercase decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test groupLength decoding
inputString = "gpjqdvdofodlklf";
@@ -526,34 +526,34 @@ public class TestTrifid{
int groupLength = 3;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, groupLength, inputString);
assertEquals("Trifid failed secure groupLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test whitespace decoding
inputString = "gqdokpd od ljvflf";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed secure whitespace decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test symbol decoding
inputString = "gqdokpd*od-ljvflf";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed secure symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Test mixed case, whitespace, symbol decoding
inputString = "Gqdokpd od^ljvflf";
keyword = "keyword";
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, inputString);
assertEquals("Trifid failed secure mixed case, whitespace, symbol decoding.", correctOutput, output);
assertEquals(correctOutput, output);
//Throw in groupLength for good measure
inputString = "Gpjqdvd of^odlklf";
keyword = "keyword";
groupLength = 3;
correctOutput = "MESSAGETOENCODE";
output = cipher.decode(keyword, groupLength, inputString);
assertEquals("Trifid failed secure mixed case, whitespace, symbol, groupLength decoding.", correctOutput, output);
assertEquals(correctOutput, output);
}
}