Resolve SpotBugs

Author: Microindole

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

@@ -136,15 +136,10 @@ public static BWTResult transform(String text) {
 
         // Sort rotations lexicographically
         Arrays.sort(rotations);
-
-        // Extract the last column and find the original string's position
+        int originalIndex = Arrays.binarySearch(rotations, text);
         StringBuilder lastColumn = new StringBuilder(n);
-        int originalIndex = -1;
         for (int i = 0; i < n; i++) {
             lastColumn.append(rotations[i].charAt(n - 1));
-            if (rotations[i].equals(text)) {
-                originalIndex = i;
-            }
         }
 
         return new BWTResult(lastColumn.toString(), originalIndex);

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

@@ -1,6 +1,7 @@
 package com.thealgorithms.compression;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -128,15 +129,14 @@ public static List<Integer> transform(String text, String initialAlphabet) {
      * to the one used in the forward transform, including character order, or the
      * output will be incorrect.</p>
      *
-     * @param indices the list of integers from the forward transform; if empty or {@code null},
-     *                returns an empty string
+     * @param indices The list of integers from the forward transform.
      * @param initialAlphabet the exact same initial alphabet string used for the forward transform;
      *                        if {@code null} or empty, returns an empty string
      * @return the original, untransformed string
      * @throws IllegalArgumentException if any index in {@code indices} is negative or
      *                                  exceeds the current alphabet size
      */
-    public static String inverseTransform(List<Integer> indices, String initialAlphabet) {
+    public static String inverseTransform(Collection<Integer> indices, String initialAlphabet) {
         if (indices == null || indices.isEmpty() || initialAlphabet == null || initialAlphabet.isEmpty()) {
             return "";
         }

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

@@ -1,6 +1,9 @@
 package com.thealgorithms.compression;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import org.junit.jupiter.api.Test;
 
@@ -71,4 +74,48 @@ public void testSingleCharacter() {
         String reconstructed = BurrowsWheelerTransform.inverseTransform(actualTransform.transformed, actualTransform.originalIndex);
         assertEquals(original, reconstructed);
     }
+
+    @Test
+    public void testTransformNull() {
+        assertEquals(new BurrowsWheelerTransform.BWTResult("", -1), BurrowsWheelerTransform.transform(null));
+    }
+
+    @Test
+    public void testInverseTransformNullString() {
+        // bwtString == null
+        assertEquals("", BurrowsWheelerTransform.inverseTransform(null, 1));
+    }
+
+    @Test
+    public void testInverseTransformIndexOutOfBounds() {
+        String bwt = "annb$aa";
+        int n = bwt.length(); // n = 7
+
+        // originalIndex >= n
+        assertThrows(IllegalArgumentException.class, () -> BurrowsWheelerTransform.inverseTransform(bwt, n));
+        assertThrows(IllegalArgumentException.class, () -> BurrowsWheelerTransform.inverseTransform(bwt, 8));
+
+        // originalIndex < 0
+        assertThrows(IllegalArgumentException.class, () -> BurrowsWheelerTransform.inverseTransform(bwt, -2));
+    }
+
+    @Test
+    public void testBWTResultHelpers() {
+        BurrowsWheelerTransform.BWTResult res1 = new BurrowsWheelerTransform.BWTResult("annb$aa", 4);
+        BurrowsWheelerTransform.BWTResult res2 = new BurrowsWheelerTransform.BWTResult("annb$aa", 4);
+        BurrowsWheelerTransform.BWTResult res3 = new BurrowsWheelerTransform.BWTResult("other", 4);
+        BurrowsWheelerTransform.BWTResult res4 = new BurrowsWheelerTransform.BWTResult("annb$aa", 1);
+
+        assertEquals(res1, res2);
+        assertNotEquals(res1, null); // obj == null
+        assertNotEquals(res1, new Object()); // different class
+        assertNotEquals(res1, res3); // different transformed
+        assertNotEquals(res1, res4); // different originalIndex
+
+        assertEquals(res1.hashCode(), res2.hashCode());
+        assertNotEquals(res1.hashCode(), res3.hashCode());
+
+        assertTrue(res1.toString().contains("annb$aa"));
+        assertTrue(res1.toString().contains("originalIndex=4"));
+    }
 }

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

@@ -67,6 +67,26 @@ public void testSymbolNotInAlphabet() {
     @Test
     public void testIndexOutOfBounds() {
         // Index 5 is out of bounds for alphabet "abc"
+        // 1. test index >= alphabet.size()
         assertThrows(IllegalArgumentException.class, () -> MoveToFront.inverseTransform(List.of(1, 2, 5), "abc"));
+
+        // 2. test index < 0
+        assertThrows(IllegalArgumentException.class, () -> MoveToFront.inverseTransform(List.of(1, -1, 2), "abc"));
+    }
+
+    @Test
+    public void testTransformNull() {
+        List<Integer> expected = List.of();
+        assertEquals(expected, MoveToFront.transform(null, "abc"));
+        assertThrows(IllegalArgumentException.class, () -> MoveToFront.transform("abc", null));
+    }
+
+    @Test
+    public void testInverseTransformNulls() {
+        // 1. test indices == null
+        assertEquals("", MoveToFront.inverseTransform(null, "abc"));
+
+        // 2. test initialAlphabet == null
+        assertEquals("", MoveToFront.inverseTransform(List.of(1, 2), null));
     }
 }