* iterator} method only once, and should be tested using this class. Exceptions to this rule should
 * be clearly documented.
 *
 * <p>Note that although your APIs should be liberal in what they accept, your methods which
 * <i>return</i> iterables should make every attempt to return ones of the robust variety.
 *
 * <p>This testing utility is not thread-safe.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible

         * @param stream the {@link Consumer} to process the {@link Stream}
         */
        public void of(final Consumer<Stream<T>> stream) {
            try (Stream<T> s = supplier.get()) {
                stream.accept(s);
            }
        }

        /**
         * Applies the given function to a stream created by the supplier and returns the result.
         * The stream is automatically closed after the function is applied.

   * here would have no significance to end users, who would be forced to conform to the signature
   * used in FilenameFilter.)
   */
  @Override
  public boolean accept(File dir, String fileName) {
    return pattern.matcher(fileName).matches();
  }

  }

  /**
   * Enters this monitor. Blocks at most the given time.
   *
   * @return whether the monitor was entered
   */
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public boolean enter(long time, TimeUnit unit) {
    long timeoutNanos = toSafeNanos(time, unit);
    ReentrantLock lock = this.lock;
    if (!fair && lock.tryLock()) {
      return true;

 * always very useful information.
 *
 * <p>On the other hand, a <i>parameter</i> type of {@link ImmutableList} is generally a nuisance to
 * callers. Instead, accept {@link Iterable} and have your method or constructor body pass it to the
 * appropriate {@code copyOf} method itself.
 *
 * <p>Expressing the immutability guarantee directly in the type that user code references is a

// Or create a visible subclass for testing.
// For now, let's assume we can modify the original class slightly for testability,
// or we accept the less precise testToStringFormat test.

// Let's add a package-private helper to TransTransactNamedPipeResponse:
// String superToString() { return super.toString(); }
// And modify the test to use it.

Si una request entrante no se valida correctamente, se enviará un response `400`.

## `GZipMiddleware`

Maneja responses GZip para cualquier request que incluya `"gzip"` en el header `Accept-Encoding`.

El middleware manejará tanto responses estándar como en streaming.

{* ../../docs_src/advanced_middleware/tutorial003.py hl[2,6] *}

Se soportan los siguientes argumentos:

        // Then
        assertNotNull(buffer, "getBuffer should never return null");
        assertSame(expectedBuffer, buffer, "Should return configured buffer");
    }

    @Test
    @DisplayName("releaseBuffer should accept byte arrays gracefully")
    void testReleaseBufferContract() {
        // Given
        byte[] buffer = new byte[1024];
        doNothing().when(mockBufferCache).releaseBuffer(buffer);

        // When & Then

   *
   * <p>This deliberately avoids all nameservice lookups (e.g. no DNS).
   *
   * <p>This method accepts non-ASCII digits, for example {@code "１９２.１６８.０.１"} (those are fullwidth
   * characters). That is consistent with {@link InetAddress}, but not with various RFCs. If you
   * want to accept ASCII digits only, you can use something like {@code
   * CharMatcher.ascii().matchesAllOf(ipString)}.
   *

        // Current behavior of test impl: returns same reference
        assertSame(raw, t.toByteArray(), "should return the same reference as mechanismToken");
    }

    @Test
    @DisplayName("Setters accept null and getters return null")
    void settersAcceptNull() {
        TestSpnegoToken t = new TestSpnegoToken();
        t.setMechanismToken(null);
        t.setMechanismListMIC(null);