}
        impersonationLevel = 0x02; // As seen on NT :~)
        securityFlags = (byte) 0x03; // SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY
    }

    @Override
    int writeParameterWordsWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        dst[dstIndex] = (byte) 0x00;
        dstIndex++;
        // name length without counting null termination

    @Nested
    @DisplayName("Encoding Tests")
    class EncodingTests {

        @Test
        @DisplayName("encode should validate size calculation")
        void testEncodeValidSize() {
            byte[] buffer = new byte[1024];
            testRequest.setTestSize(64);
            testRequest.setTestLength(64);

            int result = testRequest.encode(buffer, 0);

            assertEquals(64, result);
        }

    // SMB uses little-endian byte order
    private static void writeLong(byte[] buf, int offset, long val) {
        for (int i = 0; i < 8; i++) {
            buf[offset + i] = (byte) ((val >>> (8 * i)) & 0xFF);
        }
    }

    private static void writeShort(byte[] buf, int offset, int val) {
        buf[offset] = (byte) (val & 0xFF);
        buf[offset + 1] = (byte) ((val >>> 8) & 0xFF);
    }

    @Test

	}
}

func TestTargetDUnmarshalJSON(t *testing.T) {
	testCases := []struct {
		data             []byte
		expectedTargetID *TargetID
		expectErr        bool
	}{
		{[]byte(`""`), nil, true},
		{[]byte(`"httpclient+2e33cdee-fbec-4bdd-917e-7d8e3c5a2531:localhost:55638"`), nil, true},
		{[]byte(`":"`), &TargetID{}, false},
		{[]byte(`"1:webhook"`), &TargetID{"1", "webhook"}, false},
	}

	for i, testCase := range testCases {

	}
}

func TestTargetDUnmarshalJSON(t *testing.T) {
	testCases := []struct {
		data             []byte
		expectedTargetID *TargetID
		expectErr        bool
	}{
		{[]byte(`""`), nil, true},
		{[]byte(`"httpclient+2e33cdee-fbec-4bdd-917e-7d8e3c5a2531:localhost:55638"`), nil, true},
		{[]byte(`":"`), &TargetID{}, false},
		{[]byte(`"1:webhook"`), &TargetID{"1", "webhook"}, false},
	}

	for i, testCase := range testCases {

    }

    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override

     */
    public DurableHandleV2Response() {
        // Will be populated during decode
    }

    @Override
    public byte[] getName() {
        return CONTEXT_NAME_BYTES;
    }

    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {
        if (len != 8) {
            throw new SMBProtocolDecodingException("Invalid durable handle V2 response length: " + len);

	err = obj.MakeBucket(ctx, bucket, MakeBucketOptions{})
	if err != nil {
		t.Fatal(err)
	}

	// Put an initial object so it exists
	_, err = obj.PutObject(ctx, bucket, object,
		mustGetPutObjReader(t, bytes.NewReader([]byte("initial-value")),
			int64(len("initial-value")), "", ""), ObjectOptions{})
	if err != nil {
		t.Fatal(err)
	}

	// Get object info to capture the ETag

        assertEquals(255, ndrSmall.value, "Negative value should be masked to its unsigned byte equivalent.");
    }

    @Test
    void testConstructor_overflowValue() {
        // Test with a value exceeding byte range, expecting it to be masked
        NdrSmall ndrSmall = new NdrSmall(256); // 256 & 0xFF = 0
        assertEquals(0, ndrSmall.value, "Value exceeding byte range should be masked.");

        ndrSmall = new NdrSmall(511); // 511 & 0xFF = 255

    /**
     * Constructs a KerberosTicket from token bytes.
     *
     * @param token the ticket token bytes
     * @param apOptions AP options flags
     * @param keys array of Kerberos keys for decryption
     * @throws PACDecodingException if ticket decoding fails
     */
    public KerberosTicket(byte[] token, byte apOptions, KerberosKey[] keys) throws PACDecodingException {
        if (token.length <= 0) {