assertEquals(content.length, bytesRead);
            assertTrue(Arrays.equals(content, buffer));
        } catch (IOException e) {
            fail("IOException should not occur: " + e.getMessage());
        }
    }

    public void test_responseBodyFile() throws IOException {
        // Test response body with file
        ResponseData data = new ResponseData();

                    assertThrows(SMBProtocolDecodingException.class, () -> response.readBytesWireFormat(buffer, 0));

            assertEquals("Expected structureSize = 17", exception.getMessage());
        }

        @Test
        @DisplayName("Should handle response at end of buffer")
        void testResponseAtEndOfBuffer() throws SMBProtocolDecodingException {

        } catch (final CycleDetectedException e) {
            String message = "The projects in the reactor contain a cyclic reference: " + e.getMessage();
            ProjectCycleException error = new ProjectCycleException(message, e);
            return Result.error(
                    Collections.singletonList(new DefaultModelProblem(null, null, null, null, 0, 0, error)));

            assertTrue(true);
        } catch (final InterruptedException e) {
            fail("Interrupted during execution");
        } catch (final ExecutionException e) {
            fail("Execution failed: " + e.getMessage());
        } finally {
            executor.shutdown();
            try {
                if (!executor.awaitTermination(30, java.util.concurrent.TimeUnit.SECONDS)) {
                    executor.shutdownNow();

            if (Constants.TRUE.equalsIgnoreCase(ComponentUtil.getFessConfig().getApiJsonResponseExceptionIncluded())) {
                logger.warn("Failed to access Web API.", e);
                message = e.getMessage();
            } else {
                final String errorCode = UUID.randomUUID().toString();
                message = "[" + errorCode + "] Failed to access to Web API.";
                logger.warn(message, e);

                writeSecurityBuffer(type2, 40, data + target.length, targetInformation);
            }
            return type2;
        } catch (final IOException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    @Override
    public String toString() {
        final String target = getTarget();
        final byte[] challenge = getChallenge();
        final byte[] context = getContext();

            FileUtil.readBytes(largeFile);
            fail("Expected IORuntimeException for large file");
        } catch (final IORuntimeException e) {
            assertTrue("Error message should mention file size", e.getMessage().contains("File too large"));
        }
    }

    /**
     * Test readBytes with file within size limit
     *
     * @throws Exception
     */
    @Test

        try {
            executeThumbnailGenerator();
        } catch (final Exception e) {
            logger.warn("Failed to generate thumbnails.", e);
            resultBuf.append(e.getMessage()).append("\n");
        } finally {
            if (timeoutTask != null && !timeoutTask.isCanceled()) {
                timeoutTask.cancel();
            }
        }

        return resultBuf.toString();

                        response.isReceived = true;
                        notifyAll();
                    }
                }
            } catch (final Exception ex) {
                final String msg = ex.getMessage();
                final boolean timeout = msg != null && msg.equals("Read timed out");
                /* If just a timeout, try to disconnect gracefully
                 */
                final boolean hard = !timeout;

                        } catch (InterpolationException e) {
                            problems.add(new ModelProblemCollectorRequest(Severity.ERROR, Version.BASE)
                                    .setMessage(e.getMessage())
                                    .setException(e));
                        }
                        cache.put(value, c);
                    }
                    return c;
                }