joinUninterruptibly(interruptingThread, 2500, MILLISECONDS);
            Thread.interrupted();
            if (interruptingThread.isAlive()) {
              // This will be hidden by test-output redirection:
              logger.severe("InterruptenatorTask did not exit; future tests may be affected");
              /*
               * This won't do any good under JUnit 3, but I'll leave it around in

     * - Temporarily change this test:
     * --- Comment out assertEquals.
     * --- System.out.println(input + " " + simplifyPath(input));
     * --- fail(). (If the test were to pass, its output would be hidden.)
     * - Run the test.
     * - Pull the relevant lines of output from the test into a testcases file.
     * - Test the output:
     * --- cat testcases | while read L; do
     *       X=($L)

     * - Temporarily change this test:
     * --- Comment out assertEquals.
     * --- System.out.println(input + " " + simplifyPath(input));
     * --- fail(). (If the test were to pass, its output would be hidden.)
     * - Run the test.
     * - Pull the relevant lines of output from the test into a testcases file.
     * - Test the output:
     * --- cat testcases | while read L; do
     *       X=($L)

     *
     * - _shouldn't_ be null, so we don't annotate it with @Nullable
     *
     * - _can_ be null without causing a runtime failure (because we don't want the interesting
     *   details of precondition failure to be hidden by an exception we throw about an unexpectedly
     *   null _failure message_)
     *
     * That combination upsets NullPointerTester, which wants any call that passes null for a

     * @param closingExecutor the object will be closed on this executor
     * @return the first argument
     */
    @CanIgnoreReturnValue
    @ParametricNullness
    // TODO(b/163345357): Widen bound to AutoCloseable once we require API Level 19.
    public <C extends @Nullable Object & @Nullable Closeable> C eventuallyClose(
        @ParametricNullness C closeable, Executor closingExecutor) {

      if (declaringClass.getEnclosingConstructor() != null) {
        // Enclosed in a constructor, needs hidden this
        return true;
      }
      Method enclosingMethod = declaringClass.getEnclosingMethod();
      if (enclosingMethod != null) {
        // Enclosed in a method, if it's not static, must need hidden this.
        return !Modifier.isStatic(enclosingMethod.getModifiers());
      } else {

            joinUninterruptibly(interruptingThread, 2500, MILLISECONDS);
            Thread.interrupted();
            if (interruptingThread.isAlive()) {
              // This will be hidden by test-output redirection:
              logger.severe("InterruptenatorTask did not exit; future tests may be affected");
              /*
               * This won't do any good under JUnit 3, but I'll leave it around in

 * the License.
 */

package com.google.common.util.concurrent;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.J2ktIncompatible;

/**
 * Hidden superclass of {@link Futures} that provides us a place to declare special GWT versions of
 * the {@link Futures#catching(ListenableFuture, Class, com.google.common.base.Function,

 */

package com.google.common.util.concurrent;

import com.google.common.base.Function;
import java.util.concurrent.Executor;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Hidden superclass of {@link FluentFuture} that provides us a place to declare special GWT
 * versions of the {@link FluentFuture#catching(Class, com.google.common.base.Function)

 *       rate when using completely <i>random</i> sample input. The true test of a hash function is
 *       how it performs on representative real-world data, which tends to contain many hidden
 *       patterns and clumps. The goal of a good hash function is to stamp these patterns out as
 *       thoroughly as possible.
 *   <li><b>bit-dispersing:</b> masking out any <i>single bit</i> from a hash code should yield only