var finished: Boolean = false,
  ) : Sink {
    /**
     * Buffer of outgoing data. This batches writes of small writes into this sink as larges frames
     * written to the outgoing connection. Batching saves the (small) framing overhead.
     */
    private val sendBuffer = Buffer()

    /** Trailers to send at the end of the stream. */
    var trailers: Headers? = null

    }

    // ===================================================================================
    //                                                                        Small Helper
    //                                                                        ============
    /**
     * Verify the CRUD mode.
     * @param crudMode The CRUD mode.
     * @param expectedMode The expected mode.

            return entity;
        });
    }

    // ===================================================================================
    //                                                                        Small Helper
    //                                                                        ============
    /**
     * Verify that the CRUD mode matches the expected mode.
     *
     * @param crudMode the actual CRUD mode

    class EdgeCasesTests {

        @Test
        @DisplayName("Should handle malformed buffer gracefully")
        void testReadDataWireFormatMalformedBuffer() {
            byte[] buffer = new byte[3]; // Too small for valid DFS referral

            assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
                response.readDataWireFormat(buffer, 0, buffer.length);
            });
        }

        @Test

     *
     * @return retry delay or 0 if no retry
     */
    public long getRetryDelay() {
        switch (severity) {
        case RECOVERABLE:
            return 100; // Immediate retry with small delay
        case TRANSIENT:
            return 5000; // Wait 5 seconds
        default:
            return 0; // No retry
        }
    }

    @Override
    public String toString() {

        bufferIndex += 4;

        // Validate remaining buffer size for algorithms
        if (len < 8 + (compressionCount * 2)) {
            throw new SMBProtocolDecodingException("Buffer too small for compression algorithms");
        }

        // Read compression algorithms
        this.compressionAlgorithms = new int[compressionCount];
        for (int i = 0; i < compressionCount; i++) {

                    out.print("\"><b>");
                    out.print(name);
                    out.print("</b><br><small>");
                    out.print(f.length() / 1024 + "KB <br>");
                    out.print(sdf.format(new Date(f.lastModified())));
                    out.print("</small>");
                    out.println("</a>");
                }
            }
        }

                Arguments.of((LongGetter) FileEntry::length, -100L, "negative length"),
                Arguments.of((LongGetter) FileEntry::length, 0L, "zero length"),
                Arguments.of((LongGetter) FileEntry::length, 1L, "small length"));
    }

    @ParameterizedTest(name = "Long getter {2} returns {1}")
    @MethodSource("longGetterProvider")
    void longGetters_edgeCases(LongGetter getter, long value, String label) {
        // Arrange

 * encode/decode operation.
 */
public class DcerpcMessageTest {

    /**
     * A trivial concrete subclass used for testing. It simply writes a
     * single small value in {@code encode_in} and reads it in
     * {@code decode_out}.
     */
    private static class TestMessage extends DcerpcMessage {
        int decodedValue = 0;

        TestMessage() {

        // Arrange
        TransTransactNamedPipe trans = new TransTransactNamedPipe(mockConfig, TEST_FID, TEST_DATA, TEST_OFFSET, TEST_LENGTH);
        byte[] dst = new byte[5]; // Buffer too small
        int dstIndex = 0;

        // Act
        int bytesWritten = trans.writeDataWireFormat(dst, dstIndex);

        // Assert
        assertEquals(0, bytesWritten);
    }

    @Test