@TargetGradleVersion(">=4.1")
class KotlinBuildScriptTemplateModelCrossVersionSpec extends AbstractKotlinScriptModelCrossVersionTest {

    def "can load script template using classpath model"() {

        when:
        def model = loadToolingModel(KotlinBuildScriptTemplateModel)

        then:
        loadClassesFrom(
            model.classPath,
            "org.gradle.kotlin.dsl.KotlinBuildScript",

repositories {
	flatDir dirs: file("${repoDir.toURI()}")
}

dependencies {
	${implementationConfiguration} "some:lib:1.0"
}
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject)

        then:
        project.classpath[0].file != null
        project.classpath[0].source == null
        project.classpath[0].javadoc == null
    }

eclipse.project {
    linkedResource name: 'foo', location: '/path/to/foo', type : '2'
    linkedResource name: 'bar', locationUri: 'file://..', type : '3'
}
'''
        when:
        HierarchicalEclipseProject minimalProject = loadToolingModel(HierarchicalEclipseProject)

        then:
        minimalProject.linkedResources.size() == 2

        minimalProject.linkedResources[0].name == 'foo'
        minimalProject.linkedResources[0].type == '2'

project(':impl') {
    task implTask {}
}
"""
        createDirs("api", "impl")
        file('settings.gradle').text = "include 'api', 'impl'; rootProject.name = 'root'"

        when:
        def root = loadToolingModel(EclipseProject)

        then:
        def impl = root.children.find { it.name == 'impl'}

        root.gradleProject.tasks.find { it.name == 'rootTask' && it.path == ':rootTask' && it.project == root.gradleProject }

    apply plugin: 'eclipse'
}
'''
        createDirs("api", "impl")
        file('settings.gradle').text = "include 'api', 'impl'"

        when:
        EclipseProject eclipseProject = loadToolingModel(EclipseProject)

        then:
        def rootTasks = eclipseProject.gradleProject.tasks.collect { it.name }

        EclipseProject api = eclipseProject.children.find { it.name == "api" }

                            lib.sourcePath  = fileReference('$customSourcePath')
                        }
                    }
                }
            }
        """

        when:
        def project = loadToolingModel(EclipseProject)
        def dependency = project.classpath[0]

        then:
        dependency.source == customSource
        dependency.javadoc == customJavadoc
    }

        then:
        containModuleInfo(libs)
    }

    def "eclipse libraries contain gradle module information"() {
        given:
        prepareBuild()

        when:
        EclipseProject project = loadToolingModel(EclipseProject)
        def libs = project.classpath

        then:
        containModuleInfo(libs)
    }

    private void prepareBuild() {
        def fakeRepo = file("repo")

    main {
        java {
            srcDirs = ['src', '../subprojectB/src-sibling', '../src-root', '../src', '../subprojectB/src']
        }
    }
}
"""
        when:
        EclipseProject rootProject = loadToolingModel(EclipseProject)
        EclipseProject subprojectA = rootProject.children.find {EclipseProject project -> project.name == "subprojectA"}
        then:
        subprojectA.linkedResources.size() == 4

        file('build.gradle') << '''
task a {
   description = 'this is task a'
}
task b
task c
'''

        when:
        EclipseProject project = loadToolingModel(EclipseProject)

        then:
        def taskA = project.gradleProject.tasks.find { it.name == 'a' }
        taskA != null
        taskA.path == ':a'
        taskA.description == 'this is task a'

        assertion.validate(stdout.toString(), "stdout")
        assertion.validate(stderr.toString(), "stderr")
        true
    }

    def <T> T loadToolingModel(Class<T> modelClass, @DelegatesTo(ModelBuilder<T>) Closure cl = {}) {
        def result = loadToolingLeanModel(modelClass, cl)
        assertHasConfigureSuccessfulLogging()
        validateOutput()
        return result