],
)

py_strict_test(
    name = "stablehlo_test",
    srcs = ["stablehlo_test.py"],
    python_version = "PY3",
    deps = [
        ":stablehlo",
        #internal proto upb dep
    ],

	}
	depdir := filepath.Join(subdir, "dep")
	if err := os.Mkdir(depdir, 0777); err != nil {
		t.Fatalf("can't create outdir %s: %v", depdir, err)
	}

	// Emit program.
	insrc := filepath.Join("testdata", prog+".go")
	src := filepath.Join(subdir, prog+".go")
	emitFile(t, src, insrc)
	indep := filepath.Join("testdata", "dep.go")
	dep := filepath.Join(depdir, "dep.go")
	emitFile(t, dep, indep)

	AppendOps: "-A",
	DeleteOps: "-D",
}

type IptablesConfigurator struct {
	ruleBuilder *builder.IptablesRuleBuilder
	// TODO(abhide): Fix dep.Dependencies with better interface
	ext dep.Dependencies
	cfg *config.Config
}

func NewIptablesConfigurator(cfg *config.Config, ext dep.Dependencies) *IptablesConfigurator {
	return &IptablesConfigurator{
		ruleBuilder: builder.NewIptablesRuleBuilder(cfg),
		ext:         ext,

	defer h.recomputeMu.Unlock()
	h.mu.Lock()
	defer h.mu.Unlock()
	h.log.Errorf(">>> BEGIN DUMP")
	for k, deps := range h.objectDependencies {
		for _, dep := range deps {
			h.log.Errorf("Dependencies for: %v: %v (%v)", k, dep.collectionName, dep.filter)
		}
	}
	for i, os := range h.collectionState.mappings {
		h.log.Errorf("Input %v -> %v", i, os.UnsortedList())
	}

        1 * repositoryHandler.mavenCentral()
    }

    def "can configure dependencies"() {
        when:
        handler.dependencies {
            add('config', 'dep')
        }

        then:
        1 * depMgmtServices.dependencyHandler >> dependencyHandler
        1 * depMgmtServices.configurationContainer >> configurationContainer

    def "builds graph for finalizer whose dependency was executed in a previous plan"() {
        given:
        Task dep = task("dep")
        Task finalizer1 = task("f1", dependsOn: [dep])
        Task finalizer2 = task("f2", dependsOn: [dep])
        Task finalizer3 = task("f3", dependsOn: [dep])
        Task a = task("a", finalizedBy: [finalizer1])
        Task b = task("b", finalizedBy: [finalizer2])

                    incoming.beforeResolve {
                        dependencies.each { dep ->
                            dep.version {
                                require "2.0"
                            }
                        }
                        dependencyConstraints.each { dep ->
                            dep.version {
                                require "2.0"
                            }

	dep module.Version // disqualified because the module is or requires dep
}

func (dq dqState) isDisqualified() bool {
	return dq != dqState{}
}

func (dq dqState) String() string {
	if dq.err != nil {
		return dq.err.Error()
	}
	if dq.dep != (module.Version{}) {
		return dq.dep.String()
	}
	return "(no conflict)"
}

            task bar(type: EchoTask)
            task dep { dependsOn foo, bar }
        """

        when:
        succeeds "foo", "bar"

        then:
        output.contains "foo: custom message!"
        output.contains "bar: default message!"

        when:
        succeeds "dep"

        then:
        output.contains "foo: custom message!"

        ${setupDependencies()}

        dependencies {
            testingCollector(${expression})
        }

        var dep = testingCollectorConf.dependencies.iterator().next()
        assert(dep ${instanceOf(dsl)} ProjectDependency)
        assert(${cast("dep", "ProjectDependency", dsl)}.dependencyProject == ${expectedProjectExpression})
        """

        expect:
        succeeds("help")