test(compression): Improve test coverage for LZW and ArithmeticCoding

Author: Microindole

src/main/java/com/thealgorithms/compression/ArithmeticCoding.java

@@ -153,6 +153,5 @@ public static Map<Character, Symbol> calculateProbabilities(String text) {
      * Helper class to store the probability range [low, high) for a symbol.
      */
     public record Symbol(BigDecimal low, BigDecimal high) {
-
     }
 }

src/test/java/com/thealgorithms/compression/ArithmeticCodingTest.java

@@ -6,8 +6,8 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.math.BigDecimal;
+import java.util.HashMap;
 import java.util.Map;
-
 import org.junit.jupiter.api.Test;
 
 class ArithmeticCodingTest {
@@ -116,4 +116,39 @@ void testProbabilityTableCalculation() {
             assertTrue(symbol.low().compareTo(symbol.high()) < 0);
         }
     }
+
+    @Test
+    void testDecompressionWithMismatchedProbabilityTable() {
+        // Test decompression with a probability table that doesn't match the original
+        String original = "ABCD";
+        BigDecimal compressed = ArithmeticCoding.compress(original);
+
+        // Create a different probability table (for "XYZ" instead of "ABCD")
+        Map<Character, ArithmeticCoding.Symbol> wrongProbTable = ArithmeticCoding.calculateProbabilities("XYZ");
+
+        // Decompression with wrong probability table should produce incorrect output
+        String decompressed = ArithmeticCoding.decompress(compressed, original.length(), wrongProbTable);
+
+        // The decompressed string will be different from original (likely all 'X', 'Y', or 'Z')
+        // This tests the edge case where the compressed value doesn't fall into expected ranges
+        assertNotNull(decompressed);
+        assertEquals(original.length(), decompressed.length());
+    }
+
+    @Test
+    void testDecompressionWithValueOutsideSymbolRanges() {
+        // Create a custom probability table
+        Map<Character, ArithmeticCoding.Symbol> probTable = new HashMap<>();
+        probTable.put('A', new ArithmeticCoding.Symbol(new BigDecimal("0.0"), new BigDecimal("0.5")));
+        probTable.put('B', new ArithmeticCoding.Symbol(new BigDecimal("0.5"), new BigDecimal("1.0")));
+
+        // Use a compressed value that should decode properly
+        BigDecimal compressed = new BigDecimal("0.25"); // Falls in 'A' range
+
+        String decompressed = ArithmeticCoding.decompress(compressed, 3, probTable);
+
+        // Verify decompression completes (even if result might not be meaningful)
+        assertNotNull(decompressed);
+        assertEquals(3, decompressed.length());
+    }
 }

src/test/java/com/thealgorithms/compression/LZWTest.java

@@ -1,11 +1,12 @@
 package com.thealgorithms.compression;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-
 import org.junit.jupiter.api.Test;
 
 class LZWTest {
@@ -75,4 +76,32 @@ void testSymmetry() {
         String decompressed2 = LZW.decompress(compressed2);
         assertEquals(original2, decompressed2);
     }
-}
+
+    @Test
+    void testInvalidCompressedData() {
+        // Test that decompressing with an invalid code throws IllegalArgumentException
+        // Create a list with a code that doesn't exist in the dictionary
+        List<Integer> invalidCompressed = new ArrayList<>();
+        invalidCompressed.add(65);  // 'A' - valid
+        invalidCompressed.add(999); // Invalid code (not in dictionary)
+
+        // This should throw IllegalArgumentException with message "Bad compressed k: 999"
+        IllegalArgumentException exception = assertThrows(
+                IllegalArgumentException.class,
+                () -> LZW.decompress(invalidCompressed)
+        );
+
+        assertTrue(exception.getMessage().contains("Bad compressed k: 999"));
+    }
+
+    @Test
+    void testDecompressionWithGapInDictionary() {
+        // Test with codes that skip dictionary entries
+        List<Integer> invalidCompressed = new ArrayList<>();
+        invalidCompressed.add(84);   // 'T' - valid
+        invalidCompressed.add(500);  // Way beyond current dictionary size
+
+        // This should throw IllegalArgumentException
+        assertThrows(IllegalArgumentException.class, () -> LZW.decompress(invalidCompressed));
+    }
+}