assertEquals(16, signingKey.length, "Should produce 16-byte key");
    }

    @Test
    @DisplayName("Should handle large session key")
    void testDeriveKeys_LargeSessionKey() {
        // Given
        byte[] largeSessionKey = new byte[256]; // Larger than typical 16-byte key
        new SecureRandom().nextBytes(largeSessionKey);
        int dialect = Smb2Constants.SMB2_DIALECT_0311;

        // When

    with subsection 6b.

    d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to

        - 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?

}

func (e SizeTooSmall) Error() string {
	return fmt.Sprintf("Size small: got %d, want %d", e.Got, e.Want)
}

// SizeTooLarge reader size too large
type SizeTooLarge struct {
	Want int64
	Got  int64
}

func (e SizeTooLarge) Error() string {
	return fmt.Sprintf("Size large: got %d, want %d", e.Got, e.Want)
}

// SizeMismatch error size mismatch
type SizeMismatch struct {
	Want int64
	Got  int64
}

}

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

// 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 {