refactor: Merge files testing the same packages

Author: labe2301

…com/thealgorithms/ciphers/MyAESTest.java …a/com/thealgorithms/ciphers/AESTest.javasrc/test/java/com/thealgorithms/ciphers/MyAESTest.java renamed to src/test/java/com/thealgorithms/ciphers/AESTest.java src/test/java/com/thealgorithms/ciphers/MyAESTest.java renamed to src/test/java/com/thealgorithms/ciphers/AESTest.java

@@ -7,7 +7,7 @@
 import java.math.BigInteger;
 import org.junit.jupiter.api.Test;
 
-public class MyAESTest {
+public class AESTest {
     @Test
     void testScheduleCore() {
         BigInteger input = new BigInteger("1a2b3c4d", 16);

src/test/java/com/thealgorithms/ciphers/CaesarTest.java

@@ -43,4 +43,78 @@ void caesarBruteForce() {
         assertEquals(27, allPossibleAnswers.length);
         assertEquals("Encrypt this text", allPossibleAnswers[5]);
     }
+
+    @Test
+    void shouldReturnSameAsInputWhenShiftingZeroOr26() {
+        String message = "message";
+
+        String encoded1 = caesar.encode(message, 0);
+        String encoded2 = caesar.encode(message, 26);
+
+        assertEquals(message, encoded1, "Encoded should be same as original");
+        assertEquals(message, encoded2, "Encoded should be same as original");
+    }
+
+    @Test
+    void shouldReturnsameAsInputWhenUsingCharactersOutsideLatinAlphabet() {
+        String message = "!#¤%&/()=?`^½§@£$€{[]}´`¨~'*-.,_:;<>|";
+
+        String encoded = caesar.encode(message, 10);
+
+        assertEquals(message, encoded);
+    }
+
+    @Test
+    void shouldWrapZToAWhenEncodingSingleShift() {
+        String message = "zZ";
+
+        String encoded = caesar.encode(message, 1);
+        String exptected = "aA";
+
+        assertEquals(exptected, encoded, "zZ should wrap to aA");
+    }
+
+    @Test
+    void shouldWrapAToZWhenDecodingSingleShift() {
+        String message = "aA";
+
+        String decoded = caesar.decode(message, 1);
+        String expected = "zZ";
+
+        assertEquals(expected, decoded);
+    }
+
+    @Test
+    void shouldNotWrapWhenEncodingFromYToZ() {
+        String message = "yY";
+
+        String encoded = caesar.encode(message, 1);
+        String expected = "zZ";
+
+        assertEquals(expected, encoded);
+    }
+
+    @Test
+    void shouldNotWrapWhenDecodingFromBToA() {
+        String message = "bB";
+
+        String decoded = caesar.decode(message, 1);
+        String expected = "aA";
+
+        assertEquals(expected, decoded);
+    }
+
+    @Test
+    void shouldContain27CombinationsFromBruteForce() {
+        String message = "message";
+
+        String encoded = caesar.encode(message, 10);
+        String[] combinations = caesar.bruteforce(encoded);
+        String expected = "wocckqo";
+
+        assertEquals(27, combinations.length, "Should contain 27 possible decoded combinations");
+        assertEquals(expected, combinations[0], "First combination should contain encoded message");
+        assertEquals(message, combinations[10], "10:th entry should contain original message");
+        assertEquals(expected, combinations[26], "26:th entry should be the same as the 0:th entry, the encoded message");
+    }
 }

src/test/java/com/thealgorithms/ciphers/ColumnarTranspositionCipherTest.java

@@ -5,6 +5,7 @@
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -44,4 +45,115 @@ public void testLongPlainText() {
         assertEquals(longText.replaceAll(" ", ""), decryptedText.replaceAll(" ", ""), "The decrypted text should match the original long plaintext, ignoring spaces.");
         assertEquals(encryptedText, ColumnarTranspositionCipher.encrypt(longText, keyword), "The encrypted text should be the same when encrypted again.");
     }
+
+    @Test
+    void shouldNotProduceNullOrEmptyEncryptedText() {
+        String encrypted = ColumnarTranspositionCipher.encrypt(plaintext, keyword);
+
+        Assertions.assertNotNull(encrypted, "Encrypted text should not be null");
+        Assertions.assertFalse(encrypted.isEmpty(), "Encrypted text should not be empty");
+    }
+
+    @Test
+    void shouldChangePlaintextToEncrypted() {
+        String encrypted = ColumnarTranspositionCipher.encrypt(plaintext, keyword);
+
+        Assertions.assertNotEquals(plaintext, encrypted, "Encrypted text should differ from plaintext");
+    }
+
+    @Test
+    void shouldEncryptDetermenistically() {
+        String encrypted1 = ColumnarTranspositionCipher.encrypt(plaintext, keyword);
+        String encrypted2 = ColumnarTranspositionCipher.encrypt(plaintext, keyword);
+
+        Assertions.assertEquals(encrypted1, encrypted2, "Encryptions should be equal");
+    }
+
+    @Test
+    void shouldProduceDifferentEncryptionsWithDifferentKeywoards() {
+        String keyword2 = keyword + "a";
+
+        String encrypted1 = ColumnarTranspositionCipher.encrypt(plaintext, keyword);
+        String encrypted2 = ColumnarTranspositionCipher.encrypt(plaintext, keyword2);
+
+        Assertions.assertNotEquals(encrypted1, encrypted2, "Should produce different encryptions");
+    }
+
+    @Test
+    void shouldMatchWithUnsortedKeyword() {
+        String myPlaintext = "123456789";
+        String myKeyword = "unsorted";
+
+        String encrypted = ColumnarTranspositionCipher.encrypt(myPlaintext, myKeyword);
+        String expected = "8≈7≈2≈4≈5≈3≈6≈19";
+
+        Assertions.assertEquals(expected, encrypted, "Should match");
+    }
+
+    @Test
+    void shouldMatchEncryptionAndDecryptionWithNoSpacesOrPadding() {
+        String myPlaintext = "NoSpacesOrPadding";
+
+        ColumnarTranspositionCipher.encrypt(myPlaintext, keyword);
+        String decrypted = ColumnarTranspositionCipher.decrypt();
+
+        Assertions.assertEquals(myPlaintext, decrypted, "Decrypted text should match original plaintext");
+    }
+
+    @Test
+    void shouldNotContainPaddingInDecryption() {
+        String myPlaintext = "text";
+
+        ColumnarTranspositionCipher.encrypt(myPlaintext, keyword);
+        String decrypted = ColumnarTranspositionCipher.decrypt();
+
+        Assertions.assertFalse(decrypted.contains("≈"), "Should not contain padding characters");
+    }
+
+    @Test
+    void shouldEncryptWithKeywordLongerThanPlaintext() {
+        String myPlaintext = "text";
+        String myKeyword = "averylongkeyword";
+
+        String encryption = ColumnarTranspositionCipher.encrypt(myPlaintext, myKeyword);
+
+        Assertions.assertNotNull(encryption, "Should encrypt where plaintext.length() < keyword.length()");
+    }
+
+    @Test
+    void shouldEncryptWithKeywordWithSameLengthAsPlaintext() {
+        String myPlaintext = "textaslongaskeyword";
+        String myKeyword = "keywordaslongastext";
+
+        String encryption = ColumnarTranspositionCipher.encrypt(myPlaintext, myKeyword);
+
+        Assertions.assertNotNull(encryption, "Should encrypt where plaintext.length() == keyword.length()");
+    }
+
+    @Test
+    void shouldProduceDifferentEncryptionForSameKeywordButSortedDifferently() {
+        String unsertedKeyword1 = "EFGHABCD";
+        String unsertedKeyword2 = "AEBFCGDH";
+
+        String encrypted1 = ColumnarTranspositionCipher.encrypt(plaintext, unsertedKeyword1);
+        String encrypted2 = ColumnarTranspositionCipher.encrypt(plaintext, unsertedKeyword2);
+
+        Assertions.assertNotEquals(encrypted1, encrypted2, "Should differ with different keywords");
+    }
+
+    @Test
+    void shouldEncryptWithCustomAbecedarium() {
+        String myAbecedarium = "abcdefghijklmnopqrstuvwxyz";
+
+        String encryption = ColumnarTranspositionCipher.encrypt(plaintext, keyword, myAbecedarium);
+
+        Assertions.assertNotNull(encryption, "Should encrypt with custom abecedarium");
+    }
+
+    @Test
+    void shouldNotEncryptWithInvalidAbecedarium() {
+        String myAbecedarium = "abcde";
+
+        Assertions.assertThrows(NullPointerException.class, () -> ColumnarTranspositionCipher.encrypt(plaintext, keyword, myAbecedarium), "Should throw error when keyword contains characters not present in abecedarium");
+    }
 }