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

Update error messages and test names

Browse Source
This commit is contained in:
Mattrixwv
2024-04-19 22:36:52 -04:00
parent 434260969c
commit 0b1d5a3d91
46 changed files with 395 additions and 520 deletions
Download Patch File Download Diff File Expand all files Collapse all files

238
src/test/java/com/mattrixwv/cipherstream/polysubstitution/MorseTest.java Normal file
View File

@@ -0,0 +1,238 @@
//CipherStreamJava/src/main/java/com/mattrixwv/CipherStreamJava/MoresTest.java
//Matthew Ellison
// Created: 07-28-21
//Modified: 04-19-24
package com.mattrixwv.cipherstream.polysubstitution;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.slf4j.Logger;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
@ExtendWith(MockitoExtension.class)
public class MorseTest{
@InjectMocks
private Morse cipher;
@Mock
private Logger logger;
//Fields
private static final String inputString = "Message to^encode123";
private static final String inputStringClean = "MESSAGETOENCODE123";
private static final String outputString = "-- . ... ... .- --. . - --- . -. -.-. --- -.. . .---- ..--- ...--";
@Test
public void testConstructor(){
cipher = new Morse();
assertEquals("", cipher.inputString);
assertEquals("", cipher.outputString);
}
@Test
public void testSetInputStringEncode(){
cipher.setInputStringEncode(inputString);
assertEquals(inputStringClean, cipher.inputString);
verify(logger, times(1)).debug("Setting input string for encoding '{}'", inputString);
verify(logger, times(1)).debug("Removing case");
verify(logger, times(1)).debug("Removing whitespace and symbols");
verify(logger, times(1)).debug("Cleaned input string '{}'", inputStringClean);
}
@Test
public void testSetInputStringEncode_blank(){
assertThrows(InvalidInputException.class, () -> {
cipher.setInputStringEncode("");
});
assertEquals("", cipher.inputString);
verify(logger, times(1)).debug("Setting input string for encoding '{}'", "");
verify(logger, times(1)).debug("Removing case");
verify(logger, times(1)).debug("Removing whitespace and symbols");
verify(logger, times(1)).debug("Cleaned input string '{}'", "");
}
@Test
public void testSetInputStringEncode_blankClean(){
assertThrows(InvalidInputException.class, () -> {
cipher.setInputStringEncode("*&^");
});
assertEquals("", cipher.inputString);
verify(logger, times(1)).debug("Setting input string for encoding '{}'", "*&^");
verify(logger, times(1)).debug("Removing case");
verify(logger, times(1)).debug("Removing whitespace and symbols");
verify(logger, times(1)).debug("Cleaned input string '{}'", "");
}
@Test
public void testSetInputStringEncode_null(){
String nullString = null;
assertThrows(InvalidInputException.class, () -> {
cipher.setInputStringEncode(null);
});
assertEquals("", cipher.inputString);
verify(logger, times(1)).debug("Setting input string for encoding '{}'", nullString);
verify(logger, never()).debug("Removing case");
verify(logger, never()).debug("Removing whitespace and symbols");
verify(logger, never()).debug(eq("Cleaned input string '{}'"), anyString());
}
@Test
public void testSetInputStringDecode(){
cipher.setInputStringDecode(outputString);
assertEquals(outputString, cipher.inputString);
verify(logger, times(1)).debug("Setting input string for decoding '{}'", outputString);
verify(logger, times(1)).debug("Checking for invalid characters");
verify(logger, times(1)).debug("Saving");
}
@Test
public void testSetInputStringDecode_invalid(){
assertThrows(InvalidInputException.class, () -> {
cipher.setInputStringDecode("*");
});
assertEquals("", cipher.inputString);
verify(logger, times(1)).debug("Setting input string for decoding '{}'", "*");
verify(logger, times(1)).debug("Checking for invalid characters");
verify(logger, never()).debug("Saving");
}
@Test
public void testSetInputStringDecode_blank(){
assertThrows(InvalidInputException.class, () -> {
cipher.setInputStringDecode("");
});
assertEquals("", cipher.inputString);
verify(logger, times(1)).debug("Setting input string for decoding '{}'", "");
verify(logger, times(1)).debug("Checking for invalid characters");
verify(logger, never()).debug("Saving");
}
@Test
public void testSetInputStringDecode_null(){
String nullString = null;
assertThrows(InvalidInputException.class, () -> {
cipher.setInputStringDecode(null);
});
assertEquals("", cipher.inputString);
verify(logger, times(1)).debug("Setting input string for decoding '{}'", nullString);
verify(logger, never()).debug("Checking for invalid characters");
verify(logger, never()).debug("Saving");
}
@Test
public void testEncode(){
cipher.inputString = inputStringClean;
cipher.encode();
assertEquals(outputString, cipher.outputString);
verify(logger, times(1)).debug("Encoding");
verify(logger, times(18)).debug(eq("Working character {}"), anyChar());
verify(logger, times(15)).debug("Appending letter");
verify(logger, times(3)).debug("Appending number");
verify(logger, times(1)).debug("Saving encoded string '{}'", outputString);
}
@Test
public void testEncode_invalid(){
cipher.inputString = "*";
assertThrows(InvalidInputException.class, () -> {
cipher.encode();
});
assertEquals("", cipher.outputString);
verify(logger, times(1)).debug("Encoding");
verify(logger, times(1)).debug(eq("Working character {}"), anyChar());
verify(logger, never()).debug("Appending letter");
verify(logger, never()).debug("Appending number");
verify(logger, never()).debug("Saving encoded string '{}'", outputString);
}
@Test
public void testDecode(){
cipher.inputString = outputString;
cipher.decode();
assertEquals(inputStringClean, cipher.outputString);
verify(logger, times(1)).debug("Decoding");
verify(logger, times(18)).debug(eq("Working letter {}"), anyString());
verify(logger, times(18)).debug(eq("Decoded letter {}"), anyChar());
verify(logger, times(1)).debug("Saving decoded string '{}'", inputStringClean);
}
@Test
public void testDecode_invalid(){
cipher.inputString = "A";
assertThrows(InvalidInputException.class, () -> {
cipher.decode();
});
assertEquals("", cipher.outputString);
verify(logger, times(1)).debug("Decoding");
verify(logger, times(1)).debug(eq("Working letter {}"), anyString());
verify(logger, never()).debug(eq("Decoded letter {}"), anyChar());
verify(logger, never()).debug(eq("Saving decoded string '{}'"), anyString());
}
@Test
public void testGetters(){
cipher.inputString = inputString;
cipher.outputString = outputString;
assertEquals(inputString, cipher.getInputString());
assertEquals(outputString, cipher.getOutputString());
}
@Test
public void testReset(){
cipher.inputString = inputString;
cipher.outputString = outputString;
cipher.reset();
assertEquals("", cipher.inputString);
assertEquals("", cipher.outputString);
verify(logger, times(1)).debug("Resetting");
}
@Test
public void testPracticalEncode(){
String output = cipher.encode(inputString);
assertEquals(inputStringClean, cipher.inputString);
assertEquals(outputString, cipher.outputString);
assertEquals(outputString, output);
}
@Test
public void testPracticalDecode(){
String output = cipher.decode(outputString);
assertEquals(outputString, cipher.inputString);
assertEquals(inputStringClean, cipher.outputString);
assertEquals(inputStringClean, output);
}
}