assertThat(encoding.encode(decoded.getBytes(UTF_8), offset, len)).isEqualTo(encoded);
  }

  private static void testDecodes(BaseEncoding encoding, String encoded, String decoded) {
    assertThat(encoding.canDecode(encoded)).isTrue();
    assertThat(encoding.decode(encoded)).isEqualTo(decoded.getBytes(UTF_8));
  }

        buf.reset();
        NdrHyper decoded = new NdrHyper(0);
        decoded.decode(buf);
        assertEquals(original, decoded.value, "Decoded value should match encoded value");
    }

    /**
     * Parameterised test for a selection of edge and typical values.
     */
    @ParameterizedTest(name = "Encode and decode {0}")
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE })

            int encoded = originalContext.encode(buffer, 0);
            assertEquals(2 + (2 * maxCiphers), encoded);

            EncryptionNegotiateContext decodedContext = new EncryptionNegotiateContext();
            int decoded = decodedContext.decode(buffer, 0, encoded);

            assertEquals(encoded, decoded);
            assertArrayEquals(ciphers, decodedContext.getCiphers());

        Encdec.enc_uint64le(currentDate.getTime(), buffer, 0);
        long decoded = Encdec.dec_uint64le(buffer, 0);

        // Then
        assertEquals(currentDate.getTime(), decoded, "Encoded and decoded time should match");
    }

    @Test
    @DisplayName("Should encode and decode UUIDs")
    void testUUIDOperations() {
        // Given

        dst[di] = (byte) (i >> 24 & 0xFF);
        return 4;
    }

    /*
     * Decode integers
     */

    /**
     * Decodes a 16-bit unsigned integer from big-endian byte order.
     *
     * @param src the source byte array
     * @param si the starting index in the source array
     * @return the decoded short value
     */
    public static short dec_uint16be(final byte[] src, final int si) {

        // Decode
        FileRenameInformation2 decoded = new FileRenameInformation2();
        int bytesRead = decoded.decode(buffer, 0, bytesWritten);

        // Verify round trip
        assertEquals(bytesWritten, bytesRead);
        assertEquals(original.size(), decoded.size());
        assertEquals(original.getFileInformationLevel(), decoded.getFileInformationLevel());
    }

    @Test

        // Decode from buffer
        NdrBuffer decodeBuffer = new NdrBuffer(buffer, 0);
        lsarpc.LsarTranslatedName decodedName = new lsarpc.LsarTranslatedName();
        decodedName.decode(decodeBuffer);

        // Verify the decoded data matches
        assertEquals(translatedName.sid_type, decodedName.sid_type);

    assertThat(encoding.encode(decoded.getBytes(UTF_8), offset, len)).isEqualTo(encoded);
  }

  private static void testDecodes(BaseEncoding encoding, String encoded, String decoded) {
    assertThat(encoding.canDecode(encoded)).isTrue();
    assertThat(encoding.decode(encoded)).isEqualTo(decoded.getBytes(UTF_8));
  }

        assertEquals(40, bytesWritten);

        // Decode to verify encoding
        FileBasicInfo decoded = new FileBasicInfo();
        decoded.decode(buffer, offset, 36);

        assertEquals(TEST_CREATE_TIME, decoded.getCreateTime());
        assertEquals(TEST_LAST_ACCESS_TIME, decoded.getLastAccessTime());
        assertEquals(TEST_LAST_WRITE_TIME, decoded.getLastWriteTime());

        // Test that unicode strings are properly encoded/decoded
        String unicodeString = "日本語テスト";
        String encoded = BaseEncoding.base64().encode(unicodeString.getBytes(StandardCharsets.UTF_8));
        String decoded = new String(BaseEncoding.base64().decode(encoded), StandardCharsets.UTF_8);

        assertEquals(unicodeString, decoded);
    }

    public void test_special_characters_base64_encoding() {