// hashcodes from non-overlapping hash computations
    HashCode expected1 = randomHash(hashFunction, new Random(1L), numActions);
    HashCode expected2 = randomHash(hashFunction, new Random(2L), numActions);

    // equivalent, but overlapping, computations (should produce the same results as above)
    Random random1 = new Random(1L);
    Random random2 = new Random(2L);
    Hasher hasher1 = hashFunction.newHasher();

  }

  /**
   * Waits until the given weak reference is cleared, invoking the garbage collector as necessary to
   * try to ensure that this will happen.
   *
   * <p>This is a convenience method, equivalent to:
   *
   * {@snippet :
   * awaitDone(new FinalizationPredicate() {
   *   public boolean isDone() {
   *     return ref.get() == null;
   *   }
   * });
   * }
   *

   * captured by the returned {@link ClosingFuture}).
   *
   * <p>If this {@code ClosingFuture} succeeds, the derived one will be equivalent to the one
   * returned by the function.
   *
   * <p>If this {@code ClosingFuture} fails, the function will not be called, and the derived {@code
   * ClosingFuture} will be equivalent to this one.
   *
   * <p>If the function throws an exception, that exception is used as the result of the derived

}

var errorRune = []byte(string(utf8.RuneError))

// ScanRunes is a split function for a [Scanner] that returns each
// UTF-8-encoded rune as a token. The sequence of runes returned is
// equivalent to that from a range loop over the input as a string, which
// means that erroneous UTF-8 encodings translate to U+FFFD = "\xef\xbf\xbd".
// Because of the Scan interface, this makes it impossible for the client to

{* ../../docs_src/security/tutorial001_an_py39.py hl[8] *}

/// tip

Here `tokenUrl="token"` refers to a relative URL `token` that we haven't created yet. As it's a relative URL, it's equivalent to `./token`.

import okhttp3.OkHttpClient
import okhttp3.Response
import okhttp3.internal.http2.Header
import okio.Buffer
import okio.BufferedSource
import okio.Source

/** GMT and UTC are equivalent for our purposes. */
@JvmField
internal val UTC: TimeZone = TimeZone.getTimeZone("GMT")!!

internal fun threadFactory(
  name: String,
  daemon: Boolean,
): ThreadFactory =
  ThreadFactory { runnable ->

permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.

  You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains

   * remaining 32 bits interpreted as an IPv4 address. These are conventionally represented in
   * string literals as {@code "::192.168.0.1"}, though {@code "::c0a8:1"} is also considered an
   * IPv4 compatible address (and equivalent to {@code "::192.168.0.1"}).
   *
   * <p>For more on IPv4 compatible addresses see section 2.5.5.1 of <a target="_parent"
   * href="http://tools.ietf.org/html/rfc4291#section-2.5.5.1">RFC 4291</a>.
   *

    abstract operator fun set(
      builder: HttpUrl.Builder,
      value: String,
    )

    abstract operator fun get(url: HttpUrl): String

    /**
     * Returns a character equivalent to 's' in this component. This is used to convert hostname
     * characters to lowercase.
     */
    open fun canonicalize(s: String): String = s
  }

    /**
     * Converts this compat model InputLocation to an API model InputLocation.
     * This method is used for converting between the compat model and the API model.
     *
     * @return the equivalent API model InputLocation
     */
    public org.apache.maven.api.model.InputLocation toApiLocation() {
        if (locations != null && locations.values().contains(this)) {