} else {
		bs.XferRateSml.addSize(sz, duration)
	}
}

// RMetricName - name of replication metric
type RMetricName string

const (
	// Large - objects larger than 128MiB
	Large RMetricName = "Large"
	// Small - objects smaller than 128MiB
	Small RMetricName = "Small"
	// Total - metric pertaining to totals
	Total RMetricName = "Total"
)

            assertEquals(negativeValue, ndrShort.value);
        }

        @Test
        @DisplayName("Should decode large value correctly")
        void testDecodeLargeValue() throws NdrException {
            // Given: NdrShort and mock returning large value
            int largeValue = 65535;
            NdrShort ndrShort = new NdrShort(0);
            when(mockBuffer.dec_ndr_short()).thenReturn(largeValue);

        }
    }

    public void test_execute_withVeryLargeBoost() {
        // Test executing BoostQuery with very large boost value
        Term term = new Term("field", "large");
        TermQuery termQuery = new TermQuery(term);
        BoostQuery boostQuery = new BoostQuery(termQuery, Float.MAX_VALUE);

        QueryContext context = new QueryContext("test", false);

        String result3 = aggregateLogJob.execute();
        assertEquals("", result3);
    }

    public void test_execute_performanceWithLargeErrorMessage() {
        // Test with very large error message
        final StringBuilder largeMessage = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            largeMessage.append("Error detail ").append(i).append(" ");
        }

 * body.
 *
 * ### The response body can be consumed only once.
 *
 * This class may be used to stream very large responses. For example, it is possible to use this
 * class to read a response that is larger than the entire memory allocated to the current process.
 * It can even stream a response larger than the total storage on the current device, which is a
 * common requirement for video streaming applications.
 *

        assertEquals(free * bytesPerSect, smbInfoAllocation.getFree());
    }

    @Test
    @DisplayName("Test decode with large bytes per sector")
    void testDecodeWithLargeBytesPerSector() throws SMBProtocolDecodingException {
        // Prepare test data with large bytesPerSect
        byte[] buffer = new byte[22];
        int idFileSystem = 0x22222222;
        int sectPerAlloc = 8;
        long alloc = 10000L;

        @Test
        @DisplayName("Should calculate large capacities correctly")
        void testLargeCapacityCalculation() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[32];
            // Set large values to test 64-bit arithmetic
            buffer[0] = (byte) 0xFF;
            buffer[1] = (byte) 0xFF; // Large alloc
            buffer[24] = (byte) 0xFF; // Large sectPerAlloc
            buffer[28] = (byte) 0xFF;

    int NT_STATUS_PENDING = 0x00000103;
    /** A notify change request is being completed and information is being returned */
    int NT_STATUS_NOTIFY_ENUM_DIR = 0x0000010C;
    /** The data was too large to fit into the specified buffer */
    int NT_STATUS_BUFFER_OVERFLOW = 0x80000005;
    /** The requested operation was unsuccessful */
    int NT_STATUS_UNSUCCESSFUL = 0xC0000001;

	opReadRune4 readOp = 4  // Read rune of size 4.
)

// ErrTooLarge is passed to panic if memory cannot be allocated to store data in a buffer.
var ErrTooLarge = errors.New("bytes.Buffer: too large")
var errNegativeRead = errors.New("bytes.Buffer: reader returned negative count from Read")

const maxInt = int(^uint(0) >> 1)

// Bytes returns a slice of length b.Len() holding the unread portion of the buffer.

        assertNotNull(deserialized.getData());
    }

    /**
     * Test transformer with large data
     */
    public void test_transformerWithLargeData() {
        TestTransformer transformer = new TestTransformer("largeDataTransformer");

        // Create large response data
        byte[] largeBody = new byte[10 * 1024 * 1024]; // 10MB
        for (int i = 0; i < largeBody.length; i++) {