smb2Response.setTreeId(0);
            assertTrue(smb2Response.isValidTid(), "TID 0 should be valid");

            // Test maximum valid TID
            smb2Response.setTreeId(Integer.MAX_VALUE);
            assertTrue(smb2Response.isValidTid(), "Maximum TID should be valid");

            // Test invalid TID
            smb2Response.setTreeId(-1);

    }

    @Test
    @DisplayName("Test readDataWireFormat with maximum length server name")
    void testReadDataWireFormatMaxLengthServerName() throws Exception {
        setConverter(response, 0);
        setNumEntries(response, 1);

        // Create a 15-character server name (maximum for NetBIOS name)
        String serverName = "SERVERNAME12345"; // 15 characters

            assertEquals(0, response.getEndOfFile());
            assertEquals(0, response.getFileAttributes());
        }

        @Test
        @DisplayName("Should handle maximum values correctly")
        void testReadBytesWireFormatWithMaxValues() throws SMBProtocolDecodingException {
            // Given
            byte[] buffer = new byte[60];
            SMBUtil.writeInt2(60, buffer, 0);

  fun setClient(client: Boolean) {
    if (this.client == client) return
    this.client = client
    writer = Http2Writer(bytesOut, client)
  }

  fun acceptFrame() {
    frameCount++
  }

  /** Maximum length of an outbound data frame.  */
  fun maxOutboundDataLength(): Int = writer.maxDataLength()

  /** Count of frames sent or received.  */
  fun frameCount(): Int = frameCount

  fun sendFrame(): Http2Writer {

            assertEquals(4, bytesWritten);
            assertEquals(4, SMBUtil.readInt2(buffer, 0));
        }

        @Test
        @DisplayName("Should handle maximum offset")
        void testWriteBytesAtMaxOffset() {
            byte[] buffer = new byte[1000];
            int offset = buffer.length - 4;

      return File.createTempFile(
          /* prefix= */ prefix,
          /* suffix= */ null,
          /* directory= */ null /* defaults to java.io.tmpdir */);
    }

    /** Maximum loop count when creating temp directories. */
    private static final int TEMP_DIR_ATTEMPTS = 10000;
  }

  private static final class ThrowingCreator extends TempFileCreator {
    private static final String MESSAGE =

            assertEquals(count, response.getCount());
            assertEquals(remaining, response.getRemaining());
        }

        @Test
        @DisplayName("Should handle maximum integer values")
        void testMaximumValues() throws SMBProtocolDecodingException {
            byte[] buffer = createValidWriteResponse(Integer.MAX_VALUE, Integer.MAX_VALUE);

        int command = commandField.getInt(request);

        // Then
        assertEquals(0x000F, command); // SMB2_CHANGE_NOTIFY
    }

    @Test
    @DisplayName("Should handle maximum buffer size")
    void testMaximumBufferSize() {
        // Given
        Configuration config = mock(Configuration.class);
        when(config.getNotifyBufferSize()).thenReturn(Integer.MAX_VALUE);

            }
        }

        return Collections.unmodifiableSet(result);
    }

    /**
     * Configure resource manager
     *
     * @param maxAge maximum resource age in milliseconds
     * @param cleanupInterval cleanup interval in milliseconds
     * @param enableLeakDetection enable leak detection
     * @param enableAutoCleanup enable auto cleanup
     */

        // Assert
        assertEquals(0, bytesWritten); // Should return 0 as buffer is insufficient
    }

    @Test
    @DisplayName("Test with maximum offset boundary")
    void testMaxOffsetBoundary() {
        // Arrange
        byte[] largeData = new byte[1000];
        for (int i = 0; i < largeData.length; i++) {
            largeData[i] = (byte) (i % 256);