}
    }
    return new MessageDigestHasher(getMessageDigest(prototype.getAlgorithm()), bytes);
  }

  private static final class SerializedForm implements Serializable {
    private final String algorithmName;
    private final int bytes;
    private final String toString;

    private SerializedForm(String algorithmName, int bytes, String toString) {
      this.algorithmName = algorithmName;
      this.bytes = bytes;

/**
 * Tests for {@link AbstractInvocationHandler}.
 *
 * @author Ben Yu
 */
@NullUnmarked
public class AbstractInvocationHandlerTest extends TestCase {

  private static final ImmutableList<String> LIST1 = ImmutableList.of("one", "two");
  private static final ImmutableList<String> LIST2 = ImmutableList.of("three");

  public void testDelegate() {
    assertEquals(LIST1, ImmutableList.copyOf(newDelegatingList(LIST1)));

    private boolean cacheNotFound = false;

    private boolean ignoreMissingArtifactDescriptor = true;

    private boolean ignoreInvalidArtifactDescriptor = true;

    private boolean ignoreTransitiveRepositories;

    private List<Proxy> proxies;

    private List<Server> servers;

    private List<Mirror> mirrors;

    private List<Profile> profiles;

  private transient Map<K, V> delegate;

  @RetainedWith private transient AbstractBiMap<V, K> inverse;

  /** Package-private constructor for creating a map-backed bimap. */
  AbstractBiMap(Map<K, V> forward, Map<V, K> backward) {
    inverse = checkMapsAndMakeInverse(forward, backward);
    delegate = forward;
  }

  /** Private constructor for inverse bimap. */

public class GlobalBuildInfoPlugin implements Plugin<Project> {
    private static final Logger LOGGER = Logging.getLogger(GlobalBuildInfoPlugin.class);
    private static final String DEFAULT_VERSION_JAVA_FILE_PATH = "server/src/main/java/org/elasticsearch/Version.java";
    private static Integer _defaultParallel = null;

    private final JavaInstallationRegistry javaInstallationRegistry;
    private final JvmMetadataDetector metadataDetector;

  private var waitingCoordinatorTask: SerialTask? = null
  private var waitingCoordinatorInterrupted = false
  private var waitingCoordinatorNotified = false

  /** How many times a new task has been started. Guarded by `this`. */
  private var contextSwitchCount = 0

  /** Guarded by `this`. */
  private var activeThreads = 0

  /** A task runner that posts tasks to this fake. Tasks won't be executed until requested. */

  /** A request body that fires events when it completes. */
  private inner class RequestBodySink(
    delegate: Sink,
    /** The exact number of bytes to be written, or -1L if that is unknown. */
    private val contentLength: Long,
    private val isSocket: Boolean,
  ) : ForwardingSink(delegate) {
    private var completed = false
    private var bytesReceived = 0L
    private var invokeStartEvent = isSocket
    private var closed = false

import java.util.List;

public class NetworkInterfaceInfo {
    private int interfaceIndex;
    private int capability;
    private int linkSpeed;  // In units of 1 Mbps
    private byte[] sockaddrStorage;  // Socket address
    private InetAddress address;
    private boolean ipv6;
    private boolean rssCapable;  // Receive Side Scaling
    private boolean rdmaCapable;
    
    // Capability flags

 */
public class CheckWrapper {
    private static final ExecutorService THREAD_POOL = Executors.newCachedThreadPool();

    private static final Pattern ALLOWED_WRAPPER_VERSION =
        Pattern.compile("^[0-9.]+(-(rc|milestone|m)-[0-9]+)?$");

    // Keep the same extraction semantics as the old sed:
    //   sed 's/.*gradle-\(.*\)-[a-z]*\.[a-z]*/\1/'
    private static final Pattern WRAPPER_VERSION_EXTRACT =

    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

  /**
   * @see Predicates#and(Iterable)
   */
  private static final class AndPredicate<T extends @Nullable Object>
      implements Predicate<T>, Serializable {
    private final List<? extends Predicate<? super T>> components;

    private AndPredicate(List<? extends Predicate<? super T>> components) {