int contextPos = 192;
        SMBUtil.writeInt2(1, buffer, contextPos); // Context type
        SMBUtil.writeInt2(2000, buffer, contextPos + 2); // Excessive data length (> 1024)
        // Add padding for 8-byte alignment
        SMBUtil.writeInt2(0, buffer, contextPos + 4); // Reserved

        // The validation logic is implemented and verified through code inspection

          .url(server.url("/"))
          .build(),
      )
    val response = call.execute()
    interruptLater(500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)
    assertFailsWith<IOException> {
      while (responseBody.read(buffer) != -1) {
      }
    }
    responseBody.close()
  }

  @Test
  fun forciblyStopDispatcher() {
    client =

    }

    @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
        for (int i = 0; i < largeRequestBuffer.length; i++) {
            largeRequestBuffer[i] = (byte) (i % 256);

            byte[] buffer = new byte[1024];
            int result = request.readBytesWireFormat(buffer, 0);
            assertEquals(0, result);
        }

        @Test
        @DisplayName("Should return 0 regardless of buffer position")
        void testReadBytesWireFormatDifferentPosition() {
            byte[] buffer = new byte[1024];
            int result = request.readBytesWireFormat(buffer, 100);

        .build(),
    )
    val call = client.newCall(Request(server.url("/")))
    val response = call.execute()
    cancelLater(call, 500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)
    assertFailsWith<IOException> {
      while (responseBody.read(buffer) != -1) {
      }
    }.also { expected ->
      assertEquals(cancelMode == INTERRUPT, Thread.interrupted())
    }

    }

    /** True if initialized */
    private static volatile boolean initialized;

    /** Cache of {@link BeanDesc} */
    private static final ConcurrentMap<Class<?>, BeanDesc> beanDescCache = newConcurrentHashMap(1024);

    static {
        initialize();
    }

    /**
     * Returns a {@link BeanDesc}.
     *
     * @param clazz
     *            the Bean class. Must not be {@literal null}

    void testVariousPathFormats(String path) throws Exception {
        // Given
        Smb2TreeConnectRequest req = new Smb2TreeConnectRequest(mockConfig, path);
        byte[] buffer = new byte[1024];

        // Encode to set headerStart
        req.encode(buffer, 0);

        // Then
        byte[] pathBytes = path.getBytes(StandardCharsets.UTF_16LE);

            response.decode(buffer1, 0, buffer1.length);
            assertEquals(1, response.getChunksWritten());
            assertEquals(1024, response.getChunkBytesWritten());
            assertEquals(1024, response.getTotalBytesWritten());

            // Second decode - should update values
            byte[] buffer2 = createValidCopyChunkResponse(5, 8192, 40960);

        // Arrange
        byte[] largeData = new byte[65536]; // 64KB
        for (int i = 0; i < largeData.length; i++) {
            largeData[i] = (byte) (i % 256);
        }
        int offset = 1024;
        int length = 32768; // 32KB

        // Act
        signingDigest.sign(largeData, offset, length, request, response);

        // Assert

    @BeforeEach
    public void setUp() {
        compressionService = new DefaultCompressionService();

        // Create test data with patterns that should compress well
        testData = generateTestData(1024);
        largeTestData = generateTestData(8192);
    }

    @Test
    @DisplayName("Test supported algorithms")
    public void testSupportedAlgorithms() {