return delegate.submit(task);
  }

  @Override
  public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
      throws InterruptedException {
    Preconditions.checkNotNull(tasks, "tasks must not be null!");
    return delegate.invokeAll(tasks);
  }

  @Override
  public <T> List<Future<T>> invokeAll(
      Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)

    super.releaseResources(reason);
    /*
     * If the output future is done, then it won't need to interrupt the task later, so it can clear
     * its reference to it.
     *
     * If the output future is *not* done, then the task field will be cleared after the task runs
     * or after the output future is done, whichever comes first.
     */
    if (reason == OUTPUT_FUTURE_DONE) {
      this.task = null;

    super.releaseResources(reason);
    /*
     * If the output future is done, then it won't need to interrupt the task later, so it can clear
     * its reference to it.
     *
     * If the output future is *not* done, then the task field will be cleared after the task runs
     * or after the output future is done, whichever comes first.
     */
    if (reason == OUTPUT_FUTURE_DONE) {
      this.task = null;

    }

    final SettableFuture<V> delegate = SettableFuture.create();

    @Override
    protected Future<V> delegate() {
      return delegate;
    }

    void set(V value) {
      delegate.set(value);
    }
  }

  private static final class RuntimeExceptionThrowingFuture<V> implements Future<V> {
    final CountDownLatch allowGetToComplete = new CountDownLatch(1);

    @Override

import org.gradle.internal.service.ServiceRegistrationProvider

import java.io.Closeable
import java.time.Duration

import java.util.concurrent.ExecutorService
import java.util.concurrent.Future
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicReference


internal
object BuildServices : ServiceRegistrationProvider {

    @Provides

    }
}

dependencies {
    integTestRuntimeOnly(project(":kotlin-dsl-plugins")) {
        because("Tests require 'future-plugin-versions.properties' on the test classpath and the embedded executer needs them available")
        attributes {
            attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named("future-versions-resource"))
        }
    }
    integTestLocalRepository(project(":kotlin-dsl-plugins"))

 * the License.
 */

package com.google.common.util.concurrent.internal;


/**
 * A future that, if it fails, may <i>optionally</i> provide access to the cause of the failure.
 *
 * <p>This class is used only for micro-optimization. Standard {@code Future} utilities benefit from
 * this optimization, so there is no need to specialize methods to return or accept this type

  let summary = "Await a tensor from a !mlrt.future";

  let description = [{
    Await a tensor from a !mlrt.future.

    $future: A value of type !mlrt.future. The underlying value must be a tensorflow tensor.

    $result: a tensorflow tensor.
  }];

  let arguments = (ins
    MlrtFutureType:$future
  );

  let results = (outs
    TF_Tensor:$result
  );
}

   *       return value of this method as its cause
   * </ul>
   */
  public static
      Throwable tryInternalFastPathGetFailure(InternalFutureFailureAccess future) {
    return future.tryInternalFastPathGetFailure();
  }

  private InternalFutures() {}

	// This will also warn about possible future changes on the golang std library
	// xref: https://issues.k8s.io/108074
	ip, err := netip.ParseAddr(address)
	if err != nil {
		return []string{fmt.Sprintf("%s: IP address was accepted, but will be invalid in a future Kubernetes release: %v", fieldPath, err)}
	}
	// A Recommendation for IPv6 Address Text Representation
	//