⚡️ Speed up method Crypto.encodeBase64 by 20%

[codeflash-ai]

📄 20% (0.20x) speedup for Crypto.encodeBase64 in client/src/com/aerospike/client/util/Crypto.java

⏱️ Runtime : 213 milliseconds → 178 milliseconds (best of 1 runs)

📝 Explanation and details

Primary benefit — runtime decreased from 213 ms to 178 ms (~19% speedup). The optimized version is faster because it replaces the GNU Base64 implementation with the JDK's java.util.Base64 encoder and caches the encoder instance.

What changed:

• Replaced gnu.crypto.util.Base64.encode(src, 0, src.length, false) with a static java.util.Base64.Encoder and its encodeToString(src) method.
• Added a private static final ENCODER = java.util.Base64.getEncoder() so the encoder instance is looked up once and reused.

Why this speeds things up (developer-focused):

• Faster inner loop: java.util.Base64.encodeToString is implemented and tuned in the JDK with efficient native/low-level routines and fewer intermediate allocations than many third‑party implementations. That reduces CPU work and garbage for both small and large inputs.
• Fewer allocations/copies: encodeToString computes the exact output size and writes directly to the resulting String/char buffer, avoiding extra temporary objects that a third‑party encoder might create (byte->char buffers, builders, or repeated slice copies).
• Reduced per-call overhead: caching the Encoder avoids repeated getEncoder() lookups and potential small allocation/initialization overheads in hot paths where this method is called frequently.
• Better JIT/vectorization opportunity: the builtin encoder is more likely to benefit from JVM intrinsics and JIT optimizations (loop unrolling, vectorized copies), improving throughput on large arrays — which matches the annotated tests that include large inputs.

How this affects workloads:

• Hot paths that call encodeBase64 many times (small or medium buffers) will see lower per-call overhead and less GC pressure.
• Large-buffer encodings (the test with 1,000,000 bytes and the ~300KB tests) also benefit due to the optimized bulk copy/transform in the JDK implementation.
• Unit tests show correctness and expected properties (no line breaks, correct padding, exact decoding with java.util.Base64 decoder), so behavior is preserved for typical and edge-case inputs.

Trade-offs / notes:

• The change moves reliance from a third‑party Base64 to the JDK implementation (usually desirable). No functional regression was observed in tests; the runtime win was the acceptance criterion and is the positive outcome.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 32 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	No coverage data found for encodeBase64

🌀 Click to see Generated Regression Tests

package com.aerospike.client.util;

import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;

import java.util.Random;
import java.util.Base64;

/**
 * Unit tests for com.aerospike.client.util.Crypto.encodeBase64
 */
import com.aerospike.client.util.Crypto;

public class CryptoTest {
    // Instance created per requirement. The method under test is static.
    private Crypto instance;

    @Before
    public void setUp() {
        instance = new Crypto();
    }

    @Test
    public void testTypicalInput_HelloEncodedCorrectly() {
        byte[] input = "hello".getBytes(java.nio.charset.StandardCharsets.UTF_8);
        // Use the instance (even though method is static) to satisfy requirement
        String encoded = instance.encodeBase64(input);
        // Known base64 for "hello"
        assertEquals("aGVsbG8=", encoded);
    }

    @Test
    public void testEmptyInput_ReturnsEmptyString() {
        byte[] empty = new byte[0];
        String encoded = Crypto.encodeBase64(empty);
        assertEquals("", encoded);
    }

    @Test
    public void testNullInput_ThrowsNullPointerException() {
        assertThrows(NullPointerException.class, () -> {
            Crypto.encodeBase64(null);
        });
    }

    @Test
    public void testOneByte_MatchesJavaBase64() {
        byte[] one = new byte[] { (byte) 0xAB };
        String expected = Base64.getEncoder().encodeToString(one);
        String actual = Crypto.encodeBase64(one);
        assertEquals(expected, actual);
    }

    @Test
    public void testTwoBytes_MatchesJavaBase64() {
        byte[] two = new byte[] { (byte) 0x01, (byte) 0xFE };
        String expected = Base64.getEncoder().encodeToString(two);
        String actual = Crypto.encodeBase64(two);
        assertEquals(expected, actual);
    }

    @Test
    public void testAllByteValues_MatchesJavaBase64() {
        // Create array with every possible byte value (0..255)
        byte[] all = new byte[256];
        for (int i = 0; i < 256; i++) {
            all[i] = (byte) i;
        }
        String expected = Base64.getEncoder().encodeToString(all);
        String actual = Crypto.encodeBase64(all);
        assertEquals(expected, actual);
    }

    @Test
    public void testLargeInput_PerformanceAndCorrectness() {
        // Use a deterministic random source so test is repeatable.
        final int size = 1_000_000; // 1 million bytes - large-scale input
        byte[] large = new byte[size];
        Random rnd = new Random(123456);
        rnd.nextBytes(large);

        String encoded = Crypto.encodeBase64(large);

        // Decode using java.util.Base64 to ensure the encoded string is a correct base64 representation
        byte[] decoded = Base64.getDecoder().decode(encoded);
        assertArrayEquals("Decoded bytes should match original large input", large, decoded);

        // Additionally verify the length of the base64 string matches expected formula:
        // base64 length = 4 * ceil(n / 3)
        int expectedLength = 4 * ((size + 2) / 3);
        assertEquals("Base64 string length should match 4 * ceil(n/3)", expectedLength, encoded.length());
    }
}

package com.aerospike.client.util;

import org.junit.Test;
import org.junit.Before;
import static org.junit.Assert.*;
import com.aerospike.client.util.Crypto;

import java.nio.charset.StandardCharsets;
import java.util.Base64;

/**
 * Unit tests for com.aerospike.client.util.Crypto.encodeBase64(byte[]).
 *
 * These tests cover:
 * - Typical inputs (known string encodings)
 * - Edge cases (empty array, null input)
 * - Padding/boundary behavior
 * - Binary inputs compared to java.util.Base64
 * - Large input handling and expected output length (performance/scale check)
 */
public class CryptoTest {
    // Instance created per requirement, though encodeBase64 is static.
    private Crypto instance;

    @Before
    public void setUp() {
        instance = new Crypto();
    }

    @Test
    public void testNullInput_ThrowsNullPointerException() {
        // Passing null should result in a NullPointerException because src.length is accessed.
        assertThrows(NullPointerException.class, () -> Crypto.encodeBase64(null));
    }

    @Test
    public void testEmptyInput_ReturnsEmptyString() {
        byte[] empty = new byte[0];
        String result = Crypto.encodeBase64(empty);
        assertEquals("", result);
    }

    @Test
    public void testSingleByteEncoding_ReturnsExpectedBase64() {
        byte[] src = "f".getBytes(StandardCharsets.UTF_8);
        String result = Crypto.encodeBase64(src);
        assertEquals("Zg==", result);
    }

    @Test
    public void testTwoBytesEncoding_ReturnsExpectedBase64() {
        byte[] src = "fo".getBytes(StandardCharsets.UTF_8);
        String result = Crypto.encodeBase64(src);
        assertEquals("Zm8=", result);
    }

    @Test
    public void testThreeBytesEncoding_ReturnsExpectedBase64() {
        byte[] src = "foo".getBytes(StandardCharsets.UTF_8);
        String result = Crypto.encodeBase64(src);
        assertEquals("Zm9v", result);
    }

    @Test
    public void testPaddingBehavior_SingleAndDoublePaddingPresent() {
        String enc1 = Crypto.encodeBase64("f".getBytes(StandardCharsets.UTF_8));
        String enc2 = Crypto.encodeBase64("fo".getBytes(StandardCharsets.UTF_8));
        // One assertion per test guideline is preferred, but these two very small checks are closely related.
        assertTrue(enc1.endsWith("==") && enc2.endsWith("="));
    }

    @Test
    public void testBinaryInput_EqualsJavaBase64Encoder() {
        byte[] src = new byte[] {0, (byte) 0xFF, (byte) 0x88, 0x01, 0x7F};
        // Compare Crypto.encodeBase64 result to java.util.Base64 (standard encoder) for correctness.
        String expected = Base64.getEncoder().encodeToString(src);
        String actual = Crypto.encodeBase64(src);
        assertEquals(expected, actual);
    }

    @Test
    public void testLargeInput_ReturnsExpectedLength() {
        // Large input to verify handling and output length calculation.
        // Use a size large enough to exercise scaling but reasonable for unit tests.
        int len = 300_000; // ~300 KB
        byte[] large = new byte[len];
        for (int i = 0; i < len; i++) {
            large[i] = (byte) (i & 0xFF);
        }

        String encoded = Crypto.encodeBase64(large);

        // Base64 output length should be: ceil(len/3) * 4 -> ((len + 2) / 3) * 4
        int expectedLength = ((len + 2) / 3) * 4;
        assertEquals(expectedLength, encoded.length());
    }

    @Test
    public void testLargeInput_NoLineBreaks_InOutput() {
        int len = 300_000;
        byte[] large = new byte[len];
        for (int i = 0; i < len; i++) {
            large[i] = (byte) (i & 0xFF);
        }

        String encoded = Crypto.encodeBase64(large);
        // The Crypto.encodeBase64 uses Base64.encode(..., false) so it should not contain newlines.
        assertFalse(encoded.contains("\n"));
        assertFalse(encoded.contains("\r"));
    }
}

To edit these changes git checkout codeflash/optimize-Crypto.encodeBase64-ml2p6fx0 and push.