* <p>Modifications to this fluent iterable before a call to {@code iterator()} are reflected in
   * the returned fluent iterable. That is, the iterator skips the first {@code numberToSkip}
   * elements that exist when the iterator is created, not when {@code skip()} is called.
   *
   * <p>The returned fluent iterable's iterator supports {@code remove()} if the {@code Iterator} of

   */
  @ForOverride
  protected abstract void doStop();

  /**
   * This method is called by {@link #stopAsync} when the service is still starting (i.e. {@link
   * #startAsync} has been called but {@link #notifyStarted} has not). Subclasses can override the
   * method to cancel pending work and then call {@link #notifyStopped} to stop the service.
   *

    override fun getDisplayName(): String =
        "the build timestamp extracted from the build receipt".let {
            when {
                parameters.ignoreIncomingBuildReceipt.get() -> "$it (ignored)"
                else -> it
            }
        }

    private
    fun Parameters.buildReceiptString(): String? = when {
        ignoreIncomingBuildReceipt.get() -> null
        else -> buildReceiptFileContents.orNull
    }

import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.nio.charset.StandardCharsets;
import java.util.Arrays;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;

 * controls the order in which events are dispatched, while the executor controls how (i.e. on which
 * thread) the subscriber is actually called when an event is dispatched to it.
 *
 * @author Colin Decker
 */
abstract class Dispatcher {

  /**
   * Returns a dispatcher that queues events that are posted reentrantly on a thread that is already

        }
    }

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        when(mockConfig.getPid()).thenReturn(1234);
        when(mockConfig.getMaximumBufferSize()).thenReturn(65535);
        when(mockConfig.getMinimumVersion()).thenReturn(DialectVersion.SMB1);
        when(mockConfig.getMaximumVersion()).thenReturn(DialectVersion.SMB311);
        response = new TestSmbComNtTransactionResponse(mockConfig);

        if (isEmpty()) return ""
        deleteRange(length - 2, length)
      }
    headerValue = result
  }
  return result
}

internal fun Long.commonClampToInt(): Int =
  when {
    this > Int.MAX_VALUE -> Int.MAX_VALUE
    else -> toInt()
  }

internal fun CacheControl.Companion.commonForceNetwork() =
  CacheControl
    .Builder()
    .noCache()
    .build()

        smbComNtTransaction.writeParameterWordsWireFormat(dst, 0);

        // Check that offsets are zero when counts are zero
        assertEquals(0, SmbComTransaction.readInt4(dst, 23), "parameterOffset should be 0 when parameterCount is 0");
        assertEquals(0, SmbComTransaction.readInt4(dst, 31), "dataOffset should be 0 when dataCount is 0");
    }

After that, all of the processing logic is the same.

But because of our changes in `GzipRequest.body`, the request body will be automatically decompressed when it is loaded by **FastAPI** when needed.

## Accessing the request body in an exception handler { #accessing-the-request-body-in-an-exception-handler }

/// tip

   */
  public interface StatsCounter {
    /**
     * Records cache hits. This should be called when a cache request returns a cached value.
     *
     * @param count the number of hits to record
     * @since 11.0
     */
    void recordHits(int count);

    /**
     * Records cache misses. This should be called when a cache request returns a value that was not