}
        });
    }

    /**
     * Writes OpenSearch JSON API responses to the ZIP output stream.
     *
     * @param zos the ZIP output stream to write to
     * @param id the diagnostic ID for organizing files in the ZIP
     */
    protected void writeFesenJson(final ZipOutputStream zos, final String id) {
        writeElastisearchJsonApi(zos, id, "cluster", "health");

        int readDataAvailable = 100;
        int numberOfMessages = 2;
        int messageLength = 50;
        byte[] testData = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };

        // Write values to buffer
        SMBUtil.writeInt4(namedPipeState, buffer, bufferIndex);
        SMBUtil.writeInt4(readDataAvailable, buffer, bufferIndex + 4);
        SMBUtil.writeInt4(numberOfMessages, buffer, bufferIndex + 8);

        // Write a valid string structure
        String testString = "TEST";
        int totalChars = testString.length();
        writeLittleEndianInt(dos, totalChars); // totalChars
        writeLittleEndianInt(dos, 0); // unusedChars
        writeLittleEndianInt(dos, totalChars); // usedChars

        // Write the actual characters (as shorts in little-endian)

        offset += 4;

        // Write context name
        System.arraycopy(CONTEXT_NAME_BYTES, 0, buffer, offset, 4);
        offset += 4;

        // Padding to align data to 8-byte boundary
        offset += 4;

        // Write standard lease data (32 bytes)
        leaseKey.encode(buffer, offset); // LeaseKey (16 bytes)
        offset += 16;

        ResponseData data = new ResponseData();

        File tempFile = File.createTempFile("test", ".txt");
        try {
            String content = "File content";
            Files.write(tempFile.toPath(), content.getBytes(StandardCharsets.UTF_8));

            data.setResponseBody(tempFile, false);

            assertTrue(data.hasResponseBody());
            assertNotNull(data.getResponseBody());

        }

        @Override
        public void write(final byte[] b) throws IOException {
            this.stream.write(b);
            this.collector.write(b);
        }

        @Override
        public void write(final byte[] b, final int off, final int len) throws IOException {
            this.stream.write(b, off, len);
            this.collector.write(b, off, len);
        }

        @Override

        String testContent = "Hello, World!";
        tempFile = File.createTempFile("test", ".tmp", Curl.tmpDir);

        // Write test content to file
        try (FileOutputStream fos = new FileOutputStream(tempFile)) {
            fos.write(testContent.getBytes("UTF-8"));
        }

        ContentCache cache = new ContentCache(tempFile);

        byte[] buffer = new byte[totalSize];

        // Write next entry offset (4 bytes)
        SMBUtil.writeInt4(nextOffset, buffer, 0);

        // Write action (4 bytes)
        SMBUtil.writeInt4(action, buffer, 4);

        // Write file name length (4 bytes)
        SMBUtil.writeInt4(fileNameBytes.length, buffer, 8);

        // Write file name

        CloseableUtil.close(out);
    }

    private static class NotifyOutputStream extends OutputStream {
        private String notify_;

        @Override
        public void write(final int arg0) throws IOException {
        }

        @Override
        public void close() throws IOException {
            super.close();
            notify_ = "closed";
        }

        assertTrue(region.getSize() > 0, "Region should have positive size");
        assertTrue(region.hasAccess(RdmaAccess.LOCAL_WRITE), "Should have local write access");
        assertTrue(region.hasAccess(RdmaAccess.REMOTE_WRITE), "Should have remote write access");

        // Verify provider was called
        verify(mockProvider, atLeastOnce()).registerMemory(any(ByteBuffer.class), any());
    }

    @Test