void testDecodeWithBufferOverflow() {
            assertThrows(SMBProtocolDecodingException.class, () -> testResponse.decode(testBuffer, 250, 10),
                    "Should throw exception when reading beyond buffer bounds");
        }

        @Test
        @DisplayName("Should handle zero-length decode")
        void testDecodeWithZeroLength() throws SMBProtocolDecodingException {

}

// Target - Kafka target.
type Target struct {
	status int32

	totalMessages  int64
	failedMessages int64

	wg sync.WaitGroup

	// Channel of log entries.
	// Reading logCh must hold read lock on logChMu (to avoid read race)
	// Sending a value on logCh must hold read lock on logChMu (to avoid closing)
	logCh   chan any
	logChMu sync.RWMutex

	// store to persist and replay the logs to the target

You can also use the [HTTP `PATCH`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) operation to *partially* update data.

This means that you can send only the data that you want to update, leaving the rest intact.

/// note

`PATCH` is less commonly used and known than `PUT`.

And many teams use only `PUT`, even for partial updates.

            }
            maxLineBuffer = maxOutputLineBuffer;
        }

        /**
         * Runs the input stream thread, reading lines and buffering them.
         */
        @Override
        public void run() {
            for (;;) {
                try {
                    final String line = br.readLine();

        TransPeekNamedPipeResponse testResponse = new TransPeekNamedPipeResponse(testConfig);

        // Assert
        assertNotNull(testResponse);
    }

    @Test
    @DisplayName("Test state changes after reading parameters")
    void testStateAfterReadingParameters() {
        // Arrange
        byte[] buffer = new byte[10];
        SMBUtil.writeInt2(1500, buffer, 0);
        SMBUtil.writeInt2(0xFFFF, buffer, 2);

import java.time.Duration;
import java.util.concurrent.TimeUnit;

/**
 * An object that accurately measures <i>elapsed time</i>: the measured duration between two
 * successive readings of "now" in the same process.
 *
 * <p>In contrast, <i>wall time</i> is a reading of "now" as given by a method like
 * {@link System#currentTimeMillis()}, best represented as an {@link java.time.Instant}. Such values

 * of the access check algorithm used by Windows is required. The following
 * is a basic description of the algorithm. For a more complete description
 * we recommend reading the section on Access Control in Keith Brown's
 * "The .NET Developer's Guide to Windows Security" (which is also
 * available online).
 * <p>
 * Direct ACEs are evaluated first in order. The SID of the user performing

        // Test zero time separately - it's handled specially
        SMBUtil.writeTime(0L, buffer, 0);
        long readTime = SMBUtil.readTime(buffer, 0);
        // When writing 0, it writes 0 directly, and when reading 0, it returns negative offset
        assertEquals(-SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601, readTime);
    }

    @Test
    void testUTimeConversionRoundTrip() {

	Checksums  map[string]string `json:"crc,omitempty" msg:"crc,omitempty"`   // Content Checksums
	Error      string            `json:"error,omitempty" msg:"err,omitempty"` // only set while reading part meta from drive.
}

// ChecksumInfo - carries checksums of individual scattered parts per disk.
type ChecksumInfo struct {
	PartNumber int
	Algorithm  BitrotAlgorithm
	Hash       []byte
}

org.apache.lucene.search.TimeLimitingCollector#getGlobalCounter()

@defaultMessage Don't interrupt threads use FutureUtils#cancel(Future<T>) instead
java.util.concurrent.Future#cancel(boolean)

@defaultMessage Don't try reading from paths that are not configured in Environment, resolve from Environment instead
org.elasticsearch.core.PathUtils#get(java.lang.String, java.lang.String[])
org.elasticsearch.core.PathUtils#get(java.net.URI)