import ${Inject.name}
            import ${TaskAction.name}
            import ${WorkAction.name}
            import ${WorkParameters.name}
            import ${WorkQueue.name}
            import ${WorkerExecutor.name}
            ${snippets.imports}

            public abstract class SneakyAction implements WorkAction<WorkParameters.None> {
                @Inject

        where:
        isolationMode << ISOLATION_MODES
    }

    def "can create and use a work action defined in an external jar in #isolationMode"() {
        def workActionJarName = "workAction.jar"
        withWorkActionClassInExternalJar(file(workActionJarName))

        buildFile << """
            buildscript {
                dependencies {
                    classpath files("$workActionJarName")

                void executeTask() {
                    workerExecutor.processIsolation().submit(NoOpWorkAction) { }
                }
            }

            abstract class NoOpWorkAction implements WorkAction<WorkParameters.None> {
                public void execute() {}
            }
        """

        when:
        succeeds("doWork")

        then:
        nativeDir.exists() == initialized

            import org.gradle.internal.service.scopes.GradleUserHomeScopeServices
            import org.gradle.workers.WorkParameters
            import org.gradle.workers.WorkAction
            import org.gradle.internal.instrumentation.agent.AgentStatus
            import org.gradle.cache.scopes.GlobalScopedCacheBuilderFactory

            abstract class WorkerTask extends DefaultTask {

  // After construction:
  //  For basic block argument source this will be a first operation in the
  //  basic block, and for operations it will be an operation iself.
  //
  // During the union-find cluster formation:
  //  The root member will have the location in the basic block, where the
  //  cluster operation will be inserted. We use the location of the last
  //  operation in the cluster, so that during cluster construction we can

    that the device attribute exists.
  }];

  let constructor = "tensorflow::tf2xla::internal::CreateVerifyClusteringPass()";
}

def TPUClusterFormationPass : Pass<"tf-tpu-cluster-formation", "ModuleOp"> {
  let summary = "Forms clusters from operations assigned to the same TPU computation";

  let description = [{
    TPU computations from the frontend are composed of a `tf.TPUReplicateMetadata`

        (TF_LogicalOrOp
          (TF_GreaterOp
            (TF_SubOp:$fraction $input, (TF_FloorOp:$round_val $input)),
            (TF_ConstOp:$half (GetScalarOfFloatType<"0.5"> $input))
          ),
          (TF_LogicalAndOp
            // If the input is equal to 0.5 ...
            (TF_EqualOp
              $fraction,
              $half,
              /*incompatible_shape_error*/ConstBoolAttrTrue

	// Maximum size of default bucket encryption configuration allowed
	maxBucketSSEConfigSize = 1 * humanize.MiByte

	// diskFillFraction is the fraction of a disk we allow to be filled.
	diskFillFraction = 0.99

	// diskReserveFraction is the fraction of a disk where we will fill other server pools first.
	// If all pools reach this, we will use all pools with regular placement.
	diskReserveFraction = 0.15

    }

    private ProgressEvents.Operation runBuildWithWorkerAction() {
        buildFile << """
            import org.gradle.workers.*
            abstract class MyWorkerAction implements WorkAction<WorkParameters.None>{
                @Override public void execute() {
                    // Do nothing
                }
            }
            task runInWorker {
                doLast {

    private defineGradleWorkAction() {
        """
        interface WorkActionParams extends WorkParameters {
            Property<String> getName()
        }
        abstract class TestWorkAction implements WorkAction<WorkActionParams> {
            public void execute() {
                ${server.callFromBuildUsingExpression('parameters.name.get()')}
            }
        }

        class ParTask extends DefaultTask {