namespace mlir {
namespace tf_executor {
namespace {

// Comparator for `OpsInReverseProgramOrder`.
struct IsAfterInBlock {
  bool operator()(Operation* op, Operation* other_op) const {
    // This function has an average complexity of O(1).
    return other_op->isBeforeInBlock(op);
  }
};

#define GEN_PASS_DEF_EXECUTORUPDATECONTROLDEPENDENCIESPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

        project.repositories {
            mavenCentral()
        }

        when:
        def scalaClasspath = project.scalaRuntime.inferScalaClasspath([new File("other.jar"), new File("other2.jar")])
        scalaClasspath.files

        then:
        GradleException e = thrown()

		ctxt.mainInittasks = ctxt.inittaskSym([]string{fmt.Sprintf("%s..inittask", objabi.PathToPrefix(*flagPluginPath))}, "go:plugin.inittasks")
		// Make symbol local so multiple plugins don't clobber each other's inittask list.
		ctxt.loader.SetAttrLocal(ctxt.mainInittasks, true)
	case BuildModeShared:
		// For a shared library, all packages are roots.
		var roots []string
		for _, lib := range ctxt.Library {

    const OpSetVector& cluster_dependent_ops,
    const mlir::TF::SideEffectAnalysis::Info& side_effect_analysis) {
  auto filter = [&](Operation* other_op) {
    return cluster_ops.contains(other_op) ||
           cluster_dependent_ops.contains(other_op);
  };
  auto other_ops =
      incoming ? side_effect_analysis.DirectControlPredecessors(op, filter)

    String someValue() {
        return "s1"
    }

    @Override
    String someOtherValue() {
        return "other1"
    }

    @Override
    String someOtherValue2() {
        return "other2"
    }

    @Override
    String someOtherValue3() {
        return "other3"
    }

    @Override
    ManagedFactory managedFactory() {
        return new ManagedFactories.ProviderManagedFactory()

	}

	otherPr, err := net.ParsePortRange("200-300")
	if err != nil {
		t.Fatal(err)
	}
	_, err = NewInMemory(*otherPr)
	if err != nil {
		t.Fatal(err)
	}
	if err := r.Restore(*otherPr, dst.Data); err != ErrMismatchedNetwork {
		t.Fatal(err)
	}
	other, err := NewInMemory(*pr2)
	if err != nil {
		t.Fatal(err)
	}
	if err := other.Restore(*pr2, dst.Data); err != nil {

        def suiteTestOps = operations.children(firstLevelTestOps[1], ExecuteTestBuildOperationType)
        assert suiteTestOps.size() == 4
        assert suiteTestOps*.details.testDescriptor.name as Set == ["ok", "fail", "otherFail", "otherOk"] as Set
        assert suiteTestOps*.details.testDescriptor.className as Set == ["org.gradle.Test", "org.gradle.Test", "org.gradle.OtherTest", "org.gradle.OtherTest"] as Set

        def toConfig2 = configuration(toComponent, "to-2")
        fromConfig.hierarchy >> ImmutableSet.of("from")
        fromConfig2.hierarchy >> ImmutableSet.of("other")
        fromConfig3.hierarchy >> ImmutableSet.of("other2")
        toConfig1.visible >> true
        toConfig2.visible >> true
        toComponent.metadata >> toComponentMetadata
        toComponent.getConfigurationNames() >> ["to-1", "to-2"]

        buildFile << """
            task otherBuild(type:GradleBuild) {
                dir = 'other'
                tasks = ['resolve']
            }
        """
        createDirs("other", "other/a", "other/b")
        file("other/settings.gradle") << """
            include 'a', 'b'
        """
        file("other/build.gradle") << """
            allprojects { configurations.create('default') }

        { -> 'spec' }        | ['spec'];
        { -> return 'spec' } | ['spec']
    }

    def 'with Spec'() {
        given:
        def other1 = Stub(CopySpecInternal)
        def other2 = Stub(CopySpecInternal)

        when:
        spec.with other1, other2

        then:
        spec.sourcePaths.empty
        spec.children.size() == 2
    }

    def 'into with Closure'() {
        when: