void testInitialDataLength() {
        // Then
        assertEquals(0, response.getDataLength());
    }

    @Test
    @DisplayName("Should initially have zero data remaining")
    void testInitialDataRemaining() {
        // Then
        assertEquals(0, response.getDataRemaining());
    }

    @Test
    @DisplayName("Should write empty bytes to wire format")

        // Then
        assertEquals(6, bytesWritten);
        assertEquals(fid, SMBUtil.readInt2(dst, 0));
        // lastWriteTime is not written if digest is null, so the remaining bytes should be zero
        assertEquals(0, SMBUtil.readInt4(dst, 2));
    }

    /**
     * Test method for {@link jcifs.internal.smb1.com.SmbComClose#writeParameterWordsWireFormat(byte[], int)} with a signing digest.

                logger.warn("[{}] Failed to process ingester", ingester.getClass().getSimpleName(), e);
            }
        }
        return target;
    }

    /**
     * Commits any remaining documents in the cache to the index.
     * This method ensures all pending documents are processed.
     */
    @Override
    public void commit() {
        synchronized (docList) {

            SMBUtil.writeInt2(445, buffer, offset + 2); // sin_port
            System.arraycopy(address.getAddress(), 0, buffer, offset + 4, 4); // sin_addr
            // Remaining bytes stay zero-filled
        }
    }

    private static InetAddress parseSockaddr(byte[] data, int offset) {
        try {
            int family = SMBUtil.readInt2(data, offset);

        assertTrue(mockService.unregisterWitness(reg2));
        assertEquals(2, mockService.getRegistrationCount());
        assertFalse(mockService.hasRegistration(reg2));

        // Clean up remaining
        assertTrue(mockService.unregisterWitness(reg1));
        assertTrue(mockService.unregisterWitness(reg3));
        assertEquals(0, mockService.getRegistrationCount());
    }

    @Test

        HMACT64 clonedHmac = (HMACT64) originalHmac.clone();

        assertNotNull(clonedHmac);
        assertNotSame(originalHmac, clonedHmac);

        // Both should produce the same result when given the same remaining data
        originalHmac.engineUpdate(TEST_DATA, TEST_DATA.length / 2, TEST_DATA.length - TEST_DATA.length / 2);
        clonedHmac.engineUpdate(TEST_DATA, TEST_DATA.length / 2, TEST_DATA.length - TEST_DATA.length / 2);

        Configuration mockConfig = mock(Configuration.class);
        Smb2TreeDisconnectRequest request = new Smb2TreeDisconnectRequest(mockConfig);
        byte[] buffer = new byte[10];
        int offset = 8; // Only 2 bytes remaining, need 4

        // When & Then
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            request.writeBytesWireFormat(buffer, offset);
        });
    }

    @Test

    void testReadBytesWireFormatOffsetTooLarge() {
        // Given
        byte[] buffer = new byte[10];
        int offset = 9; // Only 1 byte remaining, need at least 2 for structure size

        // When & Then
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            response.readBytesWireFormat(buffer, offset);
        });
    }

            assertEquals(1024, req.getMaxCount(), "Named pipe maxCount should be 1024");
            assertEquals(1024, req.getRemaining(), "Named pipe remaining should be 1024");
        }
    }

    @Nested
    @DisplayName("Lifecycle and exception mapping")
    class LifecycleAndExceptions {

        @Test

                final SmbComReadAndX request = new SmbComReadAndX(file.fid, fp, r, null);
                if (file.type == SmbFile.TYPE_NAMED_PIPE) {
                    request.minCount = request.maxCount = request.remaining = 1024;
                }
                file.send(request, response);
            } catch (final SmbException se) {