file("src/main/scala/Other.scala") << """class Other"""
        file("src/main/scala/Other2.scala") << """class Other2"""

        def person = scalaClassFile("Person.class")
        def house = scalaClassFile("House.class")
        def other = scalaClassFile("Other.class")
        // We need an additional file since if >50% of files is changed everything gets recompiled
        def other2 = scalaClassFile("Other2.class")

import "example.com/other"

func F() {
	dep.G()
	other.H()
}
-- dep/go.mod --
module example.com/dep
-- dep/dep.go --
package dep

func G() {
}
-- other/go.mod --
module example.com/other
-- other/dep.go --
package other

func G() {
}
-- other2/go.mod --
module example.com/other
-- other2/dep.go --
package other

func G() {

        empty.add(other1).add(listener).remove(listener).remove(other1).empty
        empty.add(other1).add(listener).removeAll([listener, listener]).remove(other1).empty
        empty.add(other1).add(other2).add(listener).remove(listener).removeAll([other1, other2]).empty
        empty.add(other1).add(other2).add(listener).removeAll([listener]).removeAll([other1, other2]).empty

        // Add duplicates

        }
        createDir('src/dist') {
            file 'dist1.txt'
            dir2 {
                file 'dist2.txt'
            }
        }
        createDir('others/dist') {
            file 'other1.txt'
            dir2 {
                file 'other2.txt'
            }
        }

        and:
        settingsFile << "rootProject.name='canCreateADistributionWithSrcDistRuntime'"

        and:

        def transformStep2 = new TestTransformStepNode("transformStep2")
        def other1 = new TestNode("other1")
        def other2 = new TestNode("other2")

        dependsOn(task1, [other1])
        dependsOn(other1, [transformStep1])
        dependsOn(transformStep1, [task2, other2])
        dependsOn(other2, [task3])
        dependsOn(task4, [transformStep2])

        when:

        def other2 = new DefaultJavaForkOptions(resolver, fileCollectionFactory, new DefaultJavaDebugOptions())

        when:
        other2.executable = "/foo/bar"

        then:
        options.isCompatibleWith(other1)
        !options.isCompatibleWith(other2)
    }

    def "cannot determine compatibility with jvmArgumentProviders"() {

        buildFile << """
            task otherBuild(type:GradleBuild) {
                dir = 'other'
                tasks = ['resolve']
            }
        """
        createDirs("other", "other/a", "other/b")
        file("other/settings.gradle") << """
            include 'a', 'b'
        """
        file("other/build.gradle") << """
            allprojects { configurations.create('default') }

    @Test
    void canExecuteExternalScriptFromExternalScript() {
        testFile('build.gradle') << ''' apply { from 'other1.gradle' } '''
        testFile('other1.gradle') << ''' apply { from 'other2.gradle' } '''
        testFile('other2.gradle') << ''' task doStuff '''

        inTestDirectory().withTasks('doStuff').run()
    }

    @Test
    void canFetchScriptViaHttp() {

    }

    @Override
    RegularFile someOtherValue() {
        return baseDirectory.file("other1").get()
    }

    @Override
    RegularFile someOtherValue2() {
        return baseDirectory.file("other2").get()
    }

    @Override
    RegularFile someOtherValue3() {
        return baseDirectory.file("other3").get()
    }

    @Override
    PropertyInternal<RegularFile> propertyWithNoValue() {

    }

    @Override
    Directory someOtherValue() {
        return baseDirectory.dir("other1").get()
    }

    @Override
    Directory someOtherValue2() {
        return baseDirectory.dir("other2").get()
    }

    @Override
    Directory someOtherValue3() {
        return baseDirectory.dir("other3").get()
    }

    @Override
    PropertyInternal<Directory> propertyWithNoValue() {