*/

package org.gradle.launcher.daemon

import org.gradle.integtests.fixtures.AvailableJavaHomes
import org.gradle.integtests.fixtures.daemon.DaemonContextParser
import org.gradle.integtests.fixtures.daemon.DaemonIntegrationSpec
import org.gradle.integtests.fixtures.daemon.DaemonLogsAnalyzer
import org.gradle.integtests.fixtures.executer.GradleHandle
import org.gradle.launcher.daemon.context.DaemonContext

def LaunchToDeviceAttributePass : Pass<"tf-launch-to-device-attribute", "mlir::func::FuncOp"> {
  let summary = "Hoists and annotates device launch inner ops with associated device attribute.";

  let description = [{
    This pass hoists a `tf_device.launch` body and assigns a `device` attribute
    to each TensorFlow dialect op in the body based on the `device` attribute on
    the `tf_device.launch`. If a TensorFlow dialect op already has a device

        when:
        withConnection { connection ->
            TestLauncher launcher = connection.newTestLauncher().withTests(descriptor)
            collectOutputs(launcher)
            launcher.run()
        }

        then:
        outputContains("BUILD SUCCESSFUL")
    }

    def "can launch test with test launcher via test filter targeting a specific task"() {
        setup:

}

//===----------------------------------------------------------------------===//
// tf_device.launch
//===----------------------------------------------------------------------===//

// Checks if a tf_device.launch wraps a single operation and the single
// operation results are perfectly forwarded to the launch return.
bool LaunchOp::WrapsSingleOp() { return BlockWrapsSingleOp(&GetBody()); }

    if (&op != device_cluster.GetBody().getTerminator()) {
      op.moveBefore(after_op_r);
    }
  }
}

// Move ops in the tmp host launch op to new host launch op
void MoveTmpLaunchOpToNewLaunchOp(mlir::tf_device::LaunchOp tmp_host_launch_op,
                                  Operation* after_op_host_cluster) {
  for (Operation& op :
       llvm::make_early_inc_range(tmp_host_launch_op.GetBody())) {

    }

    if (!devices.has_value()) return WalkResult::advance();

    // Map aliased devices to explicit devices based on replica.
    if (auto launch = dyn_cast<tf_device::LaunchOp>(op))
      if (auto device_by_replica = devices.value().get(launch.getDevice()))
        launch->setAttr(
            kDeviceAttr,
            device_by_replica.cast<ArrayAttr>()[replica_id].cast<StringAttr>());

    return WalkResult::advance();

static java.util.HashMap instances; private org.codehaus.plexus.classworlds.launcher.Configurator config; public static ConfiguratorAdapter getInstance(org.codehaus.plexus.classworlds.launcher.Configurator, Launcher); public static ConfiguratorAdapter getInstance(org.codehaus.plexus.classworlds.launcher.Configurator, ClassWorld); private void ConfiguratorAdapter(org.codehaus.plexus.classworlds.launcher.Configurator, Launcher); private void ConfiguratorAdapter(org.codehaus.plexus.classworlds.launcher.Configurator,...

    if (IsDeviceClusterOp(*op) && HasChildLaunchDeviceOp(*op)) {
      std::string launch_error =
          absl::StrCat("Node `", op->getName().getStringRef().str(), "` ",
                       "is a launch op which should have been removed by "
                       "outside compilation");

      op->emitError() << launch_error;
      LOG(ERROR) << launch_error;
      return WalkResult::interrupt();
    }

     * If the debugger is not present then the test execution will fail.
     * <p>
     * Invoking this method adjusts the test task to launch only one JVM. More specifically, the parallel execution
     * gets disabled and the {@code forkEvery} property is set to 0.
     *
     * @param port the target port where the test JVM expects the debugger

import org.gradle.launcher.daemon.client.DaemonClientFactory;
import org.gradle.launcher.daemon.client.NotifyDaemonAboutChangedPathsClient;
import org.gradle.launcher.daemon.configuration.DaemonBuildOptions;
import org.gradle.launcher.daemon.configuration.DaemonParameters;
import org.gradle.launcher.daemon.context.DaemonRequestContext;
import org.gradle.launcher.daemon.toolchain.DaemonJvmCriteria;
import org.gradle.launcher.exec.BuildActionExecutor;