Refactor BCD Conversion docs and add more tests

Author: Hardvan

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

@@ -3,7 +3,7 @@
 /**
  * This class provides methods to convert between BCD (Binary-Coded Decimal) and binary.
  *
- * Binary-Coded Decimal (BCD) is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of binary digits, usually four or eight.
+ * BCD is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of binary digits, usually four or eight.
  *
  * For more information, refer to the
  * <a href="https://en.wikipedia.org/wiki/Binary-coded_decimal">Binary-Coded Decimal</a> Wikipedia page.
@@ -20,8 +20,14 @@
 public final class BcdConversion {
     private BcdConversion() {
     }
+
     /**
      * Converts a BCD (Binary-Coded Decimal) number to binary.
+     * <p>Steps:
+     * <p>1. Extract the last 4 bits (one BCD digit) from the BCD number.
+     * <p>2. Multiply the extracted digit by the corresponding power of 10 and add it to the binary number.
+     * <p>3. Shift the BCD number right by 4 bits to process the next BCD digit.
+     * <p>4. Repeat steps 1-3 until the BCD number is zero.
      *
      * @param bcd The BCD number.
      * @return The corresponding binary number.
@@ -30,16 +36,21 @@ public static int bcdToBinary(int bcd) {
         int binary = 0;
         int multiplier = 1;
         while (bcd > 0) {
-            int digit = bcd & 0xF; // Extract the last 4 bits (one BCD digit)
+            int digit = bcd & 0xF;
             binary += digit * multiplier;
             multiplier *= 10;
-            bcd >>= 4; // Shift right by 4 bits to process the next BCD digit
+            bcd >>= 4;
         }
         return binary;
     }
 
     /**
      * Converts a binary number to BCD (Binary-Coded Decimal).
+     * <p>Steps:
+     * <p>1. Extract the last decimal digit from the binary number.
+     * <p>2. Shift the digit to the correct BCD position and add it to the BCD number.
+     * <p>3. Remove the last decimal digit from the binary number.
+     * <p>4. Repeat steps 1-3 until the binary number is zero.
      *
      * @param binary The binary number.
      * @return The corresponding BCD number.
@@ -48,9 +59,9 @@ public static int binaryToBcd(int binary) {
         int bcd = 0;
         int shift = 0;
         while (binary > 0) {
-            int digit = binary % 10; // Extract the last decimal digit
-            bcd |= (digit << (shift * 4)); // Shift the digit to the correct BCD position
-            binary /= 10; // Remove the last decimal digit
+            int digit = binary % 10;
+            bcd |= (digit << (shift * 4));
+            binary /= 10;
             shift++;
         }
         return bcd;

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

@@ -1,65 +1,85 @@
 package com.thealgorithms.bitmanipulation;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import org.junit.jupiter.api.Test;
 
-/**
- * Unit tests for the BcdConversion class.
- */
 public class BcdConversionTest {
 
-    /**
-     * Test the bcdToBinary method with a BCD number.
-     */
     @Test
     public void testBcdToBinary() {
         int binary = BcdConversion.bcdToBinary(0x1234);
         assertEquals(1234, binary); // BCD 0x1234 should convert to binary 1234
     }
 
-    /**
-     * Test the binaryToBcd method with a binary number.
-     */
     @Test
     public void testBinaryToBcd() {
         int bcd = BcdConversion.binaryToBcd(1234);
         assertEquals(0x1234, bcd); // Binary 1234 should convert to BCD 0x1234
     }
 
-    /**
-     * Test the bcdToBinary method with zero.
-     */
     @Test
     public void testBcdToBinaryZero() {
         int binary = BcdConversion.bcdToBinary(0x0);
         assertEquals(0, binary); // BCD 0x0 should convert to binary 0
     }
 
-    /**
-     * Test the binaryToBcd method with zero.
-     */
     @Test
     public void testBinaryToBcdZero() {
         int bcd = BcdConversion.binaryToBcd(0);
         assertEquals(0x0, bcd); // Binary 0 should convert to BCD 0x0
     }
 
-    /**
-     * Test the bcdToBinary method with a single digit BCD number.
-     */
     @Test
     public void testBcdToBinarySingleDigit() {
         int binary = BcdConversion.bcdToBinary(0x7);
         assertEquals(7, binary); // BCD 0x7 should convert to binary 7
     }
 
-    /**
-     * Test the binaryToBcd method with a single digit binary number.
-     */
     @Test
     public void testBinaryToBcdSingleDigit() {
         int bcd = BcdConversion.binaryToBcd(7);
         assertEquals(0x7, bcd); // Binary 7 should convert to BCD 0x7
     }
+
+    @Test
+    public void testBcdToBinaryMaxValue() {
+        int binary = BcdConversion.bcdToBinary(0x9999);
+        assertEquals(9999, binary); // BCD 0x9999 should convert to binary 9999
+    }
+
+    @Test
+    public void testBinaryToBcdMaxValue() {
+        int bcd = BcdConversion.binaryToBcd(9999);
+        assertEquals(0x9999, bcd); // Binary 9999 should convert to BCD 0x9999
+    }
+
+    @Test
+    public void testBcdToBinaryInvalidHighDigit() {
+        // Testing invalid BCD input where one of the digits is > 9
+        assertThrows(IllegalArgumentException.class, () -> {
+            BcdConversion.bcdToBinary(0x123A); // Invalid BCD, 'A' is not a valid digit
+        });
+    }
+
+    @Test
+    public void testBinaryToBcdInvalidValue() {
+        // Testing conversion for numbers greater than 9999, which cannot be represented in BCD
+        assertThrows(IllegalArgumentException.class, () -> {
+            BcdConversion.binaryToBcd(10000); // 10000 is too large for BCD representation
+        });
+    }
+
+    @Test
+    public void testBcdToBinaryLeadingZeroes() {
+        int binary = BcdConversion.bcdToBinary(0x0234);
+        assertEquals(234, binary); // BCD 0x0234 should convert to binary 234, ignoring leading zero
+    }
+
+    @Test
+    public void testBinaryToBcdLeadingZeroes() {
+        int bcd = BcdConversion.binaryToBcd(234);
+        assertEquals(0x0234, bcd); // Binary 234 should convert to BCD 0x0234
+    }
 }