// Name of the bucket.
	Bucket string

	// Name of the object.
	Name string

	// Date and time when the object was last modified.
	ModTime time.Time

	// Total object size.
	Size int64

	// Actual size is the real size of the object uploaded by client.
	ActualSize *int64

	// IsDir indicates if the object is prefix.
	IsDir bool

	// Hex encoded unique entity tag of the object.
	ETag string

        @ValueSource(ints = { 8, 16, 32, 64, 128, 256 })
        @DisplayName("Should handle various sizes")
        void testVariousSizes(int size) {
            MockCreateContextRequest mock = new MockCreateContextRequest("TEST", size);
            assertEquals(size, mock.size());
            assertEquals(size, mock.encode(new byte[size * 2], 0));
        }
    }

    @Nested
    @DisplayName("Edge Case Tests")

        assertEquals(0, bytesRead);
    }

    @Test
    @DisplayName("Test size calculation with different buffer sizes")
    void testSizeCalculationWithDifferentBufferSizes() {
        // Test with smaller maximum buffer size
        when(mockConfig.getMaximumBufferSize()).thenReturn(8192);
        when(mockConfig.getListSize()).thenReturn(16384);

    @DisplayName("Test getSendBufferSize returns standard size")
    void testGetSendBufferSizeStandard() {
        // Arrange
        int expectedSize = 65536;
        when(negotiationResponse.getSendBufferSize()).thenReturn(expectedSize);

        // Act
        int size = negotiationResponse.getSendBufferSize();

        // Assert
        assertEquals(expectedSize, size);
        verify(negotiationResponse).getSendBufferSize();

		}

		// Manually deserialize the size since AWS specified
		// the chunk size to be of variable width. In particular,
		// a size of 16 is encoded as `10` while a size of 64 KB
		// is `10000`.
		switch {
		case b >= '0' && b <= '9':
			size = size<<4 | int(b-'0')
		case b >= 'a' && b <= 'f':
			size = size<<4 | int(b-('a'-10))
		case b >= 'A' && b <= 'F':
			size = size<<4 | int(b-('A'-10))
		default:

    checkNotNull(other);
    int size = size();

    if (other.length < size) {
      Object[] internal = internalArray();
      if (internal != null) {
        return Platform.copy(internal, internalArrayStart(), internalArrayEnd(), other);
      }
      other = ObjectArrays.newArray(other, size);
    } else if (other.length > size) {
      other[size] = null;
    }
    copyIntoArray(other, 0);

		}
		sizeS := sizeSummary{}
		for _, tier := range globalTierConfigMgr.ListTiers() {
			if sizeS.tiers == nil {
				sizeS.tiers = make(map[string]tierStats)
			}
			sizeS.tiers[tier.Name] = tierStats{}
		}
		if sizeS.tiers != nil {
			sizeS.tiers[storageclass.STANDARD] = tierStats{}
			sizeS.tiers[storageclass.RRS] = tierStats{}
		}

		if err != nil {

        // zero size -> reject
        reset(smbFile);
        when(smbFile.length()).thenReturn(0L);
        assertFalse(filter.accept(smbFile), "Zero size should be rejected");
        verify(smbFile, times(1)).length();

        // positive size -> accept
        reset(smbFile);
        when(smbFile.length()).thenReturn(42L);
        assertTrue(filter.accept(smbFile), "Positive size should be accepted");

     * Should correctly parse the raw bytes.
     */
    @Test
    void testAvSingleHostRawConstructor() {
        byte[] rawData = new byte[48]; // 8 (size/zero) + 8 (customData) + 32 (machineId)
        // Simulate some data
        rawData[0] = 48; // size
        rawData[16] = 0x01; // machineId start
        rawData[17] = 0x02;

        AvSingleHost avSingleHost = new AvSingleHost(rawData);

    /**
     * Gets the negotiated send buffer size.
     *
     * @return the send buffer size
     */
    int getSendBufferSize();

    /**
     * Gets the negotiated receive buffer size.
     *
     * @return the receive buffer size
     */
    int getReceiveBufferSize();

    /**
     * Gets the negotiated maximum transaction buffer size.
     *
     * @return the transaction buffer size