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 << """

            for line in lines:
                for dep in components:
                    if dep == component:
                        continue
                    if ("k8s.io/" + dep + " =>") not in line:
                        continue
                    print(("\t"+dep))
                    if dep not in all_dependencies[component]:
                        all_dependencies[component].append(dep)
    return all_dependencies

        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"

    }

    @Override
    public void add(Object dep) {
        if (!seen.add(dep)) {
            return;
        }
        if (dep instanceof TaskDependencyContainer) {
            TaskDependencyContainer container = (TaskDependencyContainer) dep;
            container.visitDependencies(this);
        } else {
            delegate.add(dep);
        }
    }

    @Nullable
    @Override

            public class Main {
                Dep dep = null;
            }
        """
        buildTestFixture.withBuildInSubDir()
        depProject = singleProjectBuild("dep") {
            buildFile << """
                allprojects {
                    apply plugin: 'java'
                    group = 'org.test'
                }
            """
            file("src/main/java/Dep.java") << "public class Dep {}"
        }

    }

    /**
     * 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

        checkoutDir("dep", commits["1.0"].id.name, repo.id).assertDoesNotExist()
        checkoutDir("dep", commits["2.0"].id.name, repo.id).assertDoesNotExist()
        checkoutDir("dep", commits["3.0"].id.name, repo.id).assertDoesNotExist()
    }

    private void markUnused(String version) {
        def checkout = checkoutDir("dep", commits[version].id.name, repo.id).parentFile

        String groupId = "org.apache.maven";
        String artifactId = "maven-model";

        Dependency dep = new Dependency();

        dep.setGroupId( groupId );
        dep.setArtifactId( artifactId );
        dep.setVersion( "2.0-alpha-3" );

        Model model = new Model();

        model.addDependency( dep );

        MavenProject project = new MavenProject( model, repositorySystem );

    @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])