//CipherStreamJava/src/test/java/com/mattrixwv/cipherstream/polysubstitution/TrifidTest.java
//Mattrixwv
// Created: 03-03-22
//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.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.slf4j.Logger;

import com.mattrixwv.cipherstream.exceptions.InvalidBaseException;
import com.mattrixwv.cipherstream.exceptions.InvalidCharacterException;
import com.mattrixwv.cipherstream.exceptions.InvalidInputException;
import com.mattrixwv.cipherstream.exceptions.InvalidKeywordException;
import com.mattrixwv.cipherstream.polysubstitution.Trifid.CharLocation;


@ExtendWith(MockitoExtension.class)
public class TrifidTest{
	@InjectMocks
	private Trifid cipher;
	@Mock
	private Logger logger;
	//Fields
	private static final String decodedString = "Message to^encode+";
	private static final String decodedStringClean = "MESSAGETOENCODE+";
	private static final String decodedStringCleanAlt = "MESSAGETOENCODE";
	private static final String encodedString = "Gqdokxy eg^ranmoqr";
	private static final String encodedStringAlt = "Gqdokpd od^ljvflf+";
	private static final String encodedString3 = "Gpjqdvd of^odlklf+";
	private static final String encodedStringClean = "GQDOKXYEGRANMOQR";
	private static final String encodedStringCleanAlt = "GQDOKPDODLJVFLF";
	private static final String encodedStringClean3 = "GPJQDVDOFODLKLF+";
	private static final String keyword = "ke yw*ord";
	private static final String keywordClean = "KEYWORDABCFGHIJLMNPQSTUVXZ+";
	private static final String keywordCleanAlt = "KEYWORDABCFGHIJLMNPQSTUVXZ=";
	private static final char[][][] grid = new char[][][]{
		{
			{'K', 'E', 'Y'},
			{'W', 'O', 'R'},
			{'D', 'A', 'B'}
		},
		{
			{'C', 'F', 'G'},
			{'H', 'I', 'J'},
			{'L', 'M', 'N'}
		},
		{
			{'P', 'Q', 'S'},
			{'T', 'U', 'V'},
			{'X', 'Z', '+'}
		}
	};
	private static final String gridString = "[K E Y]\n[W O R]\n[D A B]\n\n[C F G]\n[H I J]\n[L M N]\n\n[P Q S]\n[T U V]\n[X Z +]";
	private static final char[][][] gridAlt = new char[][][]{
		{
			{'K', 'E', 'Y'},
			{'W', 'O', 'R'},
			{'D', 'A', 'B'}
		},
		{
			{'C', 'F', 'G'},
			{'H', 'I', 'J'},
			{'L', 'M', 'N'}
		},
		{
			{'P', 'Q', 'S'},
			{'T', 'U', 'V'},
			{'X', 'Z', '='}
		}
	};


	@Test
	public void testConstructor_default(){
		cipher = new Trifid();

		assertFalse(cipher.preserveCapitals);
		assertFalse(cipher.preserveWhitespace);
		assertFalse(cipher.preserveSymbols);
		assertEquals('+', cipher.fillIn);
		assertEquals("", cipher.inputString);
		assertEquals("", cipher.outputString);
		assertEquals("", cipher.keyword);
		assertEquals(Integer.MAX_VALUE, cipher.groupSize);
		assertArrayEquals(new char[3][3][3], cipher.grid);
	}

	@Test
	public void testconstructor_noCapitals(){
		cipher = new Trifid(false, true, true);

		assertFalse(cipher.preserveCapitals);
		assertTrue(cipher.preserveWhitespace);
		assertTrue(cipher.preserveSymbols);
		assertEquals('+', cipher.fillIn);
		assertEquals("", cipher.inputString);
		assertEquals("", cipher.outputString);
		assertEquals("", cipher.keyword);
		assertEquals(Integer.MAX_VALUE, cipher.groupSize);
		assertArrayEquals(new char[3][3][3], cipher.grid);
	}

	@Test
	public void testconstructor_noWhitespace(){
		cipher = new Trifid(true, false, true);

		assertTrue(cipher.preserveCapitals);
		assertFalse(cipher.preserveWhitespace);
		assertTrue(cipher.preserveSymbols);
		assertEquals('+', cipher.fillIn);
		assertEquals("", cipher.inputString);
		assertEquals("", cipher.outputString);
		assertEquals("", cipher.keyword);
		assertEquals(Integer.MAX_VALUE, cipher.groupSize);
		assertArrayEquals(new char[3][3][3], cipher.grid);
	}

	@Test
	public void testconstructor_noSymbols(){
		cipher = new Trifid(true, true, false);

		assertTrue(cipher.preserveCapitals);
		assertTrue(cipher.preserveWhitespace);
		assertFalse(cipher.preserveSymbols);
		assertEquals('+', cipher.fillIn);
		assertEquals("", cipher.inputString);
		assertEquals("", cipher.outputString);
		assertEquals("", cipher.keyword);
		assertEquals(Integer.MAX_VALUE, cipher.groupSize);
		assertArrayEquals(new char[3][3][3], cipher.grid);
	}

	@Test
	public void testconstructor_fillNoCapitals(){
		cipher = new Trifid(false, true, true, '=');

		assertFalse(cipher.preserveCapitals);
		assertTrue(cipher.preserveWhitespace);
		assertTrue(cipher.preserveSymbols);
		assertEquals('=', cipher.fillIn);
		assertEquals("", cipher.inputString);
		assertEquals("", cipher.outputString);
		assertEquals("", cipher.keyword);
		assertEquals(Integer.MAX_VALUE, cipher.groupSize);
		assertArrayEquals(new char[3][3][3], cipher.grid);
	}

	@Test
	public void testconstructor_fillNoWhitespace(){
		cipher = new Trifid(true, false, true, '=');

		assertTrue(cipher.preserveCapitals);
		assertFalse(cipher.preserveWhitespace);
		assertTrue(cipher.preserveSymbols);
		assertEquals('=', cipher.fillIn);
		assertEquals("", cipher.inputString);
		assertEquals("", cipher.outputString);
		assertEquals("", cipher.keyword);
		assertEquals(Integer.MAX_VALUE, cipher.groupSize);
		assertArrayEquals(new char[3][3][3], cipher.grid);
	}

	@Test
	public void testconstructor_fillNoSymbols(){
		cipher = new Trifid(true, true, false, '=');

		assertTrue(cipher.preserveCapitals);
		assertTrue(cipher.preserveWhitespace);
		assertFalse(cipher.preserveSymbols);
		assertEquals('=', cipher.fillIn);
		assertEquals("", cipher.inputString);
		assertEquals("", cipher.outputString);
		assertEquals("", cipher.keyword);
		assertEquals(Integer.MAX_VALUE, cipher.groupSize);
		assertArrayEquals(new char[3][3][3], cipher.grid);
	}

	@Test
	public void testSetFillIn(){
		cipher.setFillIn('=');

		assertEquals('=', cipher.fillIn);
		verify(logger, times(1)).debug("Setting fill in {}", '=');
	}

	@Test
	public void testSetFillIn_nonPrintingLow(){
		assertThrows(InvalidCharacterException.class, () -> {
			cipher.setFillIn('\0');
		});

		assertEquals('+', cipher.fillIn);
		verify(logger, never()).debug(eq("Setting fill in {}"), anyChar());
	}

	@Test
	public void testSetFill_nonPrintingHigh(){
		assertThrows(InvalidCharacterException.class, () -> {
			cipher.setFillIn((char)127);
		});

		assertEquals('+', cipher.fillIn);
		verify(logger, never()).debug(eq("Setting fill in {}"), anyChar());
	}

	@Test
	public void testSetFillIn_letter(){
		assertThrows(InvalidCharacterException.class, () -> {
			cipher.setFillIn('a');
		});

		assertEquals('+', cipher.fillIn);
		verify(logger, never()).debug(eq("Setting fill in {}"), anyChar());
	}

	@Test
	public void testSetKeyword(){
		cipher.setKeyword(keyword);

		assertEquals(keywordClean, cipher.keyword);
		assertArrayEquals(grid, cipher.grid);
		verify(logger, times(1)).debug("Original keyword {}", keyword);
		verify(logger, times(1)).debug("Removing case");
		verify(logger, times(1)).debug("Removing all invalid characters");
		verify(logger, times(1)).debug("Appending entire alphabet to keyword");
		verify(logger, times(1)).debug("Removing duplicate characters");
		verify(logger, times(1)).debug("Cleaned keyword {}", keywordClean);
	}

	@Test
	public void testSetKeyword_blank(){
		char[][][] blankGrid = new char[][][]{
			{
				{'A', 'B', 'C'},
				{'D', 'E', 'F'},
				{'G', 'H', 'I'}
			},
			{
				{'J', 'K', 'L'},
				{'M', 'N', 'O'},
				{'P', 'Q', 'R'}
			},
			{
				{'S', 'T', 'U'},
				{'V', 'W', 'X'},
				{'Y', 'Z', '+'}
			}
		};
		cipher.setKeyword("");

		assertEquals("ABCDEFGHIJKLMNOPQRSTUVWXYZ+", cipher.keyword);
		assertArrayEquals(blankGrid, cipher.grid);
		verify(logger, times(1)).debug("Original keyword {}", "");
		verify(logger, times(1)).debug("Removing case");
		verify(logger, times(1)).debug("Removing all invalid characters");
		verify(logger, times(1)).debug("Appending entire alphabet to keyword");
		verify(logger, times(1)).debug("Removing duplicate characters");
		verify(logger, times(1)).debug("Cleaned keyword {}", "ABCDEFGHIJKLMNOPQRSTUVWXYZ+");
	}
	
	@Test
	public void testSetKeyword_null(){
		assertThrows(InvalidKeywordException.class, () -> {
			cipher.setKeyword(null);
		});

		assertEquals("", cipher.keyword);
		assertArrayEquals(new char[3][3][3], cipher.grid);
		verify(logger, never()).debug(eq("Original keyword {}"), anyString());
		verify(logger, never()).debug("Removing case");
		verify(logger, never()).debug("Removing all invalid characters");
		verify(logger, never()).debug("Appending entire alphabet to keyword");
		verify(logger, never()).debug("Removing duplicate characters");
		verify(logger, never()).debug(eq("Cleaned keyword {}"), anyString());
	}

	@Test
	public void setCreateGrid(){
		cipher.keyword = keywordClean;

		cipher.createGrid();

		assertArrayEquals(grid, cipher.grid);
		verify(logger, times(1)).debug("Creating grid from keyword");
		verify(logger, times(1)).debug("Completed grid\n{}", gridString);
	}

	@Test
	public void testSetGroupSize(){
		cipher.setGroupSize(1);

		assertEquals(1, cipher.groupSize);
		verify(logger, times(1)).debug("Setting group size");
	}

	@Test
	public void testSetGroupSize_negative(){
		assertThrows(InvalidBaseException.class, () -> {
			cipher.setGroupSize(-1);
		});

		assertEquals(Integer.MAX_VALUE, cipher.groupSize);
		verify(logger, never()).debug("Setting group size");
	}

	@Test
	public void testSetInputString(){
		cipher.preserveCapitals = true;
		cipher.preserveWhitespace = true;
		cipher.preserveSymbols = true;

		cipher.setInputString(decodedString);

		assertEquals(decodedString, cipher.inputString);
		verify(logger, times(1)).debug("Original input string '{}'", decodedString);
		verify(logger, never()).debug("Removing case");
		verify(logger, never()).debug("Removing whitespace");
		verify(logger, never()).debug("Removing symbols");
		verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString);
	}

	@Test
	public void testSetInputString_noCapitals(){
		cipher.preserveCapitals = false;
		cipher.preserveWhitespace = true;
		cipher.preserveSymbols = true;

		cipher.setInputString(decodedString);

		assertEquals(decodedString.toUpperCase(), cipher.inputString);
		verify(logger, times(1)).debug("Original input string '{}'", decodedString);
		verify(logger, times(1)).debug("Removing case");
		verify(logger, never()).debug("Removing whitespace");
		verify(logger, never()).debug("Removing symbols");
		verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.toUpperCase());
	}

	@Test
	public void testSetInputString_noWhitespace(){
		cipher.preserveCapitals = true;
		cipher.preserveWhitespace = false;
		cipher.preserveSymbols = true;

		cipher.setInputString(decodedString);

		assertEquals(decodedString.replaceAll("\\s", ""), cipher.inputString);
		verify(logger, times(1)).debug("Original input string '{}'", decodedString);
		verify(logger, never()).debug("Removing case");
		verify(logger, times(1)).debug("Removing whitespace");
		verify(logger, never()).debug("Removing symbols");
		verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("\\s", ""));
	}

	@Test
	public void testSetInputString_noWhitespaceFill(){
		cipher.preserveCapitals = true;
		cipher.preserveWhitespace = false;
		cipher.preserveSymbols = true;
		cipher.fillIn = ' ';

		assertThrows(InvalidInputException.class, () -> {
			cipher.setInputString(decodedString);
		});

		assertEquals("", cipher.inputString);
		verify(logger, times(1)).debug("Original input string '{}'", decodedString);
		verify(logger, never()).debug("Removing case");
		verify(logger, never()).debug("Removing whitespace");
		verify(logger, never()).debug("Removing symbols");
		verify(logger, never()).debug(eq("Cleaned input string '{}'"), anyString());
	}

	@Test
	public void testSetInputString_noSymbols(){
		cipher.preserveCapitals = true;
		cipher.preserveWhitespace = true;
		cipher.preserveSymbols = false;

		cipher.setInputString(decodedString);

		assertEquals(decodedString.replaceAll("[^a-zA-Z\\s+]", ""), cipher.inputString);
		verify(logger, times(1)).debug("Original input string '{}'", decodedString);
		verify(logger, never()).debug("Removing case");
		verify(logger, never()).debug("Removing whitespace");
		verify(logger, times(1)).debug("Removing symbols");
		verify(logger, times(1)).debug("Cleaned input string '{}'", decodedString.replaceAll("[^a-zA-Z\\s+]", ""));
	}

	@Test
	public void testSetInputString_blank(){
		cipher.preserveCapitals = true;
		cipher.preserveWhitespace = true;
		cipher.preserveSymbols = true;

		assertThrows(InvalidInputException.class, () -> {
			cipher.setInputString("");
		});

		assertEquals("", cipher.inputString);
		verify(logger, times(1)).debug("Original input string '{}'", "");
		verify(logger, never()).debug("Removing case");
		verify(logger, never()).debug("Removing whitespace");
		verify(logger, never()).debug("Removing symbols");
		verify(logger, times(1)).debug("Cleaned input string '{}'", "");
	}

	@Test
	public void testSetInputString_null(){
		cipher.preserveCapitals = true;
		cipher.preserveWhitespace = true;
		cipher.preserveSymbols = true;

		assertThrows(InvalidInputException.class, () -> {
			cipher.setInputString(null);
		});

		assertEquals("", cipher.inputString);
		verify(logger, never()).debug(eq("Original input string '{}'"), anyString());
		verify(logger, never()).debug("Removing case");
		verify(logger, never()).debug("Removing whitespace");
		verify(logger, never()).debug("Removing symbols");
		verify(logger, never()).debug(eq("Cleaned input string '{}'"), anyString());
	}

	@Test
	public void testGetCleanInputString(){
		cipher.inputString = decodedString;

		String returnedInput = cipher.getCleanInputString();

		assertEquals(decodedStringClean, returnedInput);
		verify(logger, times(1)).debug("Cleaning input string for encoding");
	}

	@Test
	public void testFindChar(){
		cipher.grid = grid;

		CharLocation returnedLocation = cipher.findChar('G');

		assertEquals(cipher.new CharLocation(0, 2, 1).toString(), returnedLocation.toString());
		verify(logger, times(1)).debug("Finding character {} in grid", 'G');
		verify(logger, times(1)).debug("Found at {} {} {}", 1, 0, 2);
	}

	@Test
	public void testFindChar_invalid(){
		cipher.grid = grid;

		assertThrows(InvalidCharacterException.class, () -> {
			cipher.findChar('=');
		});

		verify(logger, times(1)).debug("Finding character {} in grid", '=');
		verify(logger, never()).debug(eq("Found at {} {} {}"), anyInt(), anyInt(), anyInt());
	}

	@Test
	public void testGetChar(){
		cipher.grid = grid;

		char returnedChar = cipher.getChar(cipher.new CharLocation(0, 1, 2));

		assertEquals('Q', returnedChar);
		verify(logger, times(1)).debug("Getting character at {} {} {}", 2, 0, 1);
	}

	@ParameterizedTest
	@CsvSource({
		"3, 1, 2",
		"0, 3, 2",
		"0, 1, 3"
	})
	public void testGetChar_invalidLocation(int x, int y, int z){
		cipher.grid = grid;
		CharLocation location = cipher.new CharLocation(x, y, z);

		assertThrows(InvalidCharacterException.class, () -> {
			cipher.getChar(location);
		});

		verify(logger, never()).debug(eq("Getting character at {} {} {}"), anyInt(), anyInt(), anyInt());
	}

	@Test
	public void testFormatOutput(){
		cipher.preserveCapitals = true;
		cipher.inputString = decodedString;

		cipher.formatOutput(encodedStringClean);

		assertEquals(encodedString, cipher.outputString);
		verify(logger, times(1)).debug("Formatting output");
		verify(logger, times(18)).debug(eq("Working character {}"), anyChar());
		verify(logger, times(1)).debug("Formatting uppercase");
		verify(logger, times(14)).debug("Formatting lowercase");
		verify(logger, times(1)).debug("Adding fillIn");
		verify(logger, times(2)).debug("Appending symbol");
		verify(logger, times(1)).debug("Formatted output '{}'", encodedString);
	}

	@Test
	public void testFormatOutput_noCapitals(){
		cipher.preserveCapitals = false;
		cipher.inputString = decodedString.toUpperCase();

		cipher.formatOutput(encodedStringClean);

		assertEquals(encodedString.toUpperCase(), cipher.outputString);
		verify(logger, times(1)).debug("Formatting output");
		verify(logger, times(18)).debug(eq("Working character {}"), anyChar());
		verify(logger, times(15)).debug("Formatting uppercase");
		verify(logger, never()).debug("Formatting lowercase");
		verify(logger, times(1)).debug("Adding fillIn");
		verify(logger, times(2)).debug("Appending symbol");
		verify(logger, times(1)).debug("Formatted output '{}'", encodedString.toUpperCase());
	}

	@Test
	public void testEncode(){
		cipher.preserveCapitals = true;
		cipher.inputString = decodedString;
		cipher.keyword = keywordClean;
		cipher.grid = grid;

		cipher.encode();

		assertEquals(encodedString, cipher.outputString);
		verify(logger, times(1)).debug("Encoding");
		verify(logger, times(1)).debug("Converting letters to coordinates");
		verify(logger, times(1)).debug("Splitting locations into groups");
		verify(logger, times(1)).debug("Splitting groups into rows");
		verify(logger, times(1)).debug("Converting split locations into new locations");
		verify(logger, times(1)).debug("Converting new locations into characters");
	}

	@Test
	public void testEncode_3(){
		cipher.preserveCapitals = true;
		cipher.inputString = decodedString;
		cipher.keyword = keywordClean;
		cipher.grid = grid;
		cipher.groupSize = 3;

		cipher.encode();

		assertEquals(encodedString3, cipher.outputString);
		verify(logger, times(1)).debug("Encoding");
		verify(logger, times(1)).debug("Converting letters to coordinates");
		verify(logger, times(1)).debug("Splitting locations into groups");
		verify(logger, times(1)).debug("Splitting groups into rows");
		verify(logger, times(1)).debug("Converting split locations into new locations");
		verify(logger, times(1)).debug("Converting new locations into characters");
	}

	@Test
	public void testDecode(){
		cipher.preserveCapitals = true;
		cipher.inputString = encodedString;
		cipher.keyword = keywordClean;
		cipher.grid = grid;

		cipher.decode();

		assertEquals(decodedString, cipher.outputString);
		verify(logger, times(1)).debug("Decoding");
		verify(logger, times(1)).debug("Converting letters to coordinates");
		verify(logger, times(1)).debug("Splitting locations into groups");
		verify(logger, times(1)).debug("Putting locations into rows");
		verify(logger, times(1)).debug("Converting locations into new locations");
		verify(logger, times(1)).debug("Converting new locations into letters");
	}

	@Test
	public void testDecode_3(){
		cipher.preserveCapitals = true;
		cipher.inputString = encodedString3;
		cipher.keyword = keywordClean;
		cipher.grid = grid;
		cipher.groupSize = 3;

		cipher.decode();

		assertEquals(decodedString, cipher.outputString);
		verify(logger, times(1)).debug("Decoding");
		verify(logger, times(1)).debug("Converting letters to coordinates");
		verify(logger, times(1)).debug("Splitting locations into groups");
		verify(logger, times(1)).debug("Putting locations into rows");
		verify(logger, times(6)).debug("Converting locations into new locations");
		verify(logger, times(1)).debug("Converting new locations into letters");
	}

	@Test
	public void testGetters(){
		cipher.inputString = decodedString;
		cipher.outputString = encodedString;
		cipher.keyword = keywordClean;
		cipher.groupSize = 3;
		cipher.fillIn = '=';
		cipher.grid = grid;

		assertEquals(decodedString, cipher.getInputString());
		assertEquals(encodedString, cipher.getOutputString());
		assertEquals(keywordClean, cipher.getKeyword());
		assertEquals(3, cipher.getGroupSize());
		assertEquals('=', cipher.getFillIn());
		assertEquals(gridString, cipher.getGrid());
	}

	@Test
	public void testReset(){
		cipher.inputString = decodedString;
		cipher.outputString = encodedString;
		cipher.keyword = keyword;
		cipher.groupSize = 3;
		cipher.grid = grid;

		cipher.reset();

		assertEquals("", cipher.inputString);
		assertEquals("", cipher.outputString);
		assertEquals("", cipher.keyword);
		assertEquals(Integer.MAX_VALUE, cipher.groupSize);
		assertArrayEquals(new char[3][3][3], cipher.grid);
	}

	@Test
	public void testPracticalEncoding(){
		cipher = new Trifid(true, true, true);

		String output = cipher.encode(keyword, decodedString);

		assertEquals(decodedString, cipher.inputString);
		assertEquals(keywordClean, cipher.keyword);
		assertEquals(encodedString, cipher.outputString);
		assertEquals(encodedString, output);
		assertArrayEquals(grid, cipher.grid);
	}

	@Test
	public void testPracticalEncoding_3(){
		cipher = new Trifid(true, true, true);

		String output = cipher.encode(keyword, 3, decodedString);

		assertEquals(decodedString, cipher.inputString);
		assertEquals(keywordClean, cipher.keyword);
		assertEquals(encodedString3, cipher.outputString);
		assertEquals(encodedString3, output);
		assertArrayEquals(grid, cipher.grid);
	}

	@Test
	public void testPracticalEncoding_fill(){
		cipher = new Trifid(true, true, true, '=');

		String output = cipher.encode(keyword, decodedString);

		assertEquals(decodedString, cipher.inputString);
		assertEquals(keywordCleanAlt, cipher.keyword);
		assertEquals(encodedStringAlt, cipher.outputString);
		assertEquals(encodedStringAlt, output);
		assertArrayEquals(gridAlt, cipher.grid);
	}

	@Test
	public void testPracticalEncoding_clean(){
		cipher = new Trifid(false, false, false);

		String output = cipher.encode(keyword, decodedString);

		assertEquals(decodedStringClean, cipher.inputString);
		assertEquals(keywordClean, cipher.keyword);
		assertEquals(encodedStringClean, cipher.outputString);
		assertEquals(encodedStringClean, output);
		assertArrayEquals(grid, cipher.grid);
	}

	@Test
	public void testPracticalEncoding_clean3(){
		cipher = new Trifid(false, false, false);

		String output = cipher.encode(keyword, 3, decodedString);

		assertEquals(decodedStringClean, cipher.inputString);
		assertEquals(keywordClean, cipher.keyword);
		assertEquals(encodedStringClean3, cipher.outputString);
		assertEquals(encodedStringClean3, output);
		assertArrayEquals(grid, cipher.grid);
	}

	@Test
	public void testPracticalEncoding_cleanFill(){
		cipher = new Trifid(false, false, false, '=');

		String output = cipher.encode(keyword, decodedString);

		assertEquals(decodedStringCleanAlt, cipher.inputString);
		assertEquals(keywordCleanAlt, cipher.keyword);
		assertEquals(encodedStringCleanAlt, cipher.outputString);
		assertEquals(encodedStringCleanAlt, output);
		assertArrayEquals(gridAlt, cipher.grid);
	}

	@Test
	public void testPracticalDecoding(){
		cipher = new Trifid(true, true, true);

		String output = cipher.decode(keyword, encodedString);

		assertEquals(encodedString, cipher.inputString);
		assertEquals(keywordClean, cipher.keyword);
		assertEquals(decodedString, cipher.outputString);
		assertEquals(decodedString, output);
		assertArrayEquals(grid, cipher.grid);
	}

	@Test
	public void testPracticalDecoding_3(){
		cipher = new Trifid(true, true, true);

		String output = cipher.decode(keyword, 3, encodedString3);

		assertEquals(encodedString3, cipher.inputString);
		assertEquals(keywordClean, cipher.keyword);
		assertEquals(decodedString, cipher.outputString);
		assertEquals(decodedString, output);
		assertArrayEquals(grid, cipher.grid);
	}

	@Test
	public void testPracticalDecoding_fill(){
		cipher = new Trifid(true, true, true, '=');

		String output = cipher.decode(keyword, encodedStringAlt);

		assertEquals(encodedStringAlt, cipher.inputString);
		assertEquals(keywordCleanAlt, cipher.keyword);
		assertEquals(decodedString, cipher.outputString);
		assertEquals(decodedString, output);
		assertArrayEquals(gridAlt, cipher.grid);
	}

	@Test
	public void testpracticalDecoding_clean(){
		cipher = new Trifid(false, false, false);

		String output = cipher.decode(keyword, encodedString);

		assertEquals(encodedStringClean, cipher.inputString);
		assertEquals(keywordClean, cipher.keyword);
		assertEquals(decodedStringClean, cipher.outputString);
		assertEquals(decodedStringClean, output);
		assertArrayEquals(grid, cipher.grid);
	}

	@Test
	public void testPracticalDecoding_clean3(){
		cipher = new Trifid(false, false, false);

		String output = cipher.decode(keyword, 3, encodedString3);

		assertEquals(encodedStringClean3, cipher.inputString);
		assertEquals(keywordClean, cipher.keyword);
		assertEquals(decodedStringClean, cipher.outputString);
		assertEquals(decodedStringClean, output);
		assertArrayEquals(grid, cipher.grid);
	}

	@Test
	public void testPracticalDecoding_cleanFill(){
		cipher = new Trifid(false, false, false, '=');

		String output = cipher.decode(keyword, encodedStringAlt);

		assertEquals(encodedStringCleanAlt, cipher.inputString);
		assertEquals(keywordCleanAlt, cipher.keyword);
		assertEquals(decodedStringCleanAlt, cipher.outputString);
		assertEquals(decodedStringCleanAlt, output);
		assertArrayEquals(gridAlt, cipher.grid);
	}
}