//new separate compile task (compileIntegTest${language.captalizedName}) depends on class from the extra project
        file("impl/build.gradle") << """
            sourceSets { integTest.${language.name}.srcDir "src/integTest/${language.name}" }
            dependencies { integTestImplementation project(":other") }
            dependencies { integTestImplementation localGroovy() }
        """

        given:
        subproject('a') {
            'build.gradle'("""
                apply plugin: 'java'
                sourceSets {
                    foo {
                        java.srcDir 'src/foo/java'
                    }
                }
                dependencies {
                    fooImplementation project(':b')
                }
            """)
            src {

        given:
        enablePrecompiledPluginsInBuildSrc()
        file("buildSrc/src/main/groovy/plugins/foo.gradle") << """
            sourceSets.main.java.srcDir 'src'
        """

        file("src/Foo.java") << """
            public class Foo { }
        """

        buildFile << """
            plugins {
                id 'java'

            ScalaSourceDirectorySet scalaSource = getScalaSourceDirectorySet(sourceSet);
            sourceSet.getExtensions().add(ScalaSourceDirectorySet.class, "scala", scalaSource);
            scalaSource.srcDir(project.file("src/" + sourceSet.getName() + "/scala"));

            // Explicitly capture only a FileCollection in the lambda below for compatibility with configuration-cache.

When the cgo directives are parsed, any occurrence of the string ${SRCDIR}
will be replaced by the absolute path to the directory containing the source
file. This allows pre-compiled static libraries to be included in the package
directory and linked properly.
For example if package foo is in the directory /go/src/foo:

	// #cgo LDFLAGS: -L${SRCDIR}/libs -lfoo

Will be expanded to:

	// #cgo LDFLAGS: -L/go/src/foo/libs -lfoo

            model {
                components {
                    hello {
                        sources.all {
                            exportedHeaders {
                                srcDir "${safeHeaderDirPath}"
                            }
                        }
                    }
                }
            }
        """

        then:
        args("--info")

        given:
        settingsFile << """
            rootProject.name = 'somelib'
        """
        buildFile << """
            plugins { id 'java' }

            sourceSets.main.java.srcDir("src/common/java")
        """
        file("src/common/java/OtherThing.java") << """
            class OtherThing {
            }
        """
        file("src/main/java/Thing.java") << """

        }

        createDir("b") {
            file("build.gradle") << """
                plugins { id 'java' }
                dependencies { implementation project(":a") }
                sourceSets.main.java.srcDir "other"
            """
            dir("src/main/java") {
                file("Thing.java") << "class Thing {}"
            }
            dir("other") {
                file("Other.java") << "class Other {}"

            apply plugin: 'cpp'
            model {
                repositories {
                    libs(PrebuiltLibraries) {
                        hello {
                            headers.srcDir "libs/src/hello/headers"
                        }
                    }
                }
            }
        """

        when:
        succeeds '--parallel', "visualStudio"

        then:

        buildFile.text = simpleJavaProject()

        def classesDir = 'file("build/classes/moreTests")'
        buildFile << """
            sourceSets {
                moreTests {
                    java.srcDir "src/test"
                    ${destinationDirectoryCode(classesDir)}
                    compileClasspath = compileClasspath + sourceSets.test.compileClasspath