super(out);
    }

    @Override
    public synchronized void write(final byte[] b, int off, final int len) throws IOException {
        if (len > 0xFFFF) {
            throw new IOException("write too large: " + len);
        }
        if (off < 4) {
            throw new IOException("NetBIOS socket output buffer requires 4 bytes available before off");
        }

        off -= 4;

 * or construct a string representation.  The tests focus on:
 *
 * <ul>
 *   <li>happy‑path behaviour</li>
 *   <li>boundary arguments (e.g., negative indices, large values)</li>
 *   <li>string representation containing the class name</li>
 *   <li>null buffer handling</li>
 * </ul>
 */
final class TransWaitNamedPipeResponseTest {

    /**

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

    @Test
    @DisplayName("Test getSendBufferSize returns large size")
    void testGetSendBufferSizeLarge() {
        // Arrange
        int expectedSize = 1048576;
        when(negotiationResponse.getSendBufferSize()).thenReturn(expectedSize);

        // Act

        assertEquals(1, SMBUtil.readInt2(buffer, 8));
        assertEquals(1, SMBUtil.readInt2(buffer, 10));
    }

    /**
     * Test that a large file lock (bit 0x10 set) is encoded and decoded correctly.
     */
    @ParameterizedTest
    @ValueSource(ints = { 0x10, 0x11 })
    void largeFileFlagSet_and_decoded_according_to_type(int type) throws Exception {

# See https://pre-commit.com for more information
# See https://pre-commit.com/hooks.html for more hooks
repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v6.0.0
    hooks:
      - id: check-added-large-files
        args: ['--maxkb=750']
      - id: check-toml
      - id: check-yaml
        args:
        - --unsafe
      - id: end-of-file-fixer
      - id: trailing-whitespace

  - repo: local
    hooks:

        assertEquals(0, negotiationWithEmptyBuffers.getResponseRaw().length);
    }

    @Test
    @DisplayName("Test with large buffers")
    void testWithLargeBuffers() {
        // Test with large byte arrays
        byte[] largeRequestBuffer = new byte[1024];
        byte[] largeResponseBuffer = new byte[2048];

        // Fill with some test data

    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;

MinIO is a high performance distributed object storage server, designed for large-scale private cloud infrastructure. MinIO is designed in a cloud-native manner to scale sustainably in multi-tenant environments. Orchestration platforms like Kubernetes provide perfect cloud-native environment to deploy and scale MinIO.

        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        SessionRetargetResponsePacket packet = new SessionRetargetResponsePacket();

        // Create a buffer large enough to hold the read bytes
        byte[] buffer = new byte[6];
        int bytesRead = packet.readTrailerWireFormat(bais, buffer, 0);

        // Verify that 6 bytes were read, which is the expected length.

            // With size = 6 * 2 = 12, should produce "000F107F80FF"
            assertTrue(result.contains("000F107F80FF"));
        }

        @Test
        @DisplayName("Large challenge array is handled correctly")
        void testLargeChallengeArray() {
            byte[] challenge = new byte[16];
            for (int i = 0; i < 16; i++) {
                challenge[i] = (byte) i;