bufferIndex += dataCount;
        }

        /* Check to see if the entire transaction has been
         * read. If so call the read methods.
         */

        if (!parametersDone && parameterDisplacement + parameterCount == totalParameterCount) {
            parametersDone = true;
        }

    @Test
    void nullReference_throwsNullPointerException() {
        // Arrange
        SmbBasicFileInfo info = null;

        // Act & Assert: attempting to call any method on null should throw NPE
        Assertions.assertThrows(NullPointerException.class, () -> {
            // Intentionally dereference null to validate exception behavior

 * iterators that don't support {@code remove()}. Otherwise, all optional operations are supported.
 * Null row keys, columns keys, and values are not supported.
 *
 * <p>Lookups by row key are often faster than lookups by column key, because the data is stored in
 * a {@code Map<R, Map<C, V>>}. A method call like {@code column(columnKey).get(rowKey)} still runs

	index := entries - 1
	if index < dynamicTimeoutLogSize {
		dt.mutex.Lock()
		dt.log[index] = duration

		// We leak entries while we copy
		if entries == dynamicTimeoutLogSize {
			// Make copy on stack in order to call adjust()
			logCopy := [dynamicTimeoutLogSize]time.Duration{}
			copy(logCopy[:], dt.log[:])

			// reset log entries
			atomic.StoreInt64(&dt.entries, 0)
			dt.mutex.Unlock()

			dt.adjust(logCopy)

import java.util.concurrent.locks.Lock;
import org.jspecify.annotations.Nullable;

/**
 * Utilities for treating interruptible operations as uninterruptible. In all cases, if a thread is
 * interrupted during such a call, the call continues to block until the result is available or the
 * timeout elapses, and only then re-interrupts the thread.
 *
 * @author Anthony Zana
 * @since 10.0
 */
@GwtCompatible

{* ../../docs_src/settings/app03_an_py39/main.py hl[1,11] *}

Then for any subsequent call of `get_settings()` in the dependencies for the next requests, instead of executing the internal code of `get_settings()` and creating a new `Settings` object, it will return the same object that was returned on the first call, again and again.

#### `lru_cache` Technical Details { #lru-cache-technical-details }

   * Builder#addAll(Iterable)}, with all the performance implications associated with that.
   */
  public static ImmutableLongArray copyOf(Iterable<Long> values) {
    if (values instanceof Collection) {
      return copyOf((Collection<Long>) values);
    }
    return builder().addAll(values).build();
  }

  /**
   * Returns an immutable array containing all the values from {@code stream}, in order.
   *

type xlStorageDiskIDCheck struct {
	totalWrites           atomic.Uint64
	totalDeletes          atomic.Uint64
	totalErrsAvailability atomic.Uint64 // Captures all data availability errors such as faulty disk, timeout errors.
	totalErrsTimeout      atomic.Uint64 // Captures all timeout only errors

	// apiCalls should be placed first so alignment is guaranteed for atomic operations.
	apiCalls     [storageMetricLast]uint64

            // The implementation doesn't check for null in constructor
            buffer = new DfsReferralRequestBuffer(path, maxReferralLevel);
            assertNotNull(buffer);

            // Will throw NPE when trying to call size() or encode()
            assertThrows(NullPointerException.class, () -> {
                buffer.size();
            });
        }

        @ParameterizedTest

 * Fix bug where the Content-Length header was not always dropped when
   following a redirect from a POST to a GET.
 * Implement basic support for `Thread.interrupt()`. OkHttp now checks
   for an interruption before doing a blocking call. If it is interrupted,
   it throws an `InterruptedIOException`.

## Version 1.5.2

_2014-03-17_

 * Fix bug where deleting a file that was absent from the `HttpResponseCache`
   caused an IOException.