dstOut.enc_ndr_long(1); // Non-null pointer for totalentries
        totalentries.encode(dstOut); // Encode the totalentries

        dstOut.enc_ndr_long(0); // Simulate retval

        // Use the encoded data for decoding
        NdrBuffer srcOut = new NdrBuffer(encodeBufferOut, 0);
        decodedEnumEx.decode_out(srcOut);

        assertEquals(0, decodedEnumEx.retval);
        assertEquals(info.level, decodedEnumEx.info.level);

        byte[] dest = new byte[5];

        int encodedLen = encodable.encode(dest, 0);

        // Verify encoded length
        assertEquals(3, encodedLen, "Encoded length should be equal to the specified length");

        // Verify content
        assertArrayEquals(new byte[] { 0x02, 0x03, 0x04, 0x00, 0x00 }, dest, "Encoded bytes should match the expected subset");
    }

    @Test

            byte[] largeBuffer = new byte[4096];
            int encoded = originalContext.encode(largeBuffer, 0);
            assertEquals(4 + (2 * maxAlgos) + salt.length, encoded);

            PreauthIntegrityNegotiateContext decodedContext = new PreauthIntegrityNegotiateContext();
            int decoded = decodedContext.decode(largeBuffer, 0, encoded);

            assertEquals(encoded, decoded);

            return parseGeneralizedTime(string)
          }

          override fun encode(
            writer: DerWriter,
            value: Long,
          ) {
            val string = formatGeneralizedTime(value)
            return writer.writeUtf8(string)
          }
        },
    )

  /** Decodes any value without interpretation as [AnyValue]. */
  val ANY_VALUE =
    object : DerAdapter<AnyValue> {

        // Encode
        byte[] buffer = new byte[8];
        int encoded = original.encode(buffer, 0);
        assertEquals(8, encoded);

        // Decode
        FileEndOfFileInformation decoded = new FileEndOfFileInformation();
        int decodedBytes = decoded.decode(buffer, 0, 8);
        assertEquals(8, decodedBytes);

            // Encode all contexts
            byte[] buffer = new byte[512];
            int offset = 0;
            for (CreateContextRequest context : contexts) {
                int encoded = context.encode(buffer, offset);
                assertTrue(encoded > 0);
                offset += encoded;
            }

            // Verify each context was encoded
            assertTrue(offset > 0);

     * @return The string encoded in <code>application/x-www-form-urlencoded</code> format.
     */
    public static String encode(final String s, final String enc) {
        assertArgumentNotEmpty("s", s);
        assertArgumentNotEmpty("enc", enc);

        try {
            return URLEncoder.encode(s, enc);
        } catch (final UnsupportedEncodingException e) {

        byte[] encoded = AvPairs.encode(pairs);

        assertNotNull(encoded, "Encoded data should not be null");
        assertEquals(4, encoded.length, "Should only have EOL (4 bytes)");
        assertEquals(AvPair.MsvAvEOL, SMBUtil.readInt2(encoded, 0), "Should be EOL");
        assertEquals(0, SMBUtil.readInt2(encoded, 2), "EOL length should be 0");
    }

    /**
     * Test round-trip encoding and decoding

        assertTrue(request.size() > 0);

        // Test encoding
        byte[] buffer = new byte[request.size()];
        int encoded = request.encode(buffer, 0);
        assertEquals(request.size(), encoded);
    }

    @Test
    public void testDurableHandleV2Request() {
        DurableHandleV2Request request = new DurableHandleV2Request(120000, false);

    public void test_encode() {
        assertNull(permissionHelper.encode(null));
        assertNull(permissionHelper.encode(""));
        assertNull(permissionHelper.encode(" "));
        assertNull(permissionHelper.encode("{user}"));
        assertNull(permissionHelper.encode("{role}"));
        assertNull(permissionHelper.encode("{group}"));
        assertNull(permissionHelper.encode("(allow)"));