*/
    public void testDecode_Null() throws Exception {
        final byte[] result = Base64Util.decode(null);
        assertNull("Null should return null", result);
    }

    /**
     * Test encode/decode round trip with various data
     *
     * @throws Exception
     */
    public void testEncodeDecode_RoundTrip() throws Exception {
        // Test with ASCII text
        final String text = "Hello, World!";

        // padding is alwas binary 1 followed by binary 0s
        final byte[] tail = new byte[padLen + 8];
        tail[0] = (byte) 0x80;

        // append length before final transform:
        // save number of bits, casting the long to an array of 8 bytes
        // save low-order byte first.
        for (int i = 0; i < 8; i++) {
            tail[padLen + i] = (byte) (count * 8 >>> 8 * i);
        }

 */
@ExtendWith(MockitoExtension.class)
public class NdrHyperTest {

    /**
     * Tests a simple round‑trip encode → decode retains the original value.
     */
    @Test
    @DisplayName("Basic round‑trip for a fixed value")
    public void testEncodeRoundTrip() throws NdrException {
        final long original = 0x1122334455667788L;
        NdrHyper hyper = new NdrHyper(original);

            assertEquals(largeValue, ndrShort.value);
        }
    }

    @Nested
    @DisplayName("Round-trip Tests")
    class RoundTripTests {

        @Test
        @DisplayName("Should handle encode-decode round-trip correctly")
        void testEncodeDecodeRoundTrip() throws NdrException {
            // Given: Original value that fits in byte range

        assertTrue(str.contains("1024"));
    }

    /**
     * Test FileEndOfFileInformation encode/decode round trip
     */
    @Test
    @DisplayName("Test FileEndOfFileInformation encode/decode round trip")
    void testFileEndOfFileInformationEncodeDecodeRoundTrip() throws SMBProtocolDecodingException {
        long originalValue = 0x123456789ABCDEFL;

        int bytesRead = info.decode(buffer, startIndex, buffer.length - startIndex);

        assertEquals(20 + nameBytes.length, bytesRead);
    }

    @Test
    @DisplayName("Test encode and decode round trip")
    void testEncodeDecodeRoundTrip() throws SMBProtocolDecodingException {
        String fileName = "roundtrip_test.txt";
        boolean replaceIfExists = true;

        AvTimestamp avTimestamp = new AvTimestamp(rawBytes);

        assertEquals(expectedTimestamp, avTimestamp.getTimestamp());
    }

    /**
     * Test round-trip conversion: long -> bytes -> long.
     */
    @Test
    public void testRoundTripConversion() {
        long originalTimestamp = 543210987654321L;
        AvTimestamp avTimestamp = new AvTimestamp(originalTimestamp);

                    Arguments.of(5, 10, 24), Arguments.of(10, 20, 44), Arguments.of(20, 32, 76));
        }
    }

    @Nested
    @DisplayName("Round-trip Tests")
    class RoundTripTests {

        @Test
        @DisplayName("Should encode and decode correctly with single hash algorithm and salt")

     *
     * @return the buffer capacity
     */
    public int getCapacity() {
        return buf.length - start;
    }

    /**
     * Returns the available space at the tail of the buffer.
     *
     * @return the available tail space
     */
    public int getTailSpace() {
        return buf.length - index;
    }

    /**
     * Returns the underlying byte buffer.
     *

            assertEquals(4 + (2 * cipherCount), context.size());
        }
    }

    @Nested
    @DisplayName("Round-trip Tests")
    class RoundTripTests {

        @Test
        @DisplayName("Should encode and decode correctly with single cipher")
        void testRoundTripSingleCipher() throws SMBProtocolDecodingException {