Comprehensive Test Suite Enhancement for Hamming Distance Algorithm

This enhancement significantly improves the test coverage and structure of the Hamming Distance calculator implementation. The updates focus on robust testing practices, edge cases, and maintainability.

Author: TusharNaugain

src/test/java/com/thealgorithms/strings/HammingDistanceTest.java

@@ -1,36 +1,118 @@
 package com.thealgorithms.strings;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.*;
 
 import java.util.stream.Stream;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.CsvSource;
-import org.junit.jupiter.params.provider.MethodSource;
 
+/**
+ * Test class for HammingDistance calculator.
+ * Tests various scenarios including:
+ * - Valid string pairs with different Hamming distances
+ * - Edge cases (empty strings, same strings)
+ * - Invalid inputs (null values, unequal lengths)
+ * - Special characters and Unicode strings
+ */
+@DisplayName("Hamming Distance Calculator Tests")
 class HammingDistanceTest {
+    
+    private static final String ERROR_MESSAGE_UNEQUAL_LENGTH = "String lengths must be equal";
+    private static final String ERROR_MESSAGE_NULL_INPUT = "Input strings cannot be null";
 
-    @ParameterizedTest
-    @CsvSource({"'', '', 0", "'java', 'java', 0", "'karolin', 'kathrin', 3", "'kathrin', 'kerstin', 4", "'00000', '11111', 5", "'10101', '10100', 1"})
-    void testHammingDistance(String s1, String s2, int expected) {
-        assertEquals(expected, HammingDistance.calculateHammingDistance(s1, s2));
+    @Nested
+    @DisplayName("Valid Input Tests")
+    class ValidInputTests {
+        
+        @ParameterizedTest(name = "Calculate distance between \"{0}\" and \"{1}\" = {2}")
+        @CsvSource({
+            // Basic cases
+            "'', '', 0",
+            "'java', 'java', 0",
+            "'karolin', 'kathrin', 3",
+            "'kathrin', 'kerstin', 4",
+            
+            // Binary strings
+            "'00000', '11111', 5",
+            "'10101', '10100', 1",
+            
+            // Special characters
+            "'hello!', 'hello.', 1",
+            "'@#$%^&', '@#$%^*', 1",
+            
+            // Unicode characters
+            "'über④⑤', 'uber45', 2",
+            "'münchen', 'munchen', 1"
+        })
+        void shouldCalculateHammingDistance(String s1, String s2, int expected) {
+            assertEquals(expected, HammingDistance.calculateHammingDistance(s1, s2),
+                    () -> String.format("Failed to calculate correct Hamming distance for '%s' and '%s'", s1, s2));
+        }
+
+        @Test
+        @DisplayName("Should handle maximum length strings")
+        void shouldHandleMaximumLengthStrings() {
+            String str1 = "a".repeat(1000);
+            String str2 = "b".repeat(1000);
+            assertEquals(1000, HammingDistance.calculateHammingDistance(str1, str2),
+                    "Should correctly calculate distance for maximum length strings");
+        }
     }
 
-    @ParameterizedTest
-    @MethodSource("provideNullInputs")
-    void testHammingDistanceWithNullInputs(String input1, String input2) {
-        assertThrows(IllegalArgumentException.class, () -> HammingDistance.calculateHammingDistance(input1, input2));
+    @Nested
+    @DisplayName("Invalid Input Tests")
+    class InvalidInputTests {
+        
+        @ParameterizedTest(name = "Test null input: first={0}, second={1}")
+        @MethodSource("com.thealgorithms.strings.HammingDistanceTest#provideNullInputs")
+        void shouldThrowExceptionForNullInputs(String input1, String input2) {
+            IllegalArgumentException exception = assertThrows(
+                IllegalArgumentException.class,
+                () -> HammingDistance.calculateHammingDistance(input1, input2),
+                "Should throw IllegalArgumentException for null inputs"
+            );
+            assertEquals(ERROR_MESSAGE_NULL_INPUT, exception.getMessage(),
+                    "Exception message should match for null inputs");
+        }
+
+        @ParameterizedTest(name = "Test unequal lengths: \"{0}\" and \"{1}\"")
+        @CsvSource({
+            "ab, abc",
+            "a, aa",
+            "hello, hi",
+            "'', a"
+        })
+        void shouldThrowExceptionForUnequalLengths(String s1, String s2) {
+            IllegalArgumentException exception = assertThrows(
+                IllegalArgumentException.class,
+                () -> HammingDistance.calculateHammingDistance(s1, s2),
+                "Should throw IllegalArgumentException for unequal length strings"
+            );
+            assertEquals(ERROR_MESSAGE_UNEQUAL_LENGTH, exception.getMessage(),
+                    "Exception message should match for unequal lengths");
+        }
     }
 
+    // Test data providers
     private static Stream<Arguments> provideNullInputs() {
-        return Stream.of(Arguments.of(null, "abc"), Arguments.of("abc", null), Arguments.of(null, null));
+        return Stream.of(
+            Arguments.of(null, "abc"),
+            Arguments.of("abc", null),
+            Arguments.of(null, null)
+        );
     }
 
     @Test
-    void testNotEqualStringLengths() {
-        Exception exception = assertThrows(IllegalArgumentException.class, () -> HammingDistance.calculateHammingDistance("ab", "abc"));
-        assertEquals("String lengths must be equal", exception.getMessage());
+    @DisplayName("Performance test with large strings")
+    void performanceTest() {
+        String str1 = "a".repeat(10000) + "b".repeat(10000);
+        String str2 = "a".repeat(10000) + "c".repeat(10000);
+        
+        assertTimeoutPreemptively(
+            java.time.Duration.ofSeconds(1),
+            () -> HammingDistance.calculateHammingDistance(str1, str2),
+            "Should complete calculation within reasonable time"
+        );
     }
 }