SMBUtil.writeInt4(0, buffer, 12); // WriteChannelInfoOffset/Length

            int bytesRead = response.readBytesWireFormat(buffer, 0);

            assertEquals(16, bytesRead);
            assertEquals(-1, response.getCount()); // -1 as signed int represents max unsigned value
            assertEquals(-2, response.getRemaining());
        }

#else
#define TF_CAPI_EXPORT __attribute__((visibility("default")))
#endif  // TF_CAPI_WEAK
#endif  // _WIN32
#endif  // SWIG

// TF_Bool is the C API typedef for unsigned char, while TF_BOOL is
// the datatype for boolean tensors.
#ifndef TF_Bool
#define TF_Bool unsigned char
#endif  // TF_Bool

// Macro used to calculate struct size for maintaining ABI stability across
// different struct implementations.
#ifndef TF_OFFSET_OF_END

		}

		// Verify response the V2 signed HTTP request.
		// initialize HTTP NewRecorder, this records any mutations to response writer inside the handler.
		recV2 := httptest.NewRecorder()
		// construct HTTP request for PUT bucket policy endpoint.

		// verify response for V2 signed HTTP request.

     */
    public static final String CONTEXT_NAME = "DH2Q";

    private static final byte[] CONTEXT_NAME_BYTES = CONTEXT_NAME.getBytes();

    private long timeout100Ns; // timeout in 100-nanosecond intervals (wire format, unsigned 32-bit)
    private int flags;

    /**
     * Create a new durable handle V2 response
     */
    public DurableHandleV2Response() {
        // Will be populated during decode
    }

    @Override

    }

    @Test
    @DisplayName("writeUShort handles negative values as unsigned")
    void testWriteUShortNegative() {
        byte[] dest = new byte[2];
        NtlmMessage.writeUShort(dest, 0, -2);
        assertArrayEquals(new byte[] { -2, -1 }, dest, "Negative short should be encoded unsigned");
    }

    @Test
    @DisplayName("writeSecurityBuffer writes zero length buffer unchanged")

        assertEquals(SMB_COM_CLOSE, close.command, "command should be SMB_COM_CLOSE after construction");
    }

    /**
     * Verify that writeParameterWordsWireFormat writes the file id and the
     * unsigned time correctly.  The last write time is zero which should be
     * encoded as four 0xFF bytes by {@code writeUTime}.
     */
    @ParameterizedTest(name = "fid={0}, lastWriteTime={1}")
    @MethodSource("validParams")

// POSIX specifies a sum of the unsigned byte values, but the Sun tar used
// signed byte values.
// We compute and return both.
func (b *block) computeChecksum() (unsigned, signed int64) {
	for i, c := range b {
		if 148 <= i && i < 156 {
			c = ' ' // Treat the checksum field itself as all spaces.
		}
		unsigned += int64(c)
		signed += int64(int8(c))
	}
	return unsigned, signed
}

        buffer[bufferIndex + 35] = (byte) 0x80; // 128 as unsigned
        buffer[bufferIndex + 36] = (byte) 0xFF;

        int bytesRead = response.readParameterWordsWireFormat(buffer, bufferIndex);

        assertEquals(37, bytesRead);

        // Verify setupCount treats byte as unsigned

		}
	}

	// Test for Anonymous/unsigned http request.
	// Bucket policy related functions doesn't support anonymous requests, setting policies shouldn't make a difference.
	bucketPolicyStr := fmt.Sprintf(bucketPolicyTemplate, bucketName, bucketName)
	// create unsigned HTTP request for PutBucketPolicyHandler.

	}

	// Since the list of signed headers value contained `expect`, the default value of `100-continue` will be added to extracted signed headers.
	if extractedExpect != expectedExpect {
		t.Errorf("expect header incorrect value: expected `%s`, got `%s`", expectedExpect, extractedExpect)
	}

	// case where the headers don't contain the one of the signed header in the signed headers list.