} 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"
)

from fastapi.testclient import TestClient

from docs_src.advanced_middleware.tutorial003_py39 import app


@app.get("/large")
async def large():
    return PlainTextResponse("x" * 4000, status_code=200)


client = TestClient(app)


def test_middleware():
    response = client.get("/large", headers={"accept-encoding": "gzip"})
    assert response.status_code == 200, response.text
    assert response.text == "x" * 4000

    return ItemOut(name=item.name, value=item.value, dep=dep)


@app.post("/sync/large-receive")
def sync_large_receive(payload: LargeIn):
    return {"received": len(payload.items)}


@app.post("/async/large-receive")
async def async_large_receive(payload: LargeIn):
    return {"received": len(payload.items)}


@app.get("/sync/large-dict-no-response-model")
def sync_large_dict_no_response_model():

        - label: "Does this affect error handling?"
        - label: "Is this about generics?"
        - label: "Is this change backward compatible? Breaking the Go 1 compatibility guarantee is a large cost and requires a large benefit"

  - type: textarea
    id: related-proposals
    attributes:
      label: Has this idea, or one like it, been proposed before?
      description: If so, how does this proposal differ?

        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;

        assertFalse(transaction.hasMoreElements(), "hasMoreElements should be false when all data is sent");
    }

    @Test
    @DisplayName("Test transaction with large data requires multiple elements")
    void testLargeDataMultipleElements() {
        // Set large amounts that won't fit in one buffer
        transaction.maxBufferSize = 100;
        transaction.setParameterBytesWritten(200);
        transaction.setDataBytesWritten(300);

            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);

 * limitations under the License.
 */

package model

import java.util.LinkedList

/**
 * Split a list of elements into nearly even sublist. If an element is too large, largeElementSplitFunction will be used to split the large element into several smaller pieces;
 * if some elements are too small, they will be aggregated by smallElementAggregateFunction.
 *
 * @param list the list to split, must be ordered by size desc

    }

    /**
     * Test readBytes with large file throws exception
     *
     * @throws Exception
     */
    @Test
    public void testReadBytes_LargeFile() throws Exception {
        final File largeFile = tempFolder.newFile("large.dat");

        // Create a file larger than MAX_BUF_SIZE (10MB)
        // Write 11MB of data

        assertEquals("Invalid PAC credential type", exception.getMessage());
    }

    /**
     * Tests the constructor with a byte array that is too large.
     */
    @Test
    void testConstructorWithDataTooLarge() {
        // A byte array with a length of 32 should be considered too large.
        byte[] largeData = new byte[32];