Enhance docs, add more tests in NumbersDifferentSigns (#5858)

src/main/java/com/thealgorithms/bitmanipulation/NumbersDifferentSigns.java

@@ -1,14 +1,29 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * Numbers Different Signs
+ * This class provides a method to determine whether two integers have
+ * different signs. It utilizes the XOR operation on the two numbers:
+ *
+ * - If two numbers have different signs, their most significant bits
+ *   (sign bits) will differ, resulting in a negative XOR result.
+ * - If two numbers have the same sign, the XOR result will be non-negative.
+ *
+ * Time Complexity: O(1) - Constant time operation.
+ * Space Complexity: O(1) - No extra space used.
+ *
  * @author Bama Charan Chhandogi
  */
-
 public final class NumbersDifferentSigns {
     private NumbersDifferentSigns() {
     }
 
+    /**
+     * Determines if two integers have different signs using bitwise XOR.
+     *
+     * @param num1 the first integer
+     * @param num2 the second integer
+     * @return true if the two numbers have different signs, false otherwise
+     */
     public static boolean differentSigns(int num1, int num2) {
         return (num1 ^ num2) < 0;
     }

src/test/java/com/thealgorithms/bitmanipulation/NumbersDifferentSignsTest.java

@@ -3,30 +3,44 @@ package com.thealgorithms.bitmanipulation;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import org.junit.jupiter.api.Test;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
 /**
- * test Cases of Numbers Different Signs
+ * Parameterized tests for NumbersDifferentSigns class, which checks
+ * if two integers have different signs using bitwise XOR.
+ *
  * @author Bama Charan Chhandogi
  */
 class NumbersDifferentSignsTest {
 
-    @Test
-    void testDifferentSignsPositiveNegative() {
-        assertTrue(NumbersDifferentSigns.differentSigns(2, -1));
+    @ParameterizedTest
+    @MethodSource("provideTestCases")
+    void testDifferentSigns(int num1, int num2, boolean expected) {
+        if (expected) {
+            assertTrue(NumbersDifferentSigns.differentSigns(num1, num2));
+        } else {
+            assertFalse(NumbersDifferentSigns.differentSigns(num1, num2));
+        }
     }
 
-    @Test
-    void testDifferentSignsNegativePositive() {
-        assertTrue(NumbersDifferentSigns.differentSigns(-3, 7));
-    }
+    private static Stream<Arguments> provideTestCases() {
+        return Stream.of(
+            // Different signs (positive and negative)
+            Arguments.of(2, -1, Boolean.TRUE), Arguments.of(-3, 7, Boolean.TRUE),
 
-    @Test
-    void testSameSignsPositive() {
-        assertFalse(NumbersDifferentSigns.differentSigns(10, 20));
-    }
+            // Same signs (both positive)
+            Arguments.of(10, 20, Boolean.FALSE), Arguments.of(0, 5, Boolean.FALSE), // 0 is considered non-negative
 
-    @Test
-    void testSameSignsNegative() {
-        assertFalse(NumbersDifferentSigns.differentSigns(-5, -8));
+            // Same signs (both negative)
+            Arguments.of(-5, -8, Boolean.FALSE),
+
+            // Edge case: Large positive and negative values
+            Arguments.of(Integer.MAX_VALUE, Integer.MIN_VALUE, Boolean.TRUE),
+
+            // Edge case: Same number (positive and negative)
+            Arguments.of(-42, -42, Boolean.FALSE), Arguments.of(42, 42, Boolean.FALSE));
     }
 }