}

  /**
   * Returns a {@code Collector} accumulating entries into a {@code Multimap} generated from the
   * specified supplier. Each input element is mapped to a key and a stream of values, each of which
   * are put into the resulting {@code Multimap}, in the encounter order of the stream and the
   * encounter order of the streams of values.
   *
   * <p>Example:

   */
  public void testAwaitFullGc() {
    CountDownLatch finalizerRan = new CountDownLatch(1);
    WeakReference<Object> ref = createWeakReferenceWithFinalizer(finalizerRan);

    // Don't copy this into your own test!
    // Use e.g. awaitClear or await(CountDownLatch) instead.
    GcFinalization.awaitFullGc();

    // Attempt to help with some flakiness that we've seen: b/387521512.
    GcFinalization.awaitFullGc();

	if err != nil {
		return 0, 0, err
	}

	start = h.Start
	if h.IsSuffixLength {
		start = max(resourceSize+h.Start, 0)
	}
	return start, length, nil
}

// Parse a HTTP range header value into a HTTPRangeSpec
func parseRequestRangeSpec(rangeString string) (hrange *HTTPRangeSpec, err error) {
	// Return error if given range string doesn't start with byte range prefix.
	if !strings.HasPrefix(rangeString, byteRangePrefix) {

        try {
            return new URL(context, spec);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Converts a string into <code>application/x-www-form-urlencoded</code>
     * format using the specified encoding scheme.
     *
     * @param s
     *            The string to be converted. Must not be {@literal null} or empty.

#### O tempo para responder ajuda os invasores { #the-time-to-answer-helps-the-attackers }

Neste ponto, ao perceber que o servidor demorou alguns microssegundos a mais para enviar o retorno "Usuário ou senha incorretos", os invasores irão saber que eles acertaram _alguma coisa_, algumas das letras iniciais estavam certas.

 *
 * {@code CacheBuilder} builds caches with any combination of the following features:
 *
 * <ul>
 *   <li>automatic loading of entries into the cache
 *   <li>least-recently-used eviction when a maximum size is exceeded (note that the cache is
 *       divided into segments, each of which does LRU internally)
 *   <li>time-based expiration of entries, measured since last access or last write

                    return builder.build();
                }
            }
            return query;
        }

        /**
         * Splits a field name into its components.
         *
         * @param defaultField the default field name
         * @param field the field name to split
         * @return a Pair containing the field name and extension key
         */

     *
     * <p>This method caches compiled Script classes per script text.
     * Each evaluation creates a new Script instance to ensure thread-safe binding isolation.
     * The DI container is automatically injected into the binding map as "container".</p>
     *
     * @param template the Groovy script to evaluate (null-safe, returns null if empty)

import okio.ByteString.Companion.toByteString

/**
 * Logs SSL keys to a log file, allowing Wireshark to decode traffic and be examined with http2
 * filter. The approach is to hook into JSSE log events for the messages between client and server
 * during handshake, and then take the agreed masterSecret from private fields of the session.
 *
 * Copy WireSharkKeyLoggerListener to your test code to use in development.

    throw new UnsupportedOperationException();
  }

  /**
   * {@inheritDoc}
   *
   * <p>This implementation of {@code getAllPresent} lacks any insight into the internal cache data
   * structure, and is thus forced to return the query keys instead of the cached keys. This is only
   * possible with an unsafe cast which requires {@code keys} to actually be of type {@code K}.
   *