.artifact([name: 'projectB-d', conf: 'd'])
            .dependsOn(organisation: 'ivy.configuration', module: 'projectC', revision: '1.7', conf: 'a->default')
            .dependsOn(organisation: 'ivy.configuration', module: 'projectD', revision: '1.7', conf: 'b->default')
            .dependsOn(organisation: 'ivy.configuration', module: 'projectE', revision: '1.7', conf: 'd->default')

            configurations {
                conf.dependencies.clear()
            }

            dependencies {
                conf 'org.test:dep'
                conf 'org.test:swag:1.0'
                conf(platform('org.test:deps:1.0'))
                conf(platform('org.test:platform:1.0'))
            }
"""
        checkConfiguration("conf")
        resolve.expectDefaultConfiguration("runtime")

            }
            'org.test:moduleB:1.0'()
        }

        when:
        buildFile << """
            configurations.conf {
                attributes { attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 8) }
            }
            dependencies {
                conf 'org.test:moduleA:1.0'
                components {
                    withModule('org.test:moduleA', MissingJdk8VariantRule) { params('runtime') }

        artifacts2[0].name.classifier == null
        artifacts2[0].name.extension == 'zip'
    }


    def dependency(String org, String module, String version, List<String> confs = []) {
        def builder = ImmutableListMultimap.builder()
        confs.each { builder.put(it, it) }
        def dependency = new IvyDependencyDescriptor(newSelector(DefaultModuleIdentifier.newId(org, module), v(version)), builder.build())

	})

	if conf.Clock == nil {
		conf.Clock = clock.RealClock{}
	}
	manager := &managerImpl{
		logger:                           conf.Logger,
		probeManager:                     conf.ProbeManager,
		recorder:                         conf.Recorder,
		nodeRef:                          conf.NodeRef,
		getPods:                          conf.GetPodsFunc,

		klog.V(4).InfoS("Check limits for resolv.conf failed at parse resolv.conf", "err", err)
		return
	}

	domainCountLimit, maxDNSSearchListChars := validation.MaxDNSSearchPaths, validation.MaxDNSSearchListChars

	if c.ClusterDomain != "" {
		domainCountLimit -= 3
	}

	if len(hostSearch) > domainCountLimit {

            println conf.collect { it.name }
            println other.collect { it.name }
        }
    }
}

task res {
    def conf = configurations.conf
    doLast {
        // Should get the unmodified component metadata for 'projectA'
        println conf.collect { it.name }
        assert conf.collect { it.name } == ['projectA-1.0.jar']
    }
}
"""

            'org:testA:2'()
            'org:testA:3'()
            'org:testB:1'()
            'org:testB:2'()
        }
        buildFile << """
            dependencies {
                conf "org:testA:+"
                conf "org:testB:+"
            }
        """

        when:
        repositoryInteractions {
            'org:testA:3' {
                expectResolve()
            }

	}

	// set up typechecker
	var conf Config
	conf.Trace = manual && testing.Verbose()
	conf.Importer = defaultImporter()
	conf.Error = func(err error) {
		if *haltOnError {
			defer panic(err)
		}
		if listErrors {
			t.Error(err)
			return
		}
		errlist = append(errlist, err)
	}

	// apply custom configuration
	for _, opt := range opts {
		opt(&conf)
	}

            }
            configurations {
                conf
            }
            dependencies {
                conf 'org:top:1.0'
            }
            task insight(type: DependencyInsightReportTask) {
                showingAllVariants = false
                dependencySpec = { it.requested.module == 'middle' }
                configuration = configurations.conf
            }
        """

        when: