Fixed sonarqube findings
This commit is contained in:
@@ -0,0 +1,450 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/combination/TestADFGVX.java
|
||||
//Mattrixwv
|
||||
// Created: 01-26-22
|
||||
//Modified: 01-26-22
|
||||
package com.mattrixwv.cipherstream.combination;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestADFGVX{
|
||||
@Test
|
||||
public void testEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGVX cipher = new ADFGVX(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "axgvdavfxgagfaafagaaxdxfgdagda";
|
||||
String output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "axgvdavfxgagfa afag aaxdxfgdagda";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "axgvdavfxgagfa*afag+aaxdxfgdagda";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
inputString = "Message to-encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AXgvdavfxgagfa afag-aaxdxfgdagda";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed mixed case, whitespace, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
|
||||
String output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no capital lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAGAGADFAGAXXD AXDX ADAFAFXDDGDF";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no capital whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAGAGADFAGAXXD*AXDX+ADAFAFXDDGDF-";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no capital symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
String output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "aagagadfagaxxd*axdx+adafafxddgdf-";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAgagadfagaxxdaxdx^adafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace mixed case, whitesapce, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
String output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "aagagadfagaxxd axdx adafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAgagadfagaxxd axdxadafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol mixed case, whitesapce, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
|
||||
String output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed secure lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed secure whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed secure symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed secure mixed case, whitesapce, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGVX cipher = new ADFGVX(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "axgvdavfxgagfaafagaaxdxfgdagda";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "axgvdavfxgagfa afag aaxdxfgdagda";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "message to encode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "axgvdavfxgagfa*afag+aaxdxfgdagda-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "message*to+encode-";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
inputString = "AXgvdavfxgagfa afag^aaxdxfgdagda";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "Message to^encode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed mixed case, whitespace, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGVX cipher = new ADFGVX(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "axgvdavfxgagfaafagaaxdxfgdagda";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed no capital lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "axgvdavfxgagfa afag aaxdxfgdagda";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGE TO ENCODE";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed no capital whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "axgvdavfxgagfa*afag+aaxdxfgdagda-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGE*TO+ENCODE-";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed no capital symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
inputString = "AXgvdavfxgagfa afag^aaxdxfgdagda";
|
||||
squareKeyword = "SquareKeyword";
|
||||
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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGVX cipher = new ADFGVX(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "axgvdavfxgagfaafagaaxdxfgdagda";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "axgvdavfxgagfa afag aaxdxfgdagda";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed no whitespace whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "axgvdavfxgagfa*afag+aaxdxfgdagda-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "message*to+encode-";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed no whitespace symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
inputString = "AXgvdavfxgagfa afag^aaxdxfgdagda";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "Messageto^encode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed no whitespace mixed case, whitespace, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGVX cipher = new ADFGVX(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "axgvdavfxgagfaafagaaxdxfgdagda";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "axgvdavfxgagfa afag aaxdxfgdagda";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "message to encode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed no symbol whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "axgvdavfxgagfa*afag+aaxdxfgdagda-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed no symbol symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
inputString = "AXgvdavfxgagfa afag^aaxdxfgdagda";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "Message toencode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed no symbol mixed case, whitespace, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGVX cipher = new ADFGVX(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "axgvdavfxgagfaafagaaxdxfgdagda";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed secure lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "axgvdavfxgagfa afag aaxdxfgdagda";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed secure whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "axgvdavfxgagfa*afag+aaxdxfgdagda-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed secure symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
inputString = "AXgvdavfxgagfa afag^aaxdxfgdagda";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGVX failed secure mixed case, whitespace, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,450 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamjava/combination/TestADFGX.java
|
||||
//Mattrixwv
|
||||
// Created: 01-25-22
|
||||
//Modified: 01-25-22
|
||||
package com.mattrixwv.cipherstream.combination;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestADFGX{
|
||||
@Test
|
||||
public void testEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
String output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "aagagadfagaxxd axdx adafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "aagagadfagaxxd*axdx+adafafxddgdf-";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAgagadfagaxxd axdx^adafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed mixed case, whitesapce, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
|
||||
String output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no capital lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAGAGADFAGAXXD AXDX ADAFAFXDDGDF";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no capital whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAGAGADFAGAXXD*AXDX+ADAFAFXDDGDF-";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no capital symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
String output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "aagagadfagaxxd*axdx+adafafxddgdf-";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAgagadfagaxxdaxdx^adafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace mixed case, whitesapce, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
String output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "aagagadfagaxxd axdx adafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAgagadfagaxxd axdxadafafxddgdf";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol mixed case, whitesapce, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
|
||||
String output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "AAGAGADFAGAXXDAXDXADAFAFXDDGDF";
|
||||
output = cipher.encode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed mixed case, whitesapce, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "aagagadfagaxxd axdx adafafxddgdf";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "message to encode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "aagagadfagaxxd*axdx+adafafxddgdf-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "message*to+encode-";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
inputString = "AAgagadfagaxxd axdx^adafafxddgdf";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "Message to^encode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed mixed case, whitesapce, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no capital lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "aagagadfagaxxd axdx adafafxddgdf";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGE TO ENCODE";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no capital whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "aagagadfagaxxd*axdx+adafafxddgdf-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGE*TO+ENCODE-";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no capital symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
inputString = "AAgagadfagaxxd axdx^adafafxddgdf";
|
||||
squareKeyword = "SquareKeyword";
|
||||
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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "aagagadfagaxxd axdx adafafxddgdf";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "aagagadfagaxxd*axdx+adafafxddgdf-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "message*to+encode-";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
inputString = "AAgagadfagaxxd axdx^adafafxddgdf";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "Messageto^encode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no whitespace mixed case, whitesapce, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "aagagadfagaxxd axdx adafafxddgdf";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "message to encode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "aagagadfagaxxd*axdx+adafafxddgdf-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
inputString = "AAgagadfagaxxd axdx^adafafxddgdf";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "Message toencode";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed no symbol mixed case, whitesapce, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
ADFGX cipher = new ADFGX(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "aagagadfagaxxdaxdxadafafxddgdf";
|
||||
String squareKeyword = "SquareKeyword";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed secure lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "aagagadfagaxxd axdx adafafxddgdf";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed secure whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "aagagadfagaxxd*axdx+adafafxddgdf-";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed secure symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
inputString = "AAgagadfagaxxd axdx^adafafxddgdf";
|
||||
squareKeyword = "SquareKeyword";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(squareKeyword, keyword, inputString);
|
||||
assertEquals("ADFGX failed secure mixed case, whitesapce, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,449 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/polySubstitution/TestAffine.java
|
||||
//Mattrixwv
|
||||
// Created: 01-26-22
|
||||
//Modified: 01-26-22
|
||||
package com.mattrixwv.cipherstream.monosubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestAffine{
|
||||
@Test
|
||||
public void testEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Affine cipher = new Affine(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
int key1 = 5;
|
||||
int key2 = 7;
|
||||
String correctOutput = "pbtthlbyzburzwb";
|
||||
String output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "pbtthlb yz burzwb";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "pbtthlb*yz+burzwb-";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "Pbtthlb yz^burzwb";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed mixed case, whitespace, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Affine cipher = new Affine(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
int key1 = 5;
|
||||
int key2 = 7;
|
||||
String correctOutput = "pbtthlbyzburzwb";
|
||||
String output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no capital lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "pbtthlb yz burzwb";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no capital whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "pbtthlb*yz+burzwb-";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no capital symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
key1 = 5;
|
||||
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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Affine cipher = new Affine(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
int key1 = 5;
|
||||
int key2 = 7;
|
||||
String correctOutput = "pbtthlbyzburzwb";
|
||||
String output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "pbtthlbyzburzwb";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no whitespace whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "pbtthlb*yz+burzwb-";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no whitespace symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "Pbtthlbyz^burzwb";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no whitespace mixed case, whitespace, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Affine cipher = new Affine(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
int key1 = 5;
|
||||
int key2 = 7;
|
||||
String correctOutput = "pbtthlbyzburzwb";
|
||||
String output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "pbtthlb yz burzwb";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no symbol whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "pbtthlbyzburzwb";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no symbol symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "Pbtthlb yzburzwb";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no symbol mixed case, whitespace, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Affine cipher = new Affine(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
int key1 = 5;
|
||||
int key2 = 7;
|
||||
String correctOutput = "pbtthlbyzburzwb";
|
||||
String output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed secure lowercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "pbtthlbyzburzwb";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed secure whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode-";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "pbtthlbyzburzwb";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed secure symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, symbol encoding
|
||||
inputString = "Message to^encode";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "pbtthlbyzburzwb";
|
||||
output = cipher.encode(key1, key2, inputString);
|
||||
assertEquals("Affine failed secure mixed case, whitespace, and symbol encoding.", correctOutput, output);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Affine cipher = new Affine(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "pbtthlbyzburzwb";
|
||||
int key1 = 5;
|
||||
int key2 = 7;
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "pbtthlb yz burzwb";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "message to encode";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "pbtthlb*yz+burzwb-";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "message*to+encode-";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, symbol decoding
|
||||
inputString = "Pbtthlb yz^burzwb";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "Message to^encode";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed mixed case, whitespace, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Affine cipher = new Affine(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "pbtthlbyzburzwb";
|
||||
int key1 = 5;
|
||||
int key2 = 7;
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no capital lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "pbtthlb yz burzwb";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "message to encode";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no capital whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "pbtthlb*yz+burzwb-";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "message*to+encode-";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no capital symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, symbol decoding
|
||||
inputString = "Pbtthlb yz^burzwb";
|
||||
key1 = 5;
|
||||
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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Affine cipher = new Affine(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "pbtthlbyzburzwb";
|
||||
int key1 = 5;
|
||||
int key2 = 7;
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "pbtthlb yz burzwb";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no whitespace whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "pbtthlb*yz+burzwb-";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "message*to+encode-";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no whitespace symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, symbol decoding
|
||||
inputString = "Pbtthlb yz^burzwb";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "Messageto^encode";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no whitespace mixed case, whitespace, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Affine cipher = new Affine(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "pbtthlbyzburzwb";
|
||||
int key1 = 5;
|
||||
int key2 = 7;
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "pbtthlb yz burzwb";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "message to encode";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no symbol whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "pbtthlb*yz+burzwb-";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no symbol symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, symbol decoding
|
||||
inputString = "Pbtthlb yz^burzwb";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "Message toencode";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed no symbol mixed case, whitespace, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Affine cipher = new Affine(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "pbtthlbyzburzwb";
|
||||
int key1 = 5;
|
||||
int key2 = 7;
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed secure lowercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "pbtthlb yz burzwb";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed secure whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "pbtthlb*yz+burzwb-";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed secure symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, symbol decoding
|
||||
inputString = "Pbtthlb yz^burzwb";
|
||||
key1 = 5;
|
||||
key2 = 7;
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(key1, key2, inputString);
|
||||
assertEquals("Affine failed secure mixed case, whitespace, and symbol decoding.", correctOutput, output);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,356 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestAtbash.java
|
||||
//Mattrixwv
|
||||
// Created: 07-25-21
|
||||
//Modified: 02-22-22
|
||||
package com.mattrixwv.cipherstream.monosubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
|
||||
|
||||
public class TestAtbash{
|
||||
@Test
|
||||
public void testEncode() throws InvalidInputException{
|
||||
Atbash cipher = new Atbash(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String correctOutput = "nvhhztvglvmxlwv";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
correctOutput = "NVHHZTVGLVMXLWV";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed uppercase encoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
correctOutput = "nvhhztv gl vmxlwv";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode";
|
||||
correctOutput = "nvhhztv*gl+vmxlwv";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed symbol encoding.", 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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidInputException{
|
||||
Atbash cipher = new Atbash(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String correctOutput = "NVHHZTVGLVMXLWV";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no capital lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
correctOutput = "NVHHZTVGLVMXLWV";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no capital uppercase encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode";
|
||||
correctOutput = "NVHHZTV*GL+VMXLWV";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no capital symbol encoding.", 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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidInputException{
|
||||
Atbash cipher = new Atbash(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String correctOutput = "nvhhztvglvmxlwv";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no whitespace lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
correctOutput = "NVHHZTVGLVMXLWV";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no whitespace uppercase encoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
correctOutput = "nvhhztvglvmxlwv";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no whitespace whitespace encoding.", 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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidInputException{
|
||||
Atbash cipher = new Atbash(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String correctOutput = "nvhhztvglvmxlwv";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no symbol lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
correctOutput = "NVHHZTVGLVMXLWV";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no symbol uppercase encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode";
|
||||
correctOutput = "nvhhztvglvmxlwv";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no symbol symbol encoding.", 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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidInputException{
|
||||
Atbash cipher = new Atbash(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String correctOutput = "NVHHZTVGLVMXLWV";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
correctOutput = "NVHHZTVGLVMXLWV";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed secure uppercase encoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
correctOutput = "NVHHZTVGLVMXLWV";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed secure whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode";
|
||||
correctOutput = "NVHHZTVGLVMXLWV";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed secure symbol encoding.", 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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidInputException{
|
||||
Atbash cipher = new Atbash(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "nvhhztvglvmxlwv";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "NVHHZTVGLVMXLWV";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed uppercase decoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "nvhhztv gl vmxlwv";
|
||||
correctOutput = "message to encode";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "nvhhztv*gl+vmxlwv";
|
||||
correctOutput = "message*to+encode";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed symbol decoding.", 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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidInputException{
|
||||
Atbash cipher = new Atbash(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "nvhhztvglvmxlwv";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no capital lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "NVHHZTVGLVMXLWV";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no capital uppercase decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "nvhhztv*gl+vmxlwv";
|
||||
correctOutput = "MESSAGE*TO+ENCODE";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no capital symbol decoding.", 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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidInputException{
|
||||
Atbash cipher = new Atbash(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "nvhhztvglvmxlwv";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no whitespace lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "NVHHZTVGLVMXLWV";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no whitespace uppercase decoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "nvhhztv gl vmxlwv";
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no whitespace whitespace decoding.", 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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidInputException{
|
||||
Atbash cipher = new Atbash(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "nvhhztvglvmxlwv";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no symbol lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "NVHHZTVGLVMXLWV";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no symbol uppercase decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "nvhhztv*gl+vmxlwv";
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed no symbol symbol decoding.", 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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidInputException{
|
||||
Atbash cipher = new Atbash(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "nvhhztvglvmxlwv";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "NVHHZTVGLVMXLWV";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed secure uppercase decoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "nvhhztv gl vmxlwv";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed secure whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "nvhhztv*gl+vmxlwv";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Atbash failed secure symbol decoding.", 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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,443 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestAutokey.java
|
||||
//Mattrixwv
|
||||
// Created: 07-26-21
|
||||
//Modified: 02-22-22
|
||||
package com.mattrixwv.cipherstream.monosubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestAutokey{
|
||||
@Test
|
||||
public void testEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Autokey cipher = new Autokey(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "wiqooxhfswfcuhx";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Autokey failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "WIQOOXHFSWFCUHX";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Autokey failed uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Autokey cipher = new Autokey(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "WIQOOXHFSWFCUHX";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Autokey failed no capital lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Autokey cipher = new Autokey(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "wiqooxhfswfcuhx";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Autokey failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Autokey cipher = new Autokey(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "wiqooxhfswfcuhx";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Autokey failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Autokey cipher = new Autokey(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "WIQOOXHFSWFCUHX";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Autokey failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "WIQOOXHFSWFCUHX";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Autokey failed secure uppercase encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode";
|
||||
keyword = "keyword";
|
||||
correctOutput = "WIQOOXHFSWFCUHX";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Autokey failed secure symbol encoding.", 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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Autokey cipher = new Autokey(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhfswfcuhx";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Autokey failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "WIQOOXHFSWFCUHX";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Autokey failed uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Autokey cipher = new Autokey(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "WIQOOXHFSWFCUHX";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Autokey failed no capital lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Autokey cipher = new Autokey(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhfswfcuhx";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Autokey failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Autokey cipher = new Autokey(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhfswfcuhx";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Autokey failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Autokey cipher = new Autokey(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "WIQOOXHFSWFCUHX";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Autokey failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "WIQOOXHFSWFCUHX";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Autokey failed secure uppercase decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "WIQOOXH*FS+WFCUHX";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Autokey failed secure symbol decoding.", 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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testKeyword() throws InvalidKeywordException{
|
||||
Autokey cipher = new Autokey();
|
||||
|
||||
//Test keyword with whitespace
|
||||
String keyword = "x y z ";
|
||||
String correctOutput = "XYZ";
|
||||
cipher.setKeyword(keyword);
|
||||
String output = cipher.getKeyword();
|
||||
assertEquals("Autokey failed keyword with whitespace.", correctOutput, output);
|
||||
|
||||
|
||||
//Test keyword with symbol
|
||||
keyword = "x-y@z0";
|
||||
correctOutput = "XYZ";
|
||||
cipher.setKeyword(keyword);
|
||||
output = cipher.getKeyword();
|
||||
assertEquals("Autokey failed keyword with symbol.", correctOutput, output);
|
||||
|
||||
|
||||
//Test keyword with mixed case
|
||||
keyword = "xYz";
|
||||
correctOutput = "XYZ";
|
||||
cipher.setKeyword(keyword);
|
||||
output = cipher.getKeyword();
|
||||
assertEquals("Autokey failed keyword with mixed case.", 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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/TestBaconian.java
|
||||
//Mattrixwv
|
||||
// Created: 01-12-22
|
||||
//Modified: 01-12-22
|
||||
package com.mattrixwv.cipherstream.monosubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
|
||||
|
||||
public class TestBaconian{
|
||||
@Test
|
||||
public void testEncode() throws InvalidInputException{
|
||||
Baconian cipher = new Baconian(true);
|
||||
|
||||
//Test lowercase encoding
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testEncodeNoCapital() throws InvalidInputException{
|
||||
Baconian cipher = new Baconian(false);
|
||||
|
||||
//Test lowercase encoding
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidCharacterException, InvalidInputException{
|
||||
Baconian cipher = new Baconian(true);
|
||||
|
||||
//Test lowercase decoding
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testDecodeNoCapital() throws InvalidCharacterException, InvalidInputException{
|
||||
Baconian cipher = new Baconian(false);
|
||||
|
||||
//Test lowercase decoding
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,284 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestBaseX.java
|
||||
//Mattrixwv
|
||||
// Created: 01-08-22
|
||||
//Modified: 01-09-22
|
||||
package com.mattrixwv.cipherstream.monosubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidBaseException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
|
||||
|
||||
public class TestBaseX{
|
||||
@Test
|
||||
public void testBinaryEncode() throws InvalidBaseException, InvalidInputException{
|
||||
BaseX cipher = new BaseX();
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "a";
|
||||
String correctOutput = "1100001";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Binary failed binary lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "A";
|
||||
correctOutput = "1000001";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Binary failed binary uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testOctalEncode() throws InvalidBaseException, InvalidInputException{
|
||||
BaseX cipher = new BaseX(8);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "a";
|
||||
String correctOutput = "141";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Binary failed octal lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "A";
|
||||
correctOutput = "101";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Binary failed octal uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testDecimalEncode() throws InvalidBaseException, InvalidInputException{
|
||||
BaseX cipher = new BaseX(10);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "a";
|
||||
String correctOutput = "97";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Binary failed decimal lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "A";
|
||||
correctOutput = "65";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Binary failed decimal uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testHexEncode() throws InvalidBaseException, InvalidInputException{
|
||||
BaseX cipher = new BaseX(16);
|
||||
|
||||
//Test lowercase encoding
|
||||
String correctOutput = "61";
|
||||
String inputString = "a";
|
||||
String output = cipher.encode(inputString);
|
||||
assertEquals("Binary failed hex lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "A";
|
||||
correctOutput = "41";
|
||||
output = cipher.encode(inputString);
|
||||
assertEquals("Binary failed hex uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testBinaryDecode() throws InvalidCharacterException, InvalidBaseException, InvalidInputException{
|
||||
BaseX cipher = new BaseX();
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "1100001";
|
||||
String correctOutput = "a";
|
||||
String output = cipher.decode(inputString);
|
||||
assertEquals("Binary failed binary lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "1000001";
|
||||
correctOutput = "A";
|
||||
output = cipher.decode(inputString);
|
||||
assertEquals("Binary failed binary uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testOctalDecode() throws InvalidCharacterException, InvalidBaseException, InvalidInputException{
|
||||
BaseX cipher = new BaseX(8);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "141";
|
||||
String correctOutput = "a";
|
||||
String output = cipher.decode(inputString);
|
||||
assertEquals("Binary failed octal lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "101";
|
||||
correctOutput = "A";
|
||||
output = cipher.decode(inputString);
|
||||
assertEquals("Binary failed octal uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testDecimalDecode() throws InvalidCharacterException, InvalidBaseException, InvalidInputException{
|
||||
BaseX cipher = new BaseX(10);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "97";
|
||||
String correctOutput = "a";
|
||||
String output = cipher.decode(inputString);
|
||||
assertEquals("Binary failed decimal lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "65";
|
||||
correctOutput = "A";
|
||||
output = cipher.decode(inputString);
|
||||
assertEquals("Binary failed decimal uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testHexDecode() throws InvalidCharacterException, InvalidBaseException, InvalidInputException{
|
||||
BaseX cipher = new BaseX(16);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "61";
|
||||
String correctOutput = "a";
|
||||
String output = cipher.decode(inputString);
|
||||
assertEquals("Binary failed hex lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "41";
|
||||
correctOutput = "A";
|
||||
output = cipher.decode(inputString);
|
||||
assertEquals("Binary failed hex uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,407 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestBeaufort.java
|
||||
//Mattrixwv
|
||||
// Created: 02-23-22
|
||||
//Modified: 02-23-22
|
||||
package com.mattrixwv.cipherstream.monosubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestBeaufort{
|
||||
@Test
|
||||
public void testEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Beaufort cipher = new Beaufort(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "yageolzrqujmdag";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Beaufort failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "YAGEOLZRQUJMDAG";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Beaufort failed uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Beaufort cipher = new Beaufort(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "YAGEOLZRQUJMDAG";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Beaufort failed no capital lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Beaufort cipher = new Beaufort(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "yageolzrqujmdag";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Beaufort failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Beaufort cipher = new Beaufort(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "yageolzrqujmdag";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Beaufort failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalwhitespaceSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Beaufort cipher = new Beaufort(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "YAGEOLZRQUJMDAG";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Beaufort failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "YAGEOLZRQUJMDAG";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Beaufort failed secure uppercase encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode";
|
||||
keyword = "keyword";
|
||||
correctOutput = "YAGEOLZRQUJMDAG";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Beaufort failed secure symbol encoding.", 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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Beaufort cipher = new Beaufort(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "yageolzrqujmdag";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Beaufort failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "YAGEOLZRQUJMDAG";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Beaufort failed uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Beaufort cipher = new Beaufort(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "yageolzrqujmdag";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Beaufort failed no capital lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Beaufort cipher = new Beaufort(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "yageolzrqujmdag";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Beaufort failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Beaufort cipher = new Beaufort(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "yageolzrqujmdag";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Beaufort failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Beaufort cipher = new Beaufort(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "yageolzrqujmdag";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Beaufort failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "YAGEOLZRQUJMDAG";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Beaufort failed secure uppercase decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "yageolz*rq+ujmdag";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Beaufort failed secure symbol decoding.", 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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,628 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/TestCaesar.java
|
||||
//Matthew Ellison
|
||||
// Created: 07-25-21
|
||||
//Modified: 01-04-22
|
||||
package com.mattrixwv.cipherstream.monosubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
|
||||
|
||||
public class TestCaesar{
|
||||
@Test
|
||||
public void testEncode() throws InvalidInputException{
|
||||
Caesar cipher = new Caesar(true, true, true);
|
||||
|
||||
//Test lowercase encode
|
||||
String input = "abc";
|
||||
int shift = 3;
|
||||
String correctOutput = "def";
|
||||
String output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
input = "ABC";
|
||||
shift = 3;
|
||||
correctOutput = "DEF";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Ceasar failed uppercase encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test out of bounds shift encoding
|
||||
input = "abc";
|
||||
shift = 29;
|
||||
correctOutput = "def";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed out of bounds shift encoding.", 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);
|
||||
|
||||
|
||||
//Test whitespace encoding
|
||||
input = "abc def";
|
||||
shift = 3;
|
||||
correctOutput = "def ghi";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed whitespace encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test symbol encoding
|
||||
input = "abc-def@";
|
||||
shift = 3;
|
||||
correctOutput = "def-ghi@";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed symbol encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
input = "The quick brown fox jumps over - the lazy dog";
|
||||
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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidInputException{
|
||||
Caesar cipher = new Caesar(false, true, true);
|
||||
|
||||
//Test lowercase encode
|
||||
String input = "abc";
|
||||
int shift = 3;
|
||||
String correctOutput = "def";
|
||||
String output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no capital lowercase encoding.", 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);
|
||||
|
||||
|
||||
//Test out of bounds shift encoding
|
||||
input = "abc";
|
||||
shift = 29;
|
||||
correctOutput = "def";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no capital out of bounds shift encoding.", 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);
|
||||
|
||||
|
||||
//Test whitespace encoding
|
||||
input = "abc def";
|
||||
shift = 3;
|
||||
correctOutput = "def ghi";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no capital whitespace encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test symbol decoding
|
||||
input = "abc-def@";
|
||||
shift = 3;
|
||||
correctOutput = "def-ghi@";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no capital symbol encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
input = "The quick brown fox jumps over - the lazy dog";
|
||||
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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidInputException{
|
||||
Caesar cipher = new Caesar(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String input = "abc";
|
||||
int shift = 3;
|
||||
String correctOutput = "def";
|
||||
String output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
|
||||
//Test out of bounds shift encoding
|
||||
input = "abc";
|
||||
shift = 29;
|
||||
correctOutput = "def";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no whitespace out of bounds shift encoding.", 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);
|
||||
|
||||
|
||||
//Test whitespace encoding
|
||||
input = "abc def";
|
||||
shift = 3;
|
||||
correctOutput = "defghi";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no whitespace whitespace encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test symbol encoding
|
||||
input = "abc-def@";
|
||||
shift = 3;
|
||||
correctOutput = "def-ghi@";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no whitespace symbol encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Testing mixed case, whitespace, and symbol encoding
|
||||
input = "The quick brown fox jumps over - the lazy dog";
|
||||
shift = 23;
|
||||
correctOutput = "Qebnrfzhyoltkclugrjmplsbo-qebixwvald";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no whitespace mixed case, whitespace, and symbol encoding.", 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);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidInputException{
|
||||
Caesar cipher = new Caesar(true, true, false);
|
||||
|
||||
//Test lowercase encode
|
||||
String input = "abc";
|
||||
int shift = 3;
|
||||
String correctOutput = "def";
|
||||
String output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no symbol lowercase encoding.", 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);
|
||||
|
||||
|
||||
//Test out of bounds shift encoding
|
||||
input = "abc";
|
||||
shift = 29;
|
||||
correctOutput = "def";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no symbol out of bounds shift encoding.", 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);
|
||||
|
||||
|
||||
//Test whitespace encoding
|
||||
input = "abc def";
|
||||
shift = 3;
|
||||
correctOutput = "def ghi";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed no symbol whitespace encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test symbol decoding
|
||||
input = "abc-def@";
|
||||
shift = 3;
|
||||
correctOutput = "defghi";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed symbol encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
input = "The quick brown fox jumps over - the lazy dog";
|
||||
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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidInputException{
|
||||
Caesar cipher = new Caesar(false, false, false);
|
||||
|
||||
//Test lowercase encode
|
||||
String input = "abc";
|
||||
int shift = 3;
|
||||
String correctOutput = "def";
|
||||
String output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
input = "ABC";
|
||||
shift = 3;
|
||||
correctOutput = "def";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Ceasar failed secure uppercase encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test out of bounds shift encoding
|
||||
input = "abc";
|
||||
shift = 29;
|
||||
correctOutput = "def";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed secure out of bounds shift encoding.", 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);
|
||||
|
||||
|
||||
//Test whitespace encoding
|
||||
input = "abc def";
|
||||
shift = 3;
|
||||
correctOutput = "defghi";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed secure whitespace encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test symbol encoding
|
||||
input = "abc-def@";
|
||||
shift = 3;
|
||||
correctOutput = "defghi";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed secure symbol encoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test mixed case, whitespace, and symbol encoding
|
||||
input = "The quick brown fox jumps over - the lazy dog";
|
||||
shift = 23;
|
||||
correctOutput = "qebnrfzhyoltkclugrjmplsboqebixwvald";
|
||||
output = cipher.encode(shift, input);
|
||||
assertEquals("Caesar failed secure mixed case, whitespace, and symbol encoding.", 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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidInputException{
|
||||
Caesar cipher = new Caesar(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String input = "def";
|
||||
int shift = 3;
|
||||
String correctOutput = "abc";
|
||||
String output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
input = "DEF";
|
||||
shift = 3;
|
||||
correctOutput = "ABC";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed uppercase decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test out of bounds shift decoding
|
||||
input = "def";
|
||||
shift = 29;
|
||||
correctOutput = "abc";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed out of bounds shift decoding.", 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);
|
||||
|
||||
|
||||
//Test whitespace decoding
|
||||
input = "def ghi";
|
||||
shift = 3;
|
||||
correctOutput = "abc def";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed whitespace decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test symbol decoding
|
||||
input = "def-ghi@";
|
||||
shift = 3;
|
||||
correctOutput = "abc-def@";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed symbol decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
input = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
|
||||
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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidInputException{
|
||||
Caesar cipher = new Caesar(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String input = "def";
|
||||
int shift = 3;
|
||||
String correctOutput = "abc";
|
||||
String output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no capital lowercase decoding.", 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);
|
||||
|
||||
|
||||
//Test out of bounds shift decoding
|
||||
input = "def";
|
||||
shift = 29;
|
||||
correctOutput = "abc";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no capital out of bounds shift decoding.", 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);
|
||||
|
||||
|
||||
//Test whitespace decoding
|
||||
input = "def ghi";
|
||||
shift = 3;
|
||||
correctOutput = "abc def";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesare failed no capital whitespace decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test symbol decoding
|
||||
input = "def-ghi@";
|
||||
shift = 3;
|
||||
correctOutput = "abc-def@";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no capital symbol decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
input = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
|
||||
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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidInputException{
|
||||
Caesar cipher = new Caesar(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String input = "def";
|
||||
int shift = 3;
|
||||
String correctOutput = "abc";
|
||||
String output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
|
||||
//Test out of bounds shift decoding
|
||||
input = "def";
|
||||
shift = 29;
|
||||
correctOutput = "abc";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no whitespace out of bounds shift decoding.", 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);
|
||||
|
||||
|
||||
//Test whitespace decoding
|
||||
input = "def ghi";
|
||||
shift = 3;
|
||||
correctOutput = "abcdef";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no whitespace whitespace decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test symbol decoding
|
||||
input = "def-ghi@";
|
||||
shift = 3;
|
||||
correctOutput = "abc-def@";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no whitespace symbol decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
input = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
|
||||
shift = 23;
|
||||
correctOutput = "Thequickbrownfoxjumpsover-thelazydog";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no whitespace mixed case, whitespace, and symbol decoding.", 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);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidInputException{
|
||||
Caesar cipher = new Caesar(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String input = "def";
|
||||
int shift = 3;
|
||||
String correctOutput = "abc";
|
||||
String output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no symbol lowercase decoding.", 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);
|
||||
|
||||
|
||||
//Test out of bounds shift decoding
|
||||
input = "def";
|
||||
shift = 29;
|
||||
correctOutput = "abc";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no symbol out of bounds shift decoding.", 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);
|
||||
|
||||
|
||||
//Test whitepace decoding
|
||||
input = "def ghi";
|
||||
shift = 3;
|
||||
correctOutput = "abc def";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no symbol whitespace decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test symbol decoding
|
||||
input = "def-ghi!";
|
||||
shift = 3;
|
||||
correctOutput = "abcdef";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed no symbol symbol decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
input = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
|
||||
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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidInputException{
|
||||
Caesar cipher = new Caesar(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String input = "def";
|
||||
int shift = 3;
|
||||
String correctOutput = "abc";
|
||||
String output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
input = "DEF";
|
||||
shift = 3;
|
||||
correctOutput = "abc";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed secure uppercase decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test out of bounds shift decoding
|
||||
input = "def";
|
||||
shift = 29;
|
||||
correctOutput = "abc";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed secure out of bounds shift decoding.", 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);
|
||||
|
||||
|
||||
//Test whitespace decoding
|
||||
input = "def ghi";
|
||||
shift = 3;
|
||||
correctOutput = "abcdef";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed secure whitespace decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test symbol decoding
|
||||
input = "def-ghi@";
|
||||
shift = 3;
|
||||
correctOutput = "abcdef";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed secure symbol decoding.", correctOutput, output);
|
||||
|
||||
|
||||
//Test mixed case, whitespace, and symbol decoding
|
||||
input = "Qeb nrfzh yoltk clu grjmp lsbo - qeb ixwv ald";
|
||||
shift = 23;
|
||||
correctOutput = "thequickbrownfoxjumpsoverthelazydog";
|
||||
output = cipher.decode(shift, input);
|
||||
assertEquals("Caesar failed secure mixed case, whitespace, and symbol decoding.", 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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,407 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestOneTimePad.java
|
||||
//Mattrixwv
|
||||
// Created: 02-23-22
|
||||
//Modified: 02-23-22
|
||||
package com.mattrixwv.cipherstream.monosubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestOneTimePad{
|
||||
@Test
|
||||
public void testEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
OneTimePad cipher = new OneTimePad(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keywordThatIsTotallyRandom";
|
||||
String correctOutput = "wiqooxhmvegkgws";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keywordThatIsTotallyRandom";
|
||||
correctOutput = "WIQOOXHMVEGKGWS";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
OneTimePad cipher = new OneTimePad(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keywordThatIsTotallyRandom";
|
||||
String correctOutput = "WIQOOXHMVEGKGWS";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed no capital lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
OneTimePad cipher = new OneTimePad(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keywordThatIsTotallyRandom";
|
||||
String correctOutput = "wiqooxhmvegkgws";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
OneTimePad cipher = new OneTimePad(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keywordThatIsTotallyRandom";
|
||||
String correctOutput = "wiqooxhmvegkgws";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
OneTimePad cipher = new OneTimePad(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keywordThatIsTotallyRandom";
|
||||
String correctOutput = "WIQOOXHMVEGKGWS";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keywordThatIsTotallyRandom";
|
||||
correctOutput = "WIQOOXHMVEGKGWS";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed secure uppercase encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode";
|
||||
keyword = "keywordThatIsTotallyRandom";
|
||||
correctOutput = "WIQOOXHMVEGKGWS";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed secure symbol encoding.", 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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
OneTimePad cipher = new OneTimePad(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhmvegkgws";
|
||||
String keyword = "keywordThatIsTotallyRandom";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "WIQOOXHMVEGKGWS";
|
||||
keyword = "keywordThatIsTotallyRandom";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
OneTimePad cipher = new OneTimePad(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhmvegkgws";
|
||||
String keyword = "keywordThatIsTotallyRandom";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed no capital lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
OneTimePad cipher = new OneTimePad(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhmvegkgws";
|
||||
String keyword = "keywordThatIsTotallyRandom";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
OneTimePad cipher = new OneTimePad(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhmvegkgws";
|
||||
String keyword = "keywordThatIsTotallyRandom";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
OneTimePad cipher = new OneTimePad(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhmvegkgws";
|
||||
String keyword = "keywordThatIsTotallyRandom";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "WIQOOXHMVEGKGWS";
|
||||
keyword = "keywordThatIsTotallyRandom";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed secure uppercase decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "wiqooxh*mv+egkgws";
|
||||
keyword = "keywordThatIsTotallyRandom";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("OneTimePad failed secure symbol decoding.", 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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,407 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestPorta.java
|
||||
//Mattrixwv
|
||||
// Created: 02-28-22
|
||||
//Modified: 02-28-22
|
||||
package com.mattrixwv.cipherstream.monosubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestPorta{
|
||||
@Test
|
||||
public void testEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Porta cipher = new Porta(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "rtghuosbmqcwgrw";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Porta failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "RTGHUOSBMQCWGRW";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Porta failed uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Porta cipher = new Porta(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "RTGHUOSBMQCWGRW";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Porta failed no capital lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Porta cipher = new Porta(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "rtghuosbmqcwgrw";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Porta failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolEncoding() throws InvalidKeywordException, InvalidInputException{
|
||||
Porta cipher = new Porta(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "rtghuosbmqcwgrw";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Porta failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Porta cipher = new Porta(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "RTGHUOSBMQCWGRW";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Porta failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "RTGHUOSBMQCWGRW";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Porta failed secure uppercase encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode";
|
||||
keyword = "keyword";
|
||||
correctOutput = "RTGHUOSBMQCWGRW";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Porta failed secure symbol encoding.", 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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Porta cipher = new Porta(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "rtghuosbmqcwgrw";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Porta failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "RTGHUOSBMQCWGRW";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Porta failed uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Porta cipher = new Porta(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "rtghuosbmqcwgrw";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Porta failed no capital lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Porta cipher = new Porta(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "rtghuosbmqcwgrw";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Porta failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolDeocde() throws InvalidKeywordException, InvalidInputException{
|
||||
Porta cipher = new Porta(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "rtghuosbmqcwgrw";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Porta failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "RTGHUOSBMQCWGRW";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Porta failed uppercase decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "rtghuos*bm+qcwgrw";
|
||||
keyword = "keyword";
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Porta failed symbol decoding.", 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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Porta cipher = new Porta(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "rtghuosbmqcwgrw";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Porta failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "RTGHUOSBMQCWGRW";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Porta failed secure uppercase decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "rtghuos*bm+qcwgrw";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Porta failed secure symbol decoding.", 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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,467 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestSubstitution.java
|
||||
//Mattrixwv
|
||||
// Created: 02-22-22
|
||||
//Modified: 02-22-22
|
||||
package com.mattrixwv.cipherstream.monosubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestSubstitution{
|
||||
@Test
|
||||
public void testEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Substitution cipher = new Substitution(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String key = "cdefghijklmnopqrstuvwxyzab";
|
||||
String correctOutput = "oguucigvqgpeqfg";
|
||||
String output = cipher.encode(key, inputString);
|
||||
assertEquals("Substitution failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
key = "cdefghijklmnopqrstuvwxyzab";
|
||||
correctOutput = "OGUUCIGVQGPEQFG";
|
||||
output = cipher.encode(key, inputString);
|
||||
assertEquals("Substitution failed uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Substitution cipher = new Substitution(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String key = "cdefghijklmnopqrstuvwxyzab";
|
||||
String correctOutput = "OGUUCIGVQGPEQFG";
|
||||
String output = cipher.encode(key, inputString);
|
||||
assertEquals("Substitution failed no capital lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Substitution cipher = new Substitution(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String key = "cdefghijklmnopqrstuvwxyzab";
|
||||
String correctOutput = "oguucigvqgpeqfg";
|
||||
String output = cipher.encode(key, inputString);
|
||||
assertEquals("Substitution failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Substitution cipher = new Substitution(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String key = "cdefghijklmnopqrstuvwxyzab";
|
||||
String correctOutput = "oguucigvqgpeqfg";
|
||||
String output = cipher.encode(key, inputString);
|
||||
assertEquals("Substitution failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Substitution cipher = new Substitution(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String key = "cdefghijklmnopqrstuvwxyzab";
|
||||
String correctOutput = "OGUUCIGVQGPEQFG";
|
||||
String output = cipher.encode(key, inputString);
|
||||
assertEquals("Substitution failed no capital lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Substitution cipher = new Substitution(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "oguucigvqgpeqfg";
|
||||
String key = "cdefghijklmnopqrstuvwxyzab";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(key, inputString);
|
||||
assertEquals("Substitution failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "OGUUCIGVQGPEQFG";
|
||||
key = "cdefghijklmnopqrstuvwxyzab";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(key, inputString);
|
||||
assertEquals("Substitution failed uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Substitution cipher = new Substitution(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "oguucigvqgpeqfg";
|
||||
String key = "cdefghijklmnopqrstuvwxyzab";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(key, inputString);
|
||||
assertEquals("Substitution failed no capital lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Substitution cipher = new Substitution(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "oguucigvqgpeqfg";
|
||||
String key = "cdefghijklmnopqrstuvwxyzab";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(key, inputString);
|
||||
assertEquals("Substitution failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Substitution cipher = new Substitution(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "oguucigvqgpeqfg";
|
||||
String key = "cdefghijklmnopqrstuvwxyzab";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(key, inputString);
|
||||
assertEquals("Substitution failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Substitution cipher = new Substitution(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "oguucigvqgpeqfg";
|
||||
String key = "cdefghijklmnopqrstuvwxyzab";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(key, inputString);
|
||||
assertEquals("Substitution failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "OGUUCIGVQGPEQFG";
|
||||
key = "cdefghijklmnopqrstuvwxyzab";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(key, inputString);
|
||||
assertEquals("Substitution failed secure uppercase decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "oguucig*vq+gpeqfg";
|
||||
key = "cdefghijklmnopqrstuvwxyzab";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(key, inputString);
|
||||
assertEquals("Substitution failed secure whitespace decoding.", 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);
|
||||
//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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,407 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/monoSubstitution/TestVigenere.java
|
||||
//Mattrixwv
|
||||
// Created: 07-25-21
|
||||
//Modified: 02-22-22
|
||||
package com.mattrixwv.cipherstream.monosubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestVigenere{
|
||||
@Test
|
||||
public void testEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Vigenere cipher = new Vigenere(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "wiqooxhdscjqfgo";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Vigenere failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "WIQOOXHDSCJQFGO";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Vigenere failed uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Vigenere cipher = new Vigenere(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "WIQOOXHDSCJQFGO";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Vigenere failed no capital lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Vigenere cipher = new Vigenere(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "wiqooxhdscjqfgo";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Vigenere failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Vigenere cipher = new Vigenere(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "wiqooxhdscjqfgo";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Vigenere failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidKeywordException, InvalidInputException{
|
||||
Vigenere cipher = new Vigenere(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "WIQOOXHDSCJQFGO";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Vigenere failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "WIQOOXHDSCJQFGO";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Vigenere failed secure uppercase encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode";
|
||||
keyword = "keyword";
|
||||
correctOutput = "WIQOOXHDSCJQFGO";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Vigenere failed secure symbol encoding.", 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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Vigenere cipher = new Vigenere(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhdscjqfgo";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Vigenere failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "WIQOOXHDSCJQFGO";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Vigenere failed uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Vigenere cipher = new Vigenere(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhdscjqfgo";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Vigenere failed no capital lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Vigenere cipher = new Vigenere(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhdscjqfgo";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Vigenere failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Vigenere cipher = new Vigenere(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhdscjqfgo";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Vigenere failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceSymbolDecode() throws InvalidKeywordException, InvalidInputException{
|
||||
Vigenere cipher = new Vigenere(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "wiqooxhdscjqfgo";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Vigenere failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "WIQOOXHDSCJQFGO";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Vigenere failed secure uppercase decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "wiqooxh*ds+cjqfgo";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Vigenere failed secure symbol decoding.", 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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,408 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/polySubstitution/TestBifid.java
|
||||
//Mattrixwv
|
||||
// Created: 03-03-22
|
||||
//Modified: 03-03-22
|
||||
package com.mattrixwv.cipherstream.polysubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestBifid{
|
||||
@Test
|
||||
public void testEncode() throws InvalidKeywordException, InvalidInputException, InvalidCharacterException{
|
||||
Bifid cipher = new Bifid(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "mqaoknekcvdodzd";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Bifid failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MQAOKNEKCVDODZD";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Bifid failed uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidKeywordException, InvalidInputException, InvalidCharacterException{
|
||||
Bifid cipher = new Bifid(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MQAOKNEKCVDODZD";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Bifid failed no capital lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidKeywordException, InvalidInputException, InvalidCharacterException{
|
||||
Bifid cipher = new Bifid(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "mqaoknekcvdodzd";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Bifid failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidKeywordException, InvalidInputException, InvalidCharacterException{
|
||||
Bifid cipher = new Bifid(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "mqaoknekcvdodzd";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Bifid failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidKeywordException, InvalidInputException, InvalidCharacterException{
|
||||
Bifid cipher = new Bifid(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MQAOKNEKCVDODZD";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Bifid failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MQAOKNEKCVDODZD";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Bifid failed secure uppercase encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to+encode";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MQAOKNEKCVDODZD";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Bifid failed secure symbol encoding.", 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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidKeywordException, InvalidInputException, InvalidCharacterException{
|
||||
Bifid cipher = new Bifid(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "mqaoknekcvdodzd";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Bifid failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "MQAOKNEKCVDODZD";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Bifid failed uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidKeywordException, InvalidInputException, InvalidCharacterException{
|
||||
Bifid cipher = new Bifid(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "mqaoknekcvdodzd";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Bifid failed no capital lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidKeywordException, InvalidInputException, InvalidCharacterException{
|
||||
Bifid cipher = new Bifid(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "mqaoknekcvdodzd";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Bifid failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidKeywordException, InvalidInputException, InvalidCharacterException{
|
||||
Bifid cipher = new Bifid(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "mqaoknekcvdodzd";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Bifid failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidKeywordException, InvalidInputException, InvalidCharacterException{
|
||||
Bifid cipher = new Bifid(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "mqaoknekcvdodzd";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Bifid failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "MQAOKNEKCVDODZD";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Bifid failed secure uppercase decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "mqaokne*kc+vdodzd";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Bifid failed secure symbol decoding.", 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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,476 @@
|
||||
//Mattrixwv/src/test/java/com/mattrixwv/CipherStreamJava/polySubstitution/TestColumnar.java
|
||||
//Mattrixwv
|
||||
// Created: 01-16-22
|
||||
//Modified: 03-03-22
|
||||
package com.mattrixwv.cipherstream.polysubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestColumnar{
|
||||
@Test
|
||||
public void testEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(true, true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "edxeoxmteacxgoxsnxsex";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Columnar failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "EDXEOXMTEACXGOXsnxsex";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Columnar failed uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(false, true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "EDXEOXMTEACXGOXSNXSEX";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Columnar failed no capitals lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(true, false, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "edxeoxmteacxgoxsnxsex";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Columnar failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(true, true, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "edxeoxmteacxgoxsnxsex";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Columnar failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoPaddingEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(true, true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "edeomteacgosnse";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Columnar failed no padding lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(false, false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "EDXEOXMTEACXGOXSNXSEX";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Columnar failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "EDXEOXMTEACXGOXSNXSEX";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Columnar failed secure uppercase encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message@to-encode";
|
||||
keyword = "keyword";
|
||||
correctOutput = "EDXEOXMTEACXGOXSNXSEX";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Columnar failed secure symbol encoding.", 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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(true, true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "edxeoxmteacxgoxsnxsex";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencodexxxxxx";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Columnar failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "EDXEOXMTEACXGOXsnxsex";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODExxxxxx";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Columnar failed uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(false, true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "edxeoxmteacxgoxsnxsex";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODEXXXXXX";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Columnar failed no capital lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(true, false, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "edxeoxmteacxgoxsnxsex";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencodexxxxxx";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Columnar failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(true, true, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "edxeoxmteacxgoxsnxsex";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencodexxxxxx";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Columnar failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoPaddingDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(true, true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "edeomteacgosnse";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Columnar failed no padding lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidKeywordException, InvalidInputException{
|
||||
Columnar cipher = new Columnar(false, false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "edxeoxmteacxgoxsnxsex";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODEXXXXXX";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Columnar failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "EDXEOXMTEACXGOXsnxsex";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODEXXXXXX";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Columnar failed secure uppercase decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "edxeoxm@te-acxgoxsnxsex";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODEXXXXXX";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Columnar failed secure symbol decoding.", 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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,529 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamjava/polySubstitution/TestHill.java
|
||||
//Mattrixwv
|
||||
// Created: 01-31-22
|
||||
//Modified: 02-17-22
|
||||
package com.mattrixwv.cipherstream.polysubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import java.security.InvalidKeyException;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
|
||||
|
||||
public class TestHill{
|
||||
@Test
|
||||
public void testEncode() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(true, true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(false, true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(true, false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(true, true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoPaddingEncoding() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(true, true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(false, false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(true, true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "mgkeqgeulikhisp";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(false, true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "mgkeqgeulikhisp";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(true, false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "mgkeqgeulikhisp";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(true, true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "mgkeqgeulikhisp";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoPaddingDecoding() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(true, true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "mgkeqgeulikhisp";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidKeyException, InvalidInputException{
|
||||
Hill cipher = new Hill(false, false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "mgkeqgeulikhisp";
|
||||
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);
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
//CipherStreamJava/src/main/java/com/mattrixwv/CipherStreamJava/TestMorse.java
|
||||
//Matthew Ellison
|
||||
// Created: 07-28-21
|
||||
//Modified: 01-04-22
|
||||
package com.mattrixwv.cipherstream.polysubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
|
||||
public class TestMorse{
|
||||
@Test
|
||||
public void testEncode(){
|
||||
Morse cipher = new Morse();
|
||||
|
||||
//Test 1
|
||||
String input = "sos";
|
||||
String correctOutput = "... --- ...";
|
||||
String output = cipher.encode(input);
|
||||
assertEquals("Morse Encoding failed the first test", correctOutput, output);
|
||||
|
||||
//Test 2
|
||||
input = "MORSE, CODE";
|
||||
correctOutput = "-- --- .-. ... . -.-. --- -.. .";
|
||||
output = cipher.encode(input);
|
||||
assertEquals("Morse Encoding failed the second test", correctOutput, output);
|
||||
|
||||
//Test 3
|
||||
input = "1.23 987";
|
||||
correctOutput = ".---- ..--- ...-- ----. ---.. --...";
|
||||
output = cipher.encode(input);
|
||||
assertEquals("Morse Encoding failed the third test", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testDecode(){
|
||||
Morse cipher = new Morse();
|
||||
|
||||
//Test 1
|
||||
String input = "... --- ...";
|
||||
String correctOutput = "SOS";
|
||||
String output = cipher.decode(input);
|
||||
assertEquals("Morse Decoding failed the first test", correctOutput, output);
|
||||
|
||||
//Test 2
|
||||
input = "-- --- .-. ... . -.-. --- -.. .";
|
||||
correctOutput = "MORSECODE";
|
||||
output = cipher.decode(input);
|
||||
assertEquals("Morse Decoding failed the second test", correctOutput, output);
|
||||
|
||||
//Test 3
|
||||
input = ".---- ..--- ...-- ----. ---.. --...";
|
||||
correctOutput = "123987";
|
||||
output = cipher.decode(input);
|
||||
assertEquals("Morse Decoding failed the third test", correctOutput, output);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,517 @@
|
||||
//CipherStreamJava/src/main/java/com/mattrixwv/CipherStreamJava/TestPlayfair.java
|
||||
//Matthew Ellison
|
||||
// Created: 07-30-21
|
||||
//Modified: 01-04-22
|
||||
package com.mattrixwv.cipherstream.polysubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
|
||||
|
||||
public class TestPlayfair{
|
||||
@Test
|
||||
public void testEncode() throws InvalidCharacterException, InvalidInputException{
|
||||
Playfair cipher = new Playfair(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "hidethegoldinthetreestump";
|
||||
String keyword = "Playfair Example";
|
||||
String correctOutput = "bmodzbxdnabekudmuixMmouvif";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "HIDETHEGOLDINTHETREESTUMP";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed uppercase encoding.", correctOutput, output);
|
||||
//Test odd letter count encoding
|
||||
inputString = "hidethegoldinthetrexestum";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "bmodzbxdnabekudmuixmmouviM";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed odd letter count encoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "hide the gold in the 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);
|
||||
|
||||
//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);
|
||||
|
||||
//Test mixed case, whitespace, symbol encoding
|
||||
inputString = "Hide the gold in - the@tree+stump";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "Bmod zbx dnab ek - udm@uixMm+ouvif";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed mixed case, whitespace, symbol encoding.", correctOutput, output);
|
||||
//Test mixed case, whitespace, symbol encoding with mangled keyword
|
||||
inputString = "Hide the gold in - the@tree+stump";
|
||||
keyword = "Play-fair@Exam ple";
|
||||
correctOutput = "Bmod zbx dnab ek - udm@uixMm+ouvif";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidInputException{
|
||||
Playfair cipher = new Playfair(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "hidethegoldinthetreestump";
|
||||
String keyword = "Playfair Example";
|
||||
String correctOutput = "bmodzbxdnabekudmuixMmouvif";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "HIDETHEGOLDINTHETREESTUMP";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace uppercase encoding.", correctOutput, output);
|
||||
//Test odd letter count encoding
|
||||
inputString = "hidethegoldinthetreestum";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "bmodzbxdnabekudmuixMmouviM";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace odd letter count encoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "hide the gold in the tree stump";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "bmodzbxdnabekudmuixMmouvif";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace whitespace encoding.", correctOutput, output);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "hidethegoldin-the@tree+stump";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "bmodzbxdnabek-udm@uixMm+ouvif";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace symbol encoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whitespace, symbol encoding
|
||||
inputString = "Hide the gold in - the@tree+stump";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "Bmodzbxdnabek-udm@uixMm+ouvif";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol encoding.", correctOutput, output);
|
||||
//Test mixed case, whitespace, symbol encoding with mangled keyword
|
||||
inputString = "Hide the gold in - the@tree+stump";
|
||||
keyword = "Play-fair@Exam ple";
|
||||
correctOutput = "Bmodzbxdnabek-udm@uixMm+ouvif";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidCharacterException, InvalidInputException{
|
||||
Playfair cipher = new Playfair(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "hidethegoldinthetreestump";
|
||||
String keyword = "Playfair Example";
|
||||
String correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "HIDETHEGOLDINTHETREESTUMP";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital uppercase encoding.", correctOutput, output);
|
||||
//Test odd letter count encoding
|
||||
inputString = "hidethegoldinthetreestum";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIM";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital odd letter count encoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "hide the gold in the 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);
|
||||
|
||||
//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);
|
||||
|
||||
//Test mixed case, whitespace, symbol encoding
|
||||
inputString = "Hide the gold in - the@tree+stump";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "BMOD ZBX DNAB EK - UDM@UIXMM+OUVIF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital mixed case, whitespace, symbol encoding.", correctOutput, output);
|
||||
//Test mixed case, whitespace, symbol encoding with mangled keyword
|
||||
inputString = "Hide the gold in - the@tree+stump";
|
||||
keyword = "Play-fair@Exam ple";
|
||||
correctOutput = "BMOD ZBX DNAB EK - UDM@UIXMM+OUVIF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidInputException{
|
||||
Playfair cipher = new Playfair(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "hidethegoldinthetreestump";
|
||||
String keyword = "Playfair Example";
|
||||
String correctOutput = "bmodzbxdnabekudmuixMmouvif";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "HIDETHEGOLDINTHETREESTUMP";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol uppercase encoding.", correctOutput, output);
|
||||
//Test odd letter count encoding
|
||||
inputString = "hidethegoldinthetreestum";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "bmodzbxdnabekudmuixMmouviM";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol odd letter count encoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "hide the gold in the 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);
|
||||
|
||||
//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);
|
||||
|
||||
//Test mixed case, whitespace, symbol encoding
|
||||
inputString = "Hide the gold in - the@tree+stump";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "Bmod zbx dnab ek udmuixMmouvif";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol mixed case, whitespace, symbol encoding.", correctOutput, output);
|
||||
//Test mixed case, whitespace, symbol encoding with mangled keyword
|
||||
inputString = "Hide the gold in - the@tree+stump";
|
||||
keyword = "Play-fair@Exam ple";
|
||||
correctOutput = "Bmod zbx dnab ek udmuixMmouvif";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidInputException{
|
||||
Playfair cipher = new Playfair(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "hidethegoldinthetreestump";
|
||||
String keyword = "Playfair Example";
|
||||
String correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "HIDETHEGOLDINTHETREESTUMP";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed secure uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//Test mixed case, whitespace, symbol encoding
|
||||
inputString = "Hide the gold in - the@tree+stump";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed secure mixed case, whitespace, symbol encoding.", correctOutput, output);
|
||||
//Test mixed case, whitespace, symbol encoding with mangled keyword
|
||||
inputString = "Hide the gold in - the@tree+stump";
|
||||
keyword = "Play-fair@Exam ple";
|
||||
correctOutput = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Playfair failed secure mixed case, whitespace, symbol encoding with mangled keyword.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testDecode() throws InvalidCharacterException, InvalidInputException{
|
||||
Playfair cipher = new Playfair(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "bmodzbxdnabekudmuixmmouvif";
|
||||
String keyword = "Playfair Example";
|
||||
String correctOutput = "hidethegoldinthetrexestump";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed uppercase decoding.", correctOutput, output);
|
||||
//Test odd letter count decoding
|
||||
inputString = "bmodzbxdnabekudmuixmmouvim";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "hidethegoldinthetrexestumx";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed odd letter count decoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "bmod zbx dnab ek udm uixmm ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "hide the gold in the trexe stump";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "bmodzbxdnabek-udm@uixmm+ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "hidethegoldin-the@trexe+stump";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, 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);
|
||||
//Test mixed case, whtiespace, symbol decoding with mangled keyword
|
||||
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
|
||||
keyword = "Play-fair@Exam ple";
|
||||
correctOutput = "Hide the gold in - the@trexe+stump";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidInputException{
|
||||
Playfair cipher = new Playfair(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "bmodzbxdnabekudmuixmmouvif";
|
||||
String keyword = "Playfair Example";
|
||||
String correctOutput = "hidethegoldinthetrexestump";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace uppercase decoding.", correctOutput, output);
|
||||
//Test odd letter count decoding
|
||||
inputString = "bmodzbxdnabekudmuixmmouvim";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "hidethegoldinthetrexestumx";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace odd letter count decoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "bmodzbxdnabekudmuixmmouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "hidethegoldinthetrexestump";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "bmodzbxdnabek-udm@uixmm+ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "hidethegoldin-the@trexe+stump";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whtiespace, symbol decoding
|
||||
inputString = "Bmodzbxdnabek-udm@uixmm+ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "Hidethegoldin-the@trexe+stump";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol decoding.", correctOutput, output);
|
||||
//Test mixed case, whtiespace, symbol decoding with mangled keyword
|
||||
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
|
||||
keyword = "Play-fair@Exam ple";
|
||||
correctOutput = "Hidethegoldin-the@trexe+stump";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no whitespace mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidCharacterException, InvalidInputException{
|
||||
Playfair cipher = new Playfair(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "bmodzbxdnabekudmuixmmouvif";
|
||||
String keyword = "Playfair Example";
|
||||
String correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital uppercase decoding.", correctOutput, output);
|
||||
//Test odd letter count decoding
|
||||
inputString = "bmodzbxdnabekudmuixmmouvim";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDETHEGOLDINTHETREXESTUMX";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital odd letter count decoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "bmod zbx dnab ek udm uixmm ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDE THE GOLD IN THE TREXE STUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "bmodzbxdnabek-udm@uixmm+ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDETHEGOLDIN-THE@TREXE+STUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whtiespace, symbol decoding
|
||||
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDE THE GOLD IN - THE@TREXE+STUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital mixed case, whitespace, symbol decoding.", correctOutput, output);
|
||||
//Test mixed case, whtiespace, symbol decoding with mangled keyword
|
||||
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
|
||||
keyword = "Play-fair@Exam ple";
|
||||
correctOutput = "HIDE THE GOLD IN - THE@TREXE+STUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no capital mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidCharacterException, InvalidInputException{
|
||||
Playfair cipher = new Playfair(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "bmodzbxdnabekudmuixmmouvif";
|
||||
String keyword = "Playfair Example";
|
||||
String correctOutput = "hidethegoldinthetrexestump";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol uppercase decoding.", correctOutput, output);
|
||||
//Test odd letter count decoding
|
||||
inputString = "bmodzbxdnabekudmuixmmouvim";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "hidethegoldinthetrexestumx";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol odd letter count decoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "bmod zbx dnab ek udm uixmm ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "hide the gold in the trexe stump";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "bmodzbxdnabek-udm@uixmm+ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "hidethegoldinthetrexestump";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whtiespace, symbol decoding
|
||||
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "Hide the gold in thetrexestump";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol mixed case, whitespace, symbol decoding.", correctOutput, output);
|
||||
//Test mixed case, whtiespace, symbol decoding with mangled keyword
|
||||
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
|
||||
keyword = "Play-fair@Exam ple";
|
||||
correctOutput = "Hide the gold in thetrexestump";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed no symbol mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output);
|
||||
}
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidInputException{
|
||||
Playfair cipher = new Playfair(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "bmodzbxdnabekudmuixmmouvif";
|
||||
String keyword = "Playfair Example";
|
||||
String correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "BMODZBXDNABEKUDMUIXMMOUVIF";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed secure uppercase decoding.", correctOutput, output);
|
||||
//Test odd letter count decoding
|
||||
inputString = "bmodzbxdnabekudmuixmmouvim";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDETHEGOLDINTHETREXESTUMX";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed secure odd letter count decoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "bmod zbx dnab ek udm uixmm ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed secure whitespace decoding.", correctOutput, output);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "bmodzbxdnabek-udm@uixmm+ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed secure symbol decoding.", correctOutput, output);
|
||||
|
||||
//Test mixed case, whtiespace, symbol decoding
|
||||
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
|
||||
keyword = "Playfair Example";
|
||||
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed secure mixed case, whitespace, symbol decoding.", correctOutput, output);
|
||||
//Test mixed case, whtiespace, symbol decoding with mangled keyword
|
||||
inputString = "Bmod zbx dnab ek - udm@uixmm+ouvif";
|
||||
keyword = "Play-fair@Exam ple";
|
||||
correctOutput = "HIDETHEGOLDINTHETREXESTUMP";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Playfair failed secure mixed case, whitespace, symbol decoding with mangled keyword.", correctOutput, output);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,321 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/TestPolybiusSquare.java
|
||||
//Mattrixwv
|
||||
// Created: 01-04-22
|
||||
//Modified: 01-09-22
|
||||
package com.mattrixwv.cipherstream.polysubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
|
||||
|
||||
public class TestPolybiusSquare{
|
||||
@Test
|
||||
public void testEncode() throws InvalidCharacterException, InvalidInputException{
|
||||
PolybiusSquare cipher = new PolybiusSquare(true, true);
|
||||
|
||||
//Test simple encoding
|
||||
String inputString = "BAT";
|
||||
String keyword = "";
|
||||
String correctOutput = "121144";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed simple encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "B@A+T-";
|
||||
keyword = "";
|
||||
correctOutput = "12@11+44-";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed symbol encoding.", 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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidInputException{
|
||||
PolybiusSquare cipher = new PolybiusSquare(false, true);
|
||||
|
||||
//Test simple encoding
|
||||
String inputString = "BAT";
|
||||
String keyword = "";
|
||||
String correctOutput = "121144";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed no whitespace simple encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidInputException{
|
||||
PolybiusSquare cipher = new PolybiusSquare(true, false);
|
||||
|
||||
//Test simple encoding
|
||||
String inputString = "BAT";
|
||||
String keyword = "";
|
||||
String correctOutput = "121144";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed no symbol simple encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "B@A+T-";
|
||||
keyword = "";
|
||||
correctOutput = "121144";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed no symbol symbol encoding.", 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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidInputException{
|
||||
PolybiusSquare cipher = new PolybiusSquare(false, false);
|
||||
|
||||
//Test simple encoding
|
||||
String inputString = "BAT";
|
||||
String keyword = "";
|
||||
String correctOutput = "12 11 44";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed secure simple encoding.", correctOutput, output);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "B A T";
|
||||
keyword = "";
|
||||
correctOutput = "12 11 44";
|
||||
assertEquals("PolybiusSquare failed secure whitespace encoding.", correctOutput, output);
|
||||
output = cipher.encode(keyword, inputString);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "B@A+T-";
|
||||
keyword = "";
|
||||
correctOutput = "12 11 44";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed secure symbol encoding.", 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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testDecode() throws InvalidCharacterException, InvalidInputException{
|
||||
PolybiusSquare cipher = new PolybiusSquare(true, true);
|
||||
|
||||
//Test simple decoding
|
||||
String inputString = "121144";
|
||||
String keyword = "";
|
||||
String correctOutput = "BAT";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed simple decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "12@11+44-";
|
||||
keyword = "";
|
||||
correctOutput = "B@A+T-";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed symbol decoding.", 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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidInputException{
|
||||
PolybiusSquare cipher = new PolybiusSquare(false, true);
|
||||
|
||||
//Test simple decoding
|
||||
String inputString = "121144";
|
||||
String keyword = "";
|
||||
String correctOutput = "BAT";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed no whitespace simple decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoSymbolDeocde() throws InvalidCharacterException, InvalidInputException{
|
||||
PolybiusSquare cipher = new PolybiusSquare(true, false);
|
||||
|
||||
//Test simple decoding
|
||||
String inputString = "121144";
|
||||
String keyword = "";
|
||||
String correctOutput = "BAT";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed no symbol simple decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "12@11+44-";
|
||||
keyword = "";
|
||||
correctOutput = "BAT";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed no symbol symbol decoding.", 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);
|
||||
//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);
|
||||
}
|
||||
@Test
|
||||
public void testNoWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidInputException{
|
||||
PolybiusSquare cipher = new PolybiusSquare(false, false);
|
||||
|
||||
//Test simple decoding
|
||||
String inputString = "121144";
|
||||
String keyword = "";
|
||||
String correctOutput = "BAT";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed secure simple decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "12@11+44-";
|
||||
keyword = "";
|
||||
correctOutput = "BAT";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("PolybiusSquare failed secure symbol decoding.", 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);
|
||||
//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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,537 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/polySubstitution/TestRailFence.java
|
||||
//Mattrixwv
|
||||
// Created: 03-21-22
|
||||
//Modified: 03-22-22
|
||||
package com.mattrixwv.cipherstream.polysubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidBaseException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
|
||||
|
||||
public class TestRailFence{
|
||||
@Test
|
||||
public void testEncode() throws InvalidBaseException, InvalidInputException{
|
||||
RailFence cipher = new RailFence(true, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
int numRails = 3;
|
||||
String correctOutput = "maooesgtecdsene";
|
||||
String output = cipher.encode(numRails, inputString);
|
||||
assertEquals("RailFence failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
numRails = 3;
|
||||
correctOutput = "MAOOESGTECDSENE";
|
||||
output = cipher.encode(numRails, inputString);
|
||||
assertEquals("RailFence failed uppercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNocapitalEncode() throws InvalidBaseException, InvalidInputException{
|
||||
RailFence cipher = new RailFence(false, true, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
int numRails = 3;
|
||||
String correctOutput = "MAOOESGTECDSENE";
|
||||
String output = cipher.encode(numRails, inputString);
|
||||
assertEquals("RailFence failed no capital lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidBaseException, InvalidInputException{
|
||||
RailFence cipher = new RailFence(true, false, true);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
int numRails = 3;
|
||||
String correctOutput = "maooesgtecdsene";
|
||||
String output = cipher.encode(numRails, inputString);
|
||||
assertEquals("RailFence failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidBaseException, InvalidInputException{
|
||||
RailFence cipher = new RailFence(true, true, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
int numRails = 3;
|
||||
String correctOutput = "maooesgtecdsene";
|
||||
String output = cipher.encode(numRails, inputString);
|
||||
assertEquals("RailFence failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidBaseException, InvalidInputException{
|
||||
RailFence cipher = new RailFence(false, false, false);
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
int numRails = 3;
|
||||
String correctOutput = "MAOOESGTECDSENE";
|
||||
String output = cipher.encode(numRails, inputString);
|
||||
assertEquals("RailFence failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
numRails = 3;
|
||||
correctOutput = "MAOOESGTECDSENE";
|
||||
output = cipher.encode(numRails, inputString);
|
||||
assertEquals("RailFence failed secure uppercase encoding.", 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);
|
||||
|
||||
//Test whitespace encoding
|
||||
inputString = "message to encode";
|
||||
numRails = 3;
|
||||
correctOutput = "MAOOESGTECDSENE";
|
||||
output = cipher.encode(numRails, inputString);
|
||||
assertEquals("RailFence failed secure whitespace encoding.", 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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidBaseException, InvalidInputException{
|
||||
RailFence cipher = new RailFence(true, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "maooesgtecdsene";
|
||||
int numRails = 3;
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(numRails, inputString);
|
||||
assertEquals("RailFence failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "MAOOESGTECDSENE";
|
||||
numRails = 3;
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(numRails, inputString);
|
||||
assertEquals("RailFence failed uppercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidBaseException, InvalidInputException{
|
||||
RailFence cipher = new RailFence(false, true, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "maooesgtecdsene";
|
||||
int numRails = 3;
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(numRails, inputString);
|
||||
assertEquals("RailFence failed no capital lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidBaseException, InvalidInputException{
|
||||
RailFence cipher = new RailFence(true, false, true);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "maooesgtecdsene";
|
||||
int numRails = 3;
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(numRails, inputString);
|
||||
assertEquals("RailFence failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolDecode() throws InvalidBaseException, InvalidInputException{
|
||||
RailFence cipher = new RailFence(true, true, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "maooesgtecdsene";
|
||||
int numRails = 3;
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(numRails, inputString);
|
||||
assertEquals("RailFence failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidBaseException, InvalidInputException{
|
||||
RailFence cipher = new RailFence(false, false, false);
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "maooesgtecdsene";
|
||||
int numRails = 3;
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(numRails, inputString);
|
||||
assertEquals("RailFence failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "MAOOESGTECDSENE";
|
||||
numRails = 3;
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(numRails, inputString);
|
||||
assertEquals("RailFence failed secure uppercase decoding.", 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);
|
||||
|
||||
//Test whitespace decoding
|
||||
inputString = "maooesg te cdsene";
|
||||
numRails = 3;
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(numRails, inputString);
|
||||
assertEquals("RailFence failed secure whitespace decoding.", 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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,559 @@
|
||||
//CipherStreamJava/src/test/java/com/mattrixwv/CipherStreamJava/polySubstitution/TestTrifid.java
|
||||
//Mattrixwv
|
||||
// Created: 03-03-22
|
||||
//Modified: 03-03-22
|
||||
package com.mattrixwv.cipherstream.polysubstitution;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidBaseException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
|
||||
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
|
||||
|
||||
|
||||
public class TestTrifid{
|
||||
@Test
|
||||
public void testEncode() throws InvalidCharacterException, InvalidBaseException, InvalidKeywordException, InvalidInputException{
|
||||
Trifid cipher = new Trifid(true, true, true, '+');
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "gqdokpdodljvflf";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Trifid failed lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "GQDOKPDODLJVFLF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Trifid failed uppercase encoding.", correctOutput, output);
|
||||
|
||||
//Test groupLength encoding
|
||||
inputString = "messagetoencode";
|
||||
keyword = "keyword";
|
||||
int groupLength = 3;
|
||||
correctOutput = "gpjqdvdofodlklf";
|
||||
output = cipher.encode(keyword, groupLength, inputString);
|
||||
assertEquals("Trifid failed groupLength encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalEncode() throws InvalidCharacterException, InvalidBaseException, InvalidKeywordException, InvalidInputException{
|
||||
Trifid cipher = new Trifid(false, true, true, '+');
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "GQDOKPDODLJVFLF";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Trifid failed no capital lowercase encoding.", 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);
|
||||
|
||||
//Test groupLength encoding
|
||||
inputString = "messagetoencode";
|
||||
keyword = "keyword";
|
||||
int groupLength = 3;
|
||||
correctOutput = "GPJQDVDOFODLKLF";
|
||||
output = cipher.encode(keyword, groupLength, inputString);
|
||||
assertEquals("Trifid failed no capital groupLength encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceEncode() throws InvalidCharacterException, InvalidBaseException, InvalidKeywordException, InvalidInputException{
|
||||
Trifid cipher = new Trifid(true, false, true, '+');
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "gqdokpdodljvflf";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Trifid failed no whitespace lowercase encoding.", 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);
|
||||
|
||||
//Test groupLength encoding
|
||||
inputString = "messagetoencode";
|
||||
keyword = "keyword";
|
||||
int groupLength = 3;
|
||||
correctOutput = "gpjqdvdofodlklf";
|
||||
output = cipher.encode(keyword, groupLength, inputString);
|
||||
assertEquals("Trifid failed no whitespace groupLength encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolEncode() throws InvalidCharacterException, InvalidBaseException, InvalidKeywordException, InvalidInputException{
|
||||
Trifid cipher = new Trifid(true, true, false, '+');
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "gqdokpdodljvflf";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Trifid failed no symbol lowercase encoding.", 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);
|
||||
|
||||
//Test groupLength encoding
|
||||
inputString = "messagetoencode";
|
||||
keyword = "keyword";
|
||||
int groupLength = 3;
|
||||
correctOutput = "gpjqdvdofodlklf";
|
||||
output = cipher.encode(keyword, groupLength, inputString);
|
||||
assertEquals("Trifid failed no symbol groupLength encoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolEncode() throws InvalidCharacterException, InvalidBaseException, InvalidKeywordException, InvalidInputException{
|
||||
Trifid cipher = new Trifid(false, false, false, '+');
|
||||
|
||||
//Test lowercase encoding
|
||||
String inputString = "messagetoencode";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "GQDOKPDODLJVFLF";
|
||||
String output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Trifid failed secure lowercase encoding.", correctOutput, output);
|
||||
//Test uppercase encoding
|
||||
inputString = "MESSAGETOENCODE";
|
||||
keyword = "keyword";
|
||||
correctOutput = "GQDOKPDODLJVFLF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Trifid failed secure uppercase encoding.", correctOutput, output);
|
||||
|
||||
//Test groupLength encoding
|
||||
inputString = "messagetoencode";
|
||||
keyword = "keyword";
|
||||
int groupLength = 3;
|
||||
correctOutput = "GPJQDVDOFODLKLF";
|
||||
output = cipher.encode(keyword, groupLength, inputString);
|
||||
assertEquals("Trifid failed secure groupLength encoding.", 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);
|
||||
|
||||
//Test symbol encoding
|
||||
inputString = "message*to-encode";
|
||||
keyword = "keyword";
|
||||
correctOutput = "GQDOKPDODLJVFLF";
|
||||
output = cipher.encode(keyword, inputString);
|
||||
assertEquals("Trifid failed secure symbol encoding.", 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);
|
||||
//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);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testDecode() throws InvalidCharacterException, InvalidBaseException, InvalidKeywordException, InvalidInputException{
|
||||
Trifid cipher = new Trifid(true, true, true, '+');
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "gqdokpdodljvflf";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Trifid failed lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "GQDOKPDODLJVFLF";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Trifid failed uppercase decoding.", correctOutput, output);
|
||||
|
||||
//Test groupLength decoding
|
||||
inputString = "gpjqdvdofodlklf";
|
||||
keyword = "keyword";
|
||||
int groupLength = 3;
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(keyword, groupLength, inputString);
|
||||
assertEquals("Trifid failed groupLength decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalDecode() throws InvalidCharacterException, InvalidBaseException, InvalidKeywordException, InvalidInputException{
|
||||
Trifid cipher = new Trifid(false, true, true, '+');
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "gqdokpdodljvflf";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Trifid failed no capital lowercase decoding.", 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);
|
||||
|
||||
//Test groupLength decoding
|
||||
inputString = "gpjqdvdofodlklf";
|
||||
keyword = "keyword";
|
||||
int groupLength = 3;
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, groupLength, inputString);
|
||||
assertEquals("Trifid failed no capital groupLength decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoWhitespaceDecode() throws InvalidCharacterException, InvalidBaseException, InvalidKeywordException, InvalidInputException{
|
||||
Trifid cipher = new Trifid(true, false, true, '+');
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "gqdokpdodljvflf";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Trifid failed no whitespace lowercase decoding.", 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);
|
||||
|
||||
//Test groupLength decoding
|
||||
inputString = "gpjqdvdofodlklf";
|
||||
keyword = "keyword";
|
||||
int groupLength = 3;
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(keyword, groupLength, inputString);
|
||||
assertEquals("Trifid failed no whitespace groupLength decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoSymbolDeocde() throws InvalidCharacterException, InvalidBaseException, InvalidKeywordException, InvalidInputException{
|
||||
Trifid cipher = new Trifid(true, true, false, '+');
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "gqdokpdodljvflf";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "messagetoencode";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Trifid failed no symbol lowercase decoding.", 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);
|
||||
|
||||
//Test groupLength decoding
|
||||
inputString = "gpjqdvdofodlklf";
|
||||
keyword = "keyword";
|
||||
int groupLength = 3;
|
||||
correctOutput = "messagetoencode";
|
||||
output = cipher.decode(keyword, groupLength, inputString);
|
||||
assertEquals("Trifid failed no symbol groupLength decoding.", 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);
|
||||
|
||||
//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);
|
||||
|
||||
//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);
|
||||
//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);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoCapitalWhitespaceSymbolDecode() throws InvalidCharacterException, InvalidBaseException, InvalidKeywordException, InvalidInputException{
|
||||
Trifid cipher = new Trifid(false, false, false, '+');
|
||||
|
||||
//Test lowercase decoding
|
||||
String inputString = "gqdokpdodljvflf";
|
||||
String keyword = "keyword";
|
||||
String correctOutput = "MESSAGETOENCODE";
|
||||
String output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Trifid failed secure lowercase decoding.", correctOutput, output);
|
||||
//Test uppercase decoding
|
||||
inputString = "GQDOKPDODLJVFLF";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Trifid failed secure uppercase decoding.", correctOutput, output);
|
||||
|
||||
//Test groupLength decoding
|
||||
inputString = "gpjqdvdofodlklf";
|
||||
keyword = "keyword";
|
||||
int groupLength = 3;
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, groupLength, inputString);
|
||||
assertEquals("Trifid failed secure groupLength decoding.", 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);
|
||||
|
||||
//Test symbol decoding
|
||||
inputString = "gqdokpd*od-ljvflf";
|
||||
keyword = "keyword";
|
||||
correctOutput = "MESSAGETOENCODE";
|
||||
output = cipher.decode(keyword, inputString);
|
||||
assertEquals("Trifid failed secure symbol decoding.", 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);
|
||||
//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);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user