byte[] buffer = new byte[EXPECTED_SIZE * 3];

            // When
            int offset1 = chunk1.encode(buffer, 0);
            int offset2 = chunk2.encode(buffer, offset1);
            int offset3 = chunk3.encode(buffer, offset1 + offset2);

            // Then
            assertEquals(EXPECTED_SIZE, offset1);
            assertEquals(EXPECTED_SIZE, offset2);

        decoded.decode(buf);
        assertEquals(val, decoded.value, "Decoded value should match encoded value for " + Long.toHexString(val));
    }

    /**
     * Ensure encode throws NPE when passed a null buffer.
     */
    @Test
    @DisplayName("Encode with null buffer throws NullPointerException")
    public void testEncodeNullBuffer() throws NdrException {
        NdrHyper hyper = new NdrHyper(5L);

                }
            }
        }
        return hash;
    }

    /**
     * Encodes a similar document hash using GZIP compression and Base64 encoding.
     * This reduces storage space for hash values while maintaining uniqueness.
     *
     * @param hash the hash string to encode
     * @return the encoded hash string with prefix, or the original hash if encoding fails
     */

import okio.ByteString.Companion.encode

/** Factory for HTTP authorization credentials. */
object Credentials {
  /** Returns an auth credential for the Basic scheme. */
  @JvmStatic @JvmOverloads
  fun basic(
    username: String,
    password: String,
    charset: Charset = ISO_8859_1,
  ): String {
    val usernameAndPassword = "$username:$password"
    val encoded = usernameAndPassword.encode(charset).base64()

    /**
     * Returns a new instance configured with a default encode set for the ASCII range. The specific
     * rules vary per-component: for example, '?' may be identity-encoded in a fragment, but must be
     * percent-encoded in a path.
     *
     * See https://url.spec.whatwg.org/#percent-encoded-bytes
     */
    fun newInstance(): UrlComponentEncodingTester =
      UrlComponentEncodingTester()

  val tag: Long,
  /** Encode and decode the value once tags are handled. */
  private val codec: Codec<T>,
  /** True if the default value should be used if this value is absent during decoding. */
  val isOptional: Boolean = false,
  /** The value to return if this value is absent. Undefined unless this is optional. */
  val defaultValue: T? = null,

        byte[] encoded = encodeUnicode(msg);
        assertEquals(4, encoded.length, "Encoded Unicode string should be 4 bytes");

        // Verify little-endian encoding
        assertEquals((byte) 0xA1, encoded[0], "First byte of first character");
        assertEquals((byte) 0x00, encoded[1], "Second byte of first character");
        assertEquals((byte) 0xA2, encoded[2], "First byte of second character");

        assertEquals(newFlags, leaseContext.getLeaseFlags());
    }

    @Test
    @DisplayName("Should encode context correctly")
    void testEncode() {
        byte[] buffer = new byte[leaseContext.size()];
        int encoded = leaseContext.encode(buffer, 0);

        assertEquals(leaseContext.size(), encoded);

        // Verify context header structure according to MS-SMB2

        byte[] buffer1 = new byte[request.size()];
        byte[] buffer2 = new byte[request.size()];

        request.encode(buffer1, 0);
        request.encode(buffer2, 0);

        assertArrayEquals(buffer1, buffer2);
    }

    @Test
    @DisplayName("Test encode with insufficient buffer throws exception")
    void testEncodeWithInsufficientBuffer() {
        ValidateNegotiateInfoRequest request =

            }, errorHook);
        }
    }

    /**
     * Encodes permission strings into an array.
     *
     * @param permissionsText the permissions text (newline-separated)
     * @return encoded permission array
     */
    protected static String[] encodePermissions(final String permissionsText) {