}

const minReadBufferSize = 16
const maxConsecutiveEmptyReads = 100

// NewReaderSize returns a new [Reader] whose buffer has at least the specified
// size. If the argument io.Reader is already a [Reader] with large enough
// size, it returns the underlying [Reader].
func NewReaderSize(rd io.Reader, size int) *Reader {
	// Is it already a Reader?
	b, ok := rd.(*Reader)
	if ok && len(b.buf) >= size {
		return b
	}

                "1000, 500, 600, 8, 512", // Typical configuration
                "1000, 500, 600, 64, 512", // Large allocation units
                "1000, 500, 600, 8, 4096", // 4K sectors
                "1000, 500, 600, 16, 4096", // Large sectors and allocation
                "1000, 0, 0, 8, 512", // No free space
                "1000, 1000, 1000, 8, 512" // All space free
        })

        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

	if len(b) == 0 {
		return []byte{}
	}

	// Past a certain chunk size it is counterproductive to use
	// larger chunks as the source of the write, as when the source
	// is too large we are basically just thrashing the CPU D-cache.
	// So if the result length is larger than an empirically-found
	// limit (8KB), we stop growing the source string once the limit

// client may instead provide a custom split function.
//
// Scanning stops unrecoverably at EOF, the first I/O error, or a token too
// large to fit in the [Scanner.Buffer]. When a scan stops, the reader may have
// advanced arbitrarily far past the last token. Programs that need more
// control over error handling or large tokens, or must run sequential scans
// on a reader, should use [bufio.Reader] instead.
type Scanner struct {

		for b.Loop() {
			benchmarkBufioScanner(smallInput)
		}
	})
	b.Run("medium", func(b *testing.B) {
		for b.Loop() {
			benchmarkBufioScanner(mediumInput)
		}
	})
	b.Run("large", func(b *testing.B) {
		for b.Loop() {
			benchmarkBufioScanner(largeInput)
		}
	})
}

func benchmarkBufioScanner(b []byte) {
	s := bufio.NewScanner(bytes.NewReader(b))
	s.Split(bufio.ScanBytes)

from docs_src.custom_response import tutorial008_py39
from docs_src.custom_response.tutorial008_py39 import app

client = TestClient(app)


def test_get(tmp_path: Path):
    file_path: Path = tmp_path / "large-video-file.mp4"
    tutorial008_py39.some_file_path = str(file_path)
    test_content = b"Fake video bytes"
    file_path.write_bytes(test_content)
    response = client.get("/")