}

    def "artifact defaults to the dependency name"() {
        when:
        def dep = createDependency("group", "name", "version")
        dep.artifact {
            classifier = 'test'
        }

        then:
        dep.artifacts[0].name == 'name'
        dep.artifacts[0].classifier == 'test'
        dep.artifacts[0].type == 'jar'
    }

    void "can exclude dependencies"() {

        IvyArtifactName dependencyArtifact = null;
        boolean hasClassifier = dep.getClassifier() != null && dep.getClassifier().length() > 0;
        boolean hasNonJarType = dep.getType() != null && !"jar".equals(dep.getType());
        if (hasClassifier || hasNonJarType) {
            String type = "jar";
            if (dep.getType() != null) {
                type = dep.getType();
            }
            String ext = determineExtension(type);

</project>
"""

        when:
        parsePom()

        then:
        def dep = single(metadata.dependencies)
        dep.selector == moduleId('group-b', 'module-b', '1.0')
        dep.scope == MavenScope.Compile
        hasDefaultDependencyArtifact(dep)
        dep.constraint
        !dep.transitive
    }

    def "a bom can combine dependencies and dependencyManagement constraints"() {
        given:

                                    if (dep.type) {
                                        type(dep.type)
                                    }
                                    if (dep.scope) {
                                        scope(dep.scope)
                                    }
                                    if (dep.classifier) {
                                        classifier(dep.classifier)

class GitVersionSelectionIntegrationTest extends AbstractIntegrationSpec {
    @Rule
    BlockingHttpServer httpServer = new BlockingHttpServer()
    @Rule
    GitHttpRepository repo = new GitHttpRepository(httpServer, 'dep', temporaryFolder.getTestDirectory())

    TestFile repoSettingsFile
    def fixture = new ResolveTestFixture(buildFile, "compile")

    def setup() {
        httpServer.start()
        settingsFile << """

	}
	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)

        def dependency = new DefaultMavenDependency("dep-group", "dep-name", "dep-version", null, null, "runtime", [] as Set, false)
        pom.getDependencies().set(pomDependencies(dependency))

        expect:
        with (xml) {
            dependencies.dependency.size() == 1
            with (dependencies[0].dependency[0]) {
                groupId == "dep-group"
                artifactId == "dep-name"
                version == "dep-version"

    }

    /**
     * This test has
     *   - a BOM import which itself imports the junit BOM which manages the dep to 0.1
     *   - a BOM import to the junit BOM which manages the dep to 0.2
     *   - a direct managed dependency to the dep at 0.3 (as suggested by the warning)
     * This results in 0.3 (explicit managed wins) and no warning
     */
    @Test

    @Subject
    def reporter = new DependencyInsightReporter(versionSelectorScheme, versionComparator, versionParser)

    def "sorts dependencies"() {
        def dependencies = [dep("a", "x", "1.0", "2.0"), dep("a", "x", "1.5", "2.0"), dep("b", "a", "5.0"), dep("a", "z", "1.0"), dep("a", "x", "2.0")]

        when:
        def sorted = reporter.convertToRenderableItems(dependencies, false)

        then:
        sorted.size() == 8

        }
    }

    def "writes supplied dependencies"() {
        when:
        def dependency1 = new DefaultIvyDependency('dep-group', 'dep-name-1', 'dep-version', "confMappingProject", true, null, [] as Set, [] as Set)
        def dependency2 = new DefaultIvyDependency('dep-group', 'dep-name-2', 'dep-version', "confMappingProject2", true, null, [] as Set, [] as Set)
        descriptor.dependencies.set([dependency1, dependency2])