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

        });
    }

    @Test
    public void testSmb1MessageSizeTooLarge() throws Exception {
        assertThrows(SmbException.class, () -> {
            validator.validateMessageSize(65536, true);
        });
    }

    @Test
    public void testSmb2MessageSizeTooLarge() throws Exception {
        assertThrows(SmbException.class, () -> {

            byte[] salt = new byte[64];
            SecureRandom random = new SecureRandom();

            for (int i = 0; i < hashAlgos.length; i++) {
                hashAlgos[i] = random.nextInt(65536);
            }
            random.nextBytes(salt);

            PreauthIntegrityNegotiateContext original = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            // Encode

            assertEquals(16, result3);
        }

        @Test
        @DisplayName("Should handle maximum name length")
        void testMaximumNameLength() {
            byte[] maxName = new byte[65536]; // 64KB
            Arrays.fill(maxName, (byte) 'M');
            TestCreateContextRequest request = new TestCreateContextRequest(maxName);

            assertArrayEquals(maxName, request.getName());

        assertNotNull(testConfig.getRandom());
        assertNotNull(testConfig.getLocalTimezone());

        // Check PID is set
        assertTrue(testConfig.getPid() >= 0);
        assertTrue(testConfig.getPid() < 65536);

        // Check machine ID
        assertNotNull(testConfig.getMachineId());
        assertEquals(32, testConfig.getMachineId().length);

        // Check native OS

    }

    private static Stream<Arguments> provideInt4TestValues() {
        return Stream.of(Arguments.of(0), Arguments.of(1), Arguments.of(255), Arguments.of(256), Arguments.of(65535), Arguments.of(65536),
                Arguments.of(0x7FFFFFFF), Arguments.of(0xFFFFFFFF));
    }

    @Test
    @DisplayName("readInt2 should correctly read 16-bit integer")
    void testReadInt2() {

    }

    @Test
    @DisplayName("Test large buffer handling")
    void testLargeBufferHandling() {
        // Arrange
        byte[] largeBuffer = new byte[65536]; // 64KB buffer

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

secret key (apart from the KMS-generated ones) is 256 bits long. The KMS-generated keys may be 256 bits but this depends on the KMS capabilities and configuration.

The *Secure Channel* splits the object content into chunks of a fixed size of `65536` bytes. The last chunk may be smaller to avoid adding additional overhead and is treated specially to prevent truncation attacks. The nonce value is 96 bits long and generated randomly per object / multi-part part. The *Secure Channel* supports plaintexts...

    }

    @Test
    @DisplayName("Should handle maximum buffer size")
    void testMaximumBufferSize() throws Exception {
        // Given - large buffer with many notifications
        byte[] buffer = new byte[65536];
        int offset = 0;

        setHeaderStart(response, 64);

        // Calculate space for notifications
        int notificationSize = 32; // Each notification
        int notificationCount = 100;

        final int negotiateContextOffset = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // Validate security buffer parameters
        if (securityBufferLength < 0 || securityBufferLength > 65536) { // 64KB max for security buffer
            throw new SMBProtocolDecodingException("Invalid security buffer length: " + securityBufferLength + " (must be 0-65536)");
        }
        if (securityBufferOffset < 0) {