assertThat(ioe.message).isEqualTo("google.com")
      val cause = ioe.cause!!
      assertThat(cause).isInstanceOf<IOException>()
      assertThat(cause).hasMessage("response size exceeds limit (65536 bytes): 65537 bytes")
    }
  }

  @Test
  fun failOnBadResponse() {
    server.enqueue(dnsResponse("00"))
    try {
      dns.lookup("google.com")
      fail<Any>()
    } catch (ioe: IOException) {

```

A response similar to this one should be displayed:

```
Generating RSA private key, 2048 bit long modulus
............................................+++
...........+++
e is 65537 (0x10001)
```

Alternatively, use the following command to generate a private RSA key protected by a password:

```sh
openssl genrsa -aes256 -passout pass:PASSWORD -out private.key 2048
```

	VSHUF4IV	$16, V1, V2	// ERROR "operand out of range 0 to 15"
	XVSHUF4IV	$16, X1, X2	// ERROR "operand out of range 0 to 15"
	ADDV16		$1, R4, R5	// ERROR "the constant must be a multiple of 65536."

    public static final int MAX_DOMAIN_LENGTH = 255;
    public static final int MAX_SHARE_NAME_LENGTH = 80;
    public static final int MAX_BUFFER_SIZE = 65536; // 64KB default max buffer
    public static final int MAX_SMB2_BUFFER_SIZE = 8388608; // 8MB for SMB2/3
    public static final int MAX_CREDITS = 65535;

    // Patterns for validation
    private static final Pattern VALID_USERNAME = Pattern.compile("^[a-zA-Z0-9._\\-@]+$");

    @Test
    @DisplayName("Test edge case with maximum buffer index")
    void testReadBytesWireFormatMaxBufferIndex() throws SMBProtocolDecodingException {
        byte[] buffer = new byte[65536]; // Large buffer
        int bufferIndex = 65534; // Near the end

        // Set structure size to 2
        SMBUtil.writeInt2(2, buffer, bufferIndex);

        int result = response.readBytesWireFormat(buffer, bufferIndex);

	AND	R1, R2, R3            // b9e42031
	AND	$-2, R1               // a517fffe
	AND	$-65536, R1           // c01bffff0000
	AND	$1, R1                // c0a100000001b980001a
	ANDW	R1, R2                // 1421
	ANDW	R1, R2, R3            // b9f42031
	ANDW	$1, R1                // c01b00000001
	ANDW	$131071, R1           // a5160001
	ANDW	$65536, R1            // c01b00010000
	ANDW	$-2, R1               // a517fffe

        // Arrange
        byte[] largeBuffer = new byte[65536]; // 64KB buffer

        // Act & Assert
        assertEquals(0, response.writeSetupWireFormat(largeBuffer, 0));
        assertEquals(0, response.writeParametersWireFormat(largeBuffer, 32768));
        assertEquals(0, response.writeDataWireFormat(largeBuffer, 65535));
        assertEquals(0, response.readSetupWireFormat(largeBuffer, 0, 65536));

        // Arrange
        byte[] largeBuffer = new byte[65536]; // 64KB buffer

        // Act & Assert
        assertEquals(0, response.writeSetupWireFormat(largeBuffer, 0));
        assertEquals(0, response.writeParametersWireFormat(largeBuffer, 32768));
        assertEquals(0, response.writeDataWireFormat(largeBuffer, 65535));
        assertEquals(0, response.readSetupWireFormat(largeBuffer, 0, 65536));

        assertDoesNotThrow(() -> InputValidator.validatePort(65535));

        assertThrows(IllegalArgumentException.class, () -> InputValidator.validatePort(0));
        assertThrows(IllegalArgumentException.class, () -> InputValidator.validatePort(-1));
        assertThrows(IllegalArgumentException.class, () -> InputValidator.validatePort(65536));
    }

    @Test
    @DisplayName("Test timeout validation")

        }

        @Test
        @DisplayName("Should handle large arrays efficiently")
        void testWriteBytesWireFormatWithLargeArray() {
            // Given
            byte[] dst = new byte[65536]; // 64KB array

            // When
            int result = response.writeBytesWireFormat(dst, 32768);

            // Then
            assertEquals(0, result);
        }
    }

    @Nested