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());

    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));
  }

        // 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);
    }

    @Test

        final byte[] decoded = Base64Util.decode(encoded);
        assertEquals("Decoded should have same length", 2, decoded.length);
        assertEquals("First byte should match", twoBytes[0], decoded[0]);
        assertEquals("Second byte should match", twoBytes[1], decoded[1]);
    }

    /**
     * Test backward compatibility with standard Base64
     *
     * @throws Exception
     */

 *
 *  * In queries, ' ' is encoded to '+' and '+' is encoded to "%2B".
 *
 *  * Characters in `encodeSet` are percent-encoded.
 *
 *  * Control characters and non-ASCII characters are percent-encoded.
 *
 *  * All other characters are copied without transformation.
 *
 * @param alreadyEncoded true to leave '%' as-is; false to convert it to '%25'.

        return len;
    }

    /**
     * Decodes a string from OEM-encoded bytes.
     *
     * @param src the byte array containing the encoded string
     * @param srcIndex the starting offset in the byte array
     * @param len the number of bytes to decode
     * @param config the configuration providing the OEM encoding
     * @return decoded string
     */

        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[] 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

            int encoded = context.encode(largeBuffer, 0);
            assertEquals(2 + 200, encoded); // 2 for count + 100*2 for ciphers

            EncryptionNegotiateContext decoded = new EncryptionNegotiateContext();
            try {
                int decodedSize = decoded.decode(largeBuffer, 0, encoded);
                assertEquals(encoded, decodedSize);

            encodeSet = FORM_ENCODE_SET,
            // Plus is encoded as `%2B`, space is encoded as plus.
            plusIsSpace = false,
            charset = charset,
          )
        values +=
          value.canonicalizeWithCharset(
            encodeSet = FORM_ENCODE_SET,
            // Plus is encoded as `%2B`, space is encoded as plus.
            plusIsSpace = false,
            charset = charset,