Corrigidos métodos de codificação Hamming e criados testes unitários

Author: tcpassos

src/main/java/core/util/BitUtils.java

@@ -18,15 +18,15 @@ public static int bitSetLength(int bitset) {
     }
 
     /**
-     * Define o valor de um bit especificado como 1
+     * Muda o estado de um bit na posicao especificada
      *
      * @param data Valor original
-     * @param index Index do bit a ser setado
+     * @param index Index do bit a ser alterado
      * @return {@code int}
      */
-    public static int setBit(int data, int index) {
+    public static int toggleBit(int data, int index) {
         if (index < 0 || index > (Integer.SIZE - 1)) throw new IllegalArgumentException();
-        return data | (1 << index);
+        return data ^ (1 << index);
     }
 
 }

src/main/java/errorcorrecting/hamming/HammingUtils.java

@@ -56,27 +56,31 @@ public static int parseAndCorrectCodeword(int codeword) {
         //  3  2  1  0 <= posicao
         switch (hammingCheck) {
             case 0b101: // r1, r4 = m1
-                symbol = BitUtils.setBit(symbol, 3);
+                symbol = BitUtils.toggleBit(symbol, 3);
+                break;
             case 0b111: // r1, r2, r4 = m2
-                symbol = BitUtils.setBit(symbol, 2);
+                symbol = BitUtils.toggleBit(symbol, 2);
+                break;
             case 0b110: // r1, r2 = m3
-                symbol = BitUtils.setBit(symbol, 1);
+                symbol = BitUtils.toggleBit(symbol, 1);
+                break;
             case 0b011: // r2, r4 = m4
-                symbol = BitUtils.setBit(symbol, 0);
+                symbol = BitUtils.toggleBit(symbol, 0);
+                break;
         }
         return symbol;
     }
 
     private static int getFirstBitHamming(int b) {
-        return (b ^ 0b1101) % 2 == 0 ? 0 : 1;
+        return Integer.bitCount(b & 0b1110) % 2 == 0 ? 0 : 1;
     }
 
     private static int getSecondBitHamming(int b) {
-        return (b ^ 0b0111) % 2 == 0 ? 0 : 1;
+        return Integer.bitCount(b & 0b0111) % 2 == 0 ? 0 : 1;
     }
 
     private static int getThirdBitHamming(int b) {
-        return (b ^ 0b1101) % 2 == 0 ? 0 : 1;
+        return Integer.bitCount(b & 0b1101) % 2 == 0 ? 0 : 1;
     }
 
 }

src/test/java/errorcorrectiong/hamming/HammingUtilsTest.java

@@ -0,0 +1,40 @@
+package errorcorrectiong.hamming;
+
+import errorcorrecting.hamming.HammingUtils;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class HammingUtilsTest {
+    
+    @Test
+    void getCodewordTest() {
+        assertEquals(0, HammingUtils.getCodeword(0));
+        assertEquals(41, HammingUtils.getCodeword(1));
+        assertEquals(75, HammingUtils.getCodeword(3));
+        assertEquals(39, HammingUtils.getCodeword(7));
+        assertEquals(127, HammingUtils.getCodeword(15));
+    }
+    
+    @Test
+    void parseCodewordTest() {
+        assertEquals(0, HammingUtils.parseCodeword(0));
+        assertEquals(1, HammingUtils.parseCodeword(41));
+        assertEquals(3, HammingUtils.parseCodeword(75));
+        assertEquals(7, HammingUtils.parseCodeword(39));
+        assertEquals(15, HammingUtils.parseCodeword(127));
+    }
+    
+    @Test
+    void parseAndCorrectCodewordTest() {
+        assertEquals(0, HammingUtils.parseAndCorrectCodeword(0));
+        assertEquals(1, HammingUtils.parseAndCorrectCodeword(41));
+        assertEquals(1, HammingUtils.parseAndCorrectCodeword(43));
+        assertEquals(3, HammingUtils.parseAndCorrectCodeword(75));
+        assertEquals(3, HammingUtils.parseAndCorrectCodeword(67));
+        assertEquals(7, HammingUtils.parseAndCorrectCodeword(39));
+        assertEquals(7, HammingUtils.parseAndCorrectCodeword(7));
+        assertEquals(15, HammingUtils.parseAndCorrectCodeword(127));
+        assertEquals(15, HammingUtils.parseAndCorrectCodeword(119));
+    }
+    
+}