class LockingInteractionsIntegrationTest extends AbstractHttpDependencyResolutionTest {

    def lockfileFixture = new LockfileFixture(testDirectory: testDirectory)

    def setup() {
        settingsFile << "rootProject.name = 'locking-interactions'"
    }

    def 'locking constraints do not bring back excluded modules'() {
        def foo = mavenRepo.module('org', 'foo', '1.0').publish()

        assertNotNull(result);
        List<Dependency> deps = new ArrayList<>(result.getDependencies().keySet());
        List<Dependency> deps2 = result.getNodes().stream()
                .map(Node::getDependency)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        assertEquals(deps, deps2);
        for (Dependency dep : deps2) {
            dep.getVersion();

import org.gradle.api.internal.tasks.compile.incremental.compilerapi.CompilerApiData;
import org.gradle.api.internal.tasks.compile.incremental.compilerapi.deps.DependentSetSerializer;
import org.gradle.api.internal.tasks.compile.incremental.compilerapi.deps.DependentsSet;
import org.gradle.internal.hash.HashCode;
import org.gradle.internal.serialize.AbstractSerializer;
import org.gradle.internal.serialize.Decoder;

            }

            task resolve {
                doLast {
                    def filesA = configurations.first.incoming.artifactView { lenient = true }.files.files*.name
                    def filesB = configurations.second.incoming.artifactView { lenient = true }.files.files*.name
                    def filesC = configurations.third.incoming.artifactView { lenient = true }.files.files*.name

		Name string
		Href string
		Help string
	}
	var deps []debugEndpoint
	for k, v := range s.debugHandlers {
		deps = append(deps, debugEndpoint{
			Name: k,
			Href: k,
			Help: v,
		})
	}

	sort.Slice(deps, func(i, j int) bool {
		return deps[i].Name < deps[j].Name
	})

	if err := indexTmpl.Execute(w, deps); err != nil {
		istiolog.Errorf("Error in rendering index template %v", err)

	stk.Push("testmain")
	deps := TestMainDeps // cap==len, so safe for append
	if cover != nil && cfg.Experiment.CoverageRedesign {
		deps = append(deps, "internal/coverage/cfile")
	}
	ldDeps, err := LinkerDeps(p)
	if err != nil && pmain.Error == nil {
		pmain.Error = &PackageError{Err: err}
	}
	for _, d := range ldDeps {
		deps = append(deps, d)
	}
	for _, dep := range deps {

        succeeds 'publish'

        then:
        def module = mavenRepo.module('org.gradle.test', 'customizePom', '1.0')
        module.assertPublished()
        module.hasGradleMetadataRedirectionMarker()
        def parsedPom = module.parsedPom
        parsedPom.scope("runtime") {
            assertDependsOn("junit:junit:4.13")
        }
    }

    def "GenerateMavenPom scope attributes methods are deprecated"() {

                    addResolutionAlternatives("anotherConf")
                    extendsFrom(deps)
                }
            }

            repositories { maven { url "${mavenRepo.uri}" } }

            dependencies {
                deps "org:foo:1.0"
            }

            task resolve {
                configurations.testConf.files
            }
        """

    // considering accessing resource only. However, for branches under parallel
    // group, there should not be any control deps between them even side effect
    // analysis indicate some control deps. Therefore, we will mark parallel
    // group and branch information here so that `UpdateControlDependenciesPass`
    // can fetch the related information later.

		s     string
	}{
		// Statement terminators precede regexps.
		{jsCtxRegexp, ";"},
		// This is not airtight.
		//     ({ valueOf: function () { return 1 } } / 2)
		// is valid JavaScript but in practice, devs do not do this.
		// A block followed by a statement starting with a RegExp is
		// much more common:
		//     while (x) {...} /foo/.test(x) || panic()
		{jsCtxRegexp, "}"},