ListenableFuture<Foo> immediate = immediateFuture(new Foo());
    SettableFuture<Bar> secondary = SettableFuture.create();
    AsyncFunction<Foo, Bar> function = unused -> secondary;
    assertTrue(transformAsync(immediate, function, directExecutor()).cancel(false));
    assertTrue(secondary.isCancelled());
    assertFalse(secondary.wasInterrupted());
  }

   * UncheckedTimeoutException} to the caller.
   *
   * <p>It is important to note that the primary purpose of the proxy object is to return control to
   * the caller when the timeout elapses; aborting the target method call is of secondary concern.
   * The particular nature and strength of the guarantees made by the proxy is
   * implementation-dependent. However, it is important that each of the methods on the target

   * holds the lock. If a hashed slot is empty, and lock is
   * available, a new Cell is created. Otherwise, if the slot
   * exists, a CAS is tried.  Retries proceed by "double hashing",
   * using a secondary hash (Marsaglia XorShift) to try to find a
   * free slot.
   *
   * The table size is capped because, when there are more threads
   * than CPUs, supposing that each thread were bound to a CPU,

    // used as repository for requested parameters
    protected static final String CONTEXT_TEMPDIR_KEY = "javax.servlet.context.tempdir"; // prior
    protected static final String JAVA_IO_TMPDIR_KEY = "java.io.tmpdir"; // secondary

    // ===================================================================================
    //                                                                           Attribute

                        logger.debug("{} finished: exitCode={}", getName(), exitValue);
                    }
                    return exitValue;
                }
            } else {
                // This is a secondary timeout, a safety net.
                logger.warn("{} is unresponsive and could not be terminated within the safety timeout.", getName());
                if (!task.isExecuted()) {
                    task.run();

   * holds the lock. If a hashed slot is empty, and lock is
   * available, a new Cell is created. Otherwise, if the slot
   * exists, a CAS is tried.  Retries proceed by "double hashing",
   * using a secondary hash (Marsaglia XorShift) to try to find a
   * free slot.
   *
   * The table size is capped because, when there are more threads
   * than CPUs, supposing that each thread were bound to a CPU,

     */
    @Nonnull
    Optional<Path> getPath(@Nonnull Project project);

    /**
     * Returns an immutable collection of attached artifacts for the given project.
     * Attached artifacts are secondary artifacts produced during the build (e.g., sources jar,
     * javadoc jar, test jars). These artifacts are created and attached during specific

                f"Approaching GitHub API rate limit, remaining points: {self.remaining_points}, "
                f"reset time in {primary_limit_wait_time} seconds"
            )

        # Handle secondary rate limits
        secondary_limit_wait_time = 0.0
        points_per_minute = POINTS_PER_MINUTE_LIMIT * self.speed_multiplier
        interval = 60 / (points_per_minute / self.last_query_cost)

the Covered Software. If the Larger Work is a combination of Covered
Software with a work governed by one or more Secondary Licenses, and the
Covered Software is not Incompatible With Secondary Licenses, this
License permits You to additionally distribute such Covered Software
under the terms of such Secondary License(s), so that the recipient of
the Larger Work may, at their option, further distribute the Covered

     */
    public static final byte TRANS_TRANSACT_NAMED_PIPE = (byte) 0x26;

    /** Offset to the setup words in the primary request */
    protected int primarySetupOffset;
    /** Offset to the parameters in secondary requests */
    protected int secondaryParameterOffset;
    /** Number of parameter bytes being sent in this request */
    protected int parameterCount;