fix: build and lint fix update

Author: NithinU2802

src/main/java/com/thealgorithms/conversions/Base64.java

@@ -1,36 +1,35 @@
 package com.thealgorithms.conversions;
 
-import java.util.List;
-import java.util.ArrayList;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Base64 is a group of binary-to-text encoding schemes that represent binary data
  * in an ASCII string format by translating it into a radix-64 representation.
  * Each base64 digit represents exactly 6 bits of data.
- * 
+ *
  * Base64 encoding is commonly used when there is a need to encode binary data
  * that needs to be stored and transferred over media that are designed to deal
  * with textual data.
- * 
+ *
  * Wikipedia Reference: https://en.wikipedia.org/wiki/Base64
  * Author: Nithin U.
  * Github: https://github.com/NithinU2802
  */
 
 public final class Base64 {
-    
+
     // Base64 character set
     private static final String BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     private static final char PADDING_CHAR = '=';
-    
+
     private Base64() {
-        
     }
 
     /**
      * Encodes the given byte array to a Base64 encoded string.
-     * 
+     *
      * @param input the byte array to encode
      * @return the Base64 encoded string
      * @throws IllegalArgumentException if input is null
@@ -39,52 +38,52 @@ public static String encode(byte[] input) {
         if (input == null) {
             throw new IllegalArgumentException("Input cannot be null");
         }
-        
+
         if (input.length == 0) {
             return "";
         }
-        
+
         StringBuilder result = new StringBuilder();
         int padding = 0;
-        
+
         // Process input in groups of 3 bytes
         for (int i = 0; i < input.length; i += 3) {
             // Get up to 3 bytes
             int byte1 = input[i] & 0xFF;
             int byte2 = (i + 1 < input.length) ? (input[i + 1] & 0xFF) : 0;
             int byte3 = (i + 2 < input.length) ? (input[i + 2] & 0xFF) : 0;
-            
+
             // Calculate padding needed
             if (i + 1 >= input.length) {
                 padding = 2;
             } else if (i + 2 >= input.length) {
                 padding = 1;
             }
-            
+
             // Combine 3 bytes into a 24-bit number
             int combined = (byte1 << 16) | (byte2 << 8) | byte3;
-            
+
             // Extract four 6-bit groups
             result.append(BASE64_CHARS.charAt((combined >> 18) & 0x3F));
             result.append(BASE64_CHARS.charAt((combined >> 12) & 0x3F));
             result.append(BASE64_CHARS.charAt((combined >> 6) & 0x3F));
             result.append(BASE64_CHARS.charAt(combined & 0x3F));
         }
-        
+
         // Replace padding characters
         if (padding > 0) {
             result.setLength(result.length() - padding);
             for (int i = 0; i < padding; i++) {
                 result.append(PADDING_CHAR);
             }
         }
-        
+
         return result.toString();
     }
-    
+
     /**
      * Encodes the given string to a Base64 encoded string using UTF-8 encoding.
-     * 
+     *
      * @param input the string to encode
      * @return the Base64 encoded string
      * @throws IllegalArgumentException if input is null
@@ -93,13 +92,13 @@ public static String encode(String input) {
         if (input == null) {
             throw new IllegalArgumentException("Input cannot be null");
         }
-        
+
         return encode(input.getBytes(StandardCharsets.UTF_8));
     }
-    
+
     /**
      * Decodes the given Base64 encoded string to a byte array.
-     * 
+     *
      * @param input the Base64 encoded string to decode
      * @return the decoded byte array
      * @throws IllegalArgumentException if input is null or contains invalid Base64 characters
@@ -108,33 +107,33 @@ public static byte[] decode(String input) {
         if (input == null) {
             throw new IllegalArgumentException("Input cannot be null");
         }
-        
+
         if (input.isEmpty()) {
             return new byte[0];
         }
-        
+
         // Remove padding for processing
         String cleanInput = input.replace("=", "");
         int padding = input.length() - cleanInput.length();
-        
+
         // Validate input length
         if ((cleanInput.length() % 4) + padding > 4) {
             throw new IllegalArgumentException("Invalid Base64 input length");
         }
-        
+
         List<Byte> result = new ArrayList<>();
-        
+
         // Process input in groups of 4 characters
         for (int i = 0; i < cleanInput.length(); i += 4) {
             // Get up to 4 characters
             int char1 = getBase64Value(cleanInput.charAt(i));
             int char2 = (i + 1 < cleanInput.length()) ? getBase64Value(cleanInput.charAt(i + 1)) : 0;
             int char3 = (i + 2 < cleanInput.length()) ? getBase64Value(cleanInput.charAt(i + 2)) : 0;
             int char4 = (i + 3 < cleanInput.length()) ? getBase64Value(cleanInput.charAt(i + 3)) : 0;
-            
+
             // Combine four 6-bit groups into a 24-bit number
             int combined = (char1 << 18) | (char2 << 12) | (char3 << 6) | char4;
-            
+
             // Extract three 8-bit bytes
             result.add((byte) ((combined >> 16) & 0xFF));
             if (i + 2 < cleanInput.length() || (i + 2 == cleanInput.length() && padding < 2)) {
@@ -144,19 +143,19 @@ public static byte[] decode(String input) {
                 result.add((byte) (combined & 0xFF));
             }
         }
-        
+
         // Convert List<Byte> to byte[]
         byte[] resultArray = new byte[result.size()];
         for (int i = 0; i < result.size(); i++) {
             resultArray[i] = result.get(i);
         }
-        
+
         return resultArray;
     }
-    
+
     /**
      * Decodes the given Base64 encoded string to a string using UTF-8 encoding.
-     * 
+     *
      * @param input the Base64 encoded string to decode
      * @return the decoded string
      * @throws IllegalArgumentException if input is null or contains invalid Base64 characters
@@ -165,14 +164,14 @@ public static String decodeToString(String input) {
         if (input == null) {
             throw new IllegalArgumentException("Input cannot be null");
         }
-        
+
         byte[] decodedBytes = decode(input);
         return new String(decodedBytes, StandardCharsets.UTF_8);
     }
-    
+
     /**
      * Gets the numeric value of a Base64 character.
-     * 
+     *
      * @param c the Base64 character
      * @return the numeric value (0-63)
      * @throws IllegalArgumentException if character is not a valid Base64 character

src/test/java/com/thealgorithms/conversions/Base64Test.java

@@ -9,7 +9,7 @@
 
 /**
  * Test cases for Base64 encoding and decoding.
- * 
+ *
  * Author: Nithin U.
  * Github: https://github.com/NithinU2802
  */
@@ -26,37 +26,15 @@ void testBase64Alphabet() {
     }
 
     @ParameterizedTest
-    @CsvSource({
-        "'', ''",
-        "A, QQ==",
-        "AB, QUI=",
-        "ABC, QUJD",
-        "ABCD, QUJDRA==",
-        "Hello, SGVsbG8=",
-        "'Hello World', SGVsbG8gV29ybGQ=",
-        "'Hello, World!', 'SGVsbG8sIFdvcmxkIQ=='",
-        "'The quick brown fox jumps over the lazy dog', 'VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw=='",
-        "123456789, MTIzNDU2Nzg5",
-        "'Base64 encoding test', 'QmFzZTY0IGVuY29kaW5nIHRlc3Q='"
-    })
+    @CsvSource({"'', ''", "A, QQ==", "AB, QUI=", "ABC, QUJD", "ABCD, QUJDRA==", "Hello, SGVsbG8=", "'Hello World', SGVsbG8gV29ybGQ=", "'Hello, World!', 'SGVsbG8sIFdvcmxkIQ=='", "'The quick brown fox jumps over the lazy dog', 'VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw=='",
+        "123456789, MTIzNDU2Nzg5", "'Base64 encoding test', 'QmFzZTY0IGVuY29kaW5nIHRlc3Q='"})
     void testStringEncoding(String input, String expected) {
         assertEquals(expected, Base64.encode(input));
     }
 
     @ParameterizedTest
-    @CsvSource({
-        "'', ''",
-        "QQ==, A",
-        "QUI=, AB", 
-        "QUJD, ABC",
-        "QUJDRA==, ABCD",
-        "SGVsbG8=, Hello",
-        "'SGVsbG8gV29ybGQ=', 'Hello World'",
-        "'SGVsbG8sIFdvcmxkIQ==', 'Hello, World!'",
-        "'VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw==', 'The quick brown fox jumps over the lazy dog'",
-        "MTIzNDU2Nzg5, 123456789",
-        "'QmFzZTY0IGVuY29kaW5nIHRlc3Q=', 'Base64 encoding test'"
-    })
+    @CsvSource({"'', ''", "QQ==, A", "QUI=, AB", "QUJD, ABC", "QUJDRA==, ABCD", "SGVsbG8=, Hello", "'SGVsbG8gV29ybGQ=', 'Hello World'", "'SGVsbG8sIFdvcmxkIQ==', 'Hello, World!'", "'VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw==', 'The quick brown fox jumps over the lazy dog'",
+        "MTIzNDU2Nzg5, 123456789", "'QmFzZTY0IGVuY29kaW5nIHRlc3Q=', 'Base64 encoding test'"})
     void testStringDecoding(String input, String expected) {
         assertEquals(expected, Base64.decodeToString(input));
     }
@@ -77,19 +55,10 @@ void testByteArrayDecoding() {
 
     @Test
     void testRoundTripEncoding() {
-        String[] testStrings = {
-            "",
-            "A",
-            "AB", 
-            "ABC",
-            "Hello, World!",
-            "The quick brown fox jumps over the lazy dog",
-            "1234567890",
-            "Special chars: !@#$%^&*()_+-=[]{}|;:,.<>?",
+        String[] testStrings = {"", "A", "AB", "ABC", "Hello, World!", "The quick brown fox jumps over the lazy dog", "1234567890", "Special chars: !@#$%^&*()_+-=[]{}|;:,.<>?",
             "Unicode: வணக்கம்", // Tamil for "Hello"
-            "Multi-line\nstring\rwith\tdifferent\nwhitespace"
-        };
-
+            "Multi-line\nstring\rwith\tdifferent\nwhitespace"};
+        
         for (String original : testStrings) {
             String encoded = Base64.encode(original);
             String decoded = Base64.decodeToString(encoded);