final CountDownLatch exitLatch = new CountDownLatch(1);
    final TrustedListenableFutureTask<@Nullable Void> task =
        TrustedListenableFutureTask.create(
            new Callable<@Nullable Void>() {
              @Override
              public @Nullable Void call() throws Exception {
                enterLatch.countDown();
                new CountDownLatch(1).await(); // wait forever

    Callable<@Nullable Void> cancelRunnable =
        new Callable<@Nullable Void>() {
          @Override
          public @Nullable Void call() {
            cancellationSuccess.set(currentFuture.get().cancel(true));
            awaitUnchecked(barrier);
            return null;
          }
        };
    Callable<@Nullable Void> setFutureCompleteSuccessfullyRunnable =

    MappedProperty map(String propertyName, Closure<?> value);

    MappedProperty map(String propertyName, Callable<?> value);

    /**
     * Mark a property as ineligible for convention mapping.
     */
    void ineligible(String propertyName);

    @Nullable
    <T> T getConventionValue(@Nullable T actualValue, String propertyName, boolean isExplicitValue);

    interface MappedProperty {
        void cache();

    /**
     * The date of the signature artifact.
     *
     * @see #getDate()
     */
    private Date date;

    private Callable<File> toSignGenerator;

    private Callable<String> classifierGenerator;

    @Nullable
    private Callable<String> nameGenerator;

    /**
     * Creates a signature artifact for the given public artifact.
     *

import org.gradle.api.internal.tasks.TaskDependencyContainer;

import javax.annotation.Nullable;
import java.util.concurrent.Callable;

/**
 * A supplier of a property value.
 */
public interface PropertyValue extends Callable<Object> {
    /**
     * The value of the underlying property.
     */
    @Nullable
    @Override
    Object call();

    /**

   * @throws ExecutionError if {@code callable} throws an {@code Error}
   * @since 28.0
   */
  @CanIgnoreReturnValue
  @ParametricNullness
  default <T extends @Nullable Object> T callWithTimeout(Callable<T> callable, Duration timeout)
      throws TimeoutException, InterruptedException, ExecutionException {
    return callWithTimeout(callable, toNanosSaturated(timeout), TimeUnit.NANOSECONDS);

    }

    @Nonnull
    private static List<ParameterMatchEntry> parameterMatchEntries(CallableInfo callable) {
        Optional<ParameterInfo> varargParameter = callable.getParameters().stream().filter(it -> it.getKind() == ParameterKindInfo.VARARG_METHOD_PARAMETER).findAny();
        CallableKindInfo kind = callable.getKind();
        return Stream.of(
            // Match the `Class<?>` in `receiver` for static methods and constructors

    final CountDownLatch exitLatch = new CountDownLatch(1);
    final TrustedListenableFutureTask<@Nullable Void> task =
        TrustedListenableFutureTask.create(
            new Callable<@Nullable Void>() {
              @Override
              public @Nullable Void call() throws Exception {
                enterLatch.countDown();
                new CountDownLatch(1).await(); // wait forever

    }

    public DefaultTaskDependency(
        @Nullable TaskResolver resolver,
        @Nullable TaskDependencyUsageTracker taskDependencyUsageTracker
    ) {
        this(resolver, ImmutableSet.of(), taskDependencyUsageTracker);
    }

    public DefaultTaskDependency(
        @Nullable TaskResolver resolver,
        ImmutableSet<Object> immutableValues,
        @Nullable TaskDependencyUsageTracker taskDependencyUsageTracker
    ) {

  protected abstract ListeningExecutorService delegate();

  @Override
  public <T extends @Nullable Object> ListenableFuture<T> submit(Callable<T> task) {
    return delegate().submit(task);
  }

  @Override
  public ListenableFuture<?> submit(Runnable task) {
    return delegate().submit(task);
  }

  @Override
  public <T extends @Nullable Object> ListenableFuture<T> submit(
      Runnable task, @ParametricNullness T result) {