file("lib/dir1.classes").file("child").createFile()

        when:
        succeeds ":util:resolve", ":app:resolve"

        then:
        output.count("files: [dir1.classes.dir]") == 2

        output.count("Transformed") == 1
        isTransformed("dir1.classes", "dir1.classes.dir")
        def outputDir1 = outputDir("dir1.classes", "dir1.classes.dir").assertIsDir()

		d += e
	}
	return d, e
}

func NoFix32A(divr int32) (int32, int32) {
	var d int32 = 42
	var e int32 = 84
	if divr > 5 {
		// amd64:-"JMP"
		// 386:-"JMP"
		d /= divr
		// amd64:-"JMP"
		// 386:-"JMP"
		e %= divr
		d += e
	}
	return d, e
}

func NoFix32B(divd int32) (int32, int32) {
	var d int32
	var e int32
	var divr int32 = -1

    def "executable is unavailable when not found in path"() {
        def visitor = Mock(DiagnosticsVisitor)
        def dir1 = tmpDir.createDir("some-dir")
        def dir2 = tmpDir.createDir("some-dir-2")

        given:
        os.getExecutableName("cc") >> "cc.bin"
        registry.setPath([dir1, dir2])

        when:
        def result = registry.locate(ToolType.C_COMPILER, "cc")

        then:

        def includedProject2 = Mock(ProjectState)
        includedProject2.projectPath >> Path.ROOT

        def rootDir = temporaryFolder.createDir("root")
        def dir1 = temporaryFolder.createDir("dir1")
        def dir2 = temporaryFolder.createDir("dir2")

        def rootBuild = Mock(GradleInternal)
        def build1 = Mock(GradleInternal)
        def build2 = Mock(GradleInternal)

    def windowsRegistry = Mock(WindowsRegistry)
    def metadataProvider = new DefaultVisualCppMetadataProvider(windowsRegistry)

    def "can derive metadata from registry"() {
        def visualCppDir = tmpDir.createDir("dir1")

        given:
        1 * windowsRegistry.getStringValue(_, _, "14.0") >> visualCppDir

        when:
        VisualCppInstallCandidate metadata = metadataProvider.getVisualCppFromRegistry("14.0")

        !homeDirService.closed
    }

    def "closes and recreates services when home dir is different to last use"() {
        def dir1 = new File("home-dir-1")
        def dir2 = new File("home-dir-2")

        given:
        def servicesBefore = homeDirServices.getServicesFor(dir1)
        def globalService = servicesBefore.get(SomeGlobalService)
        def userHomeDirProvider = servicesBefore.get(GradleUserHomeDirProvider)

            createDir.inputFile = layout.projectDirectory.file("dir1-source.txt")
            createDir.outputDir = layout.buildDirectory.dir("dir1")
            createFile1.inputFile = layout.projectDirectory.file("file1-source.txt")
            createFile1.outputFile = layout.buildDirectory.file("file1.txt")

            buildDir = "output"
"""
        file("dir1-source.txt").text = "dir1"
        file("file1-source.txt").text = "file1"

    def "use highest visual studio version found in the registry"() {
        def dir1 = vsDir("vs1")
        def dir2 = vsDir("vs2")

        given:
        1 * commandLineLocator.getVisualStudioInstalls() >> []
        1 * windowsRegistryLocator.getVisualStudioInstalls() >> { [legacyVsInstall(dir1, "11.0"), legacyVsInstall(dir2, "12.0")] }
        0 * systemPathLocator.getVisualStudioInstalls()

        when:

    final DefaultFlatDirArtifactRepository repository = newRepo()

    def "creates a repository with multiple root directories"() {
        given:
        def dir1 = new File('a')
        def dir2 = new File('b')
        _ * fileCollectionFactory.resolving(['a', 'b']) >> TestFiles.fixed(dir1, dir2)
        _ * repositoryTransport.repository >> resourceRepository

        and:
        repository.dirs('a', 'b')

        when:

            def sourceDirs = objects.sourceDirectorySet('main', 'main files')
            sourceDirs.srcDirs("dir1", "dir2")
            fileCollection.from(sourceDirs.srcDirTrees)
            println("files = \${fileCollection.files.name.sort()}")
        """

        given:
        file("dir1/file1").createFile()
        file("dir1/file2").createFile()
        file("dir2/sub/file3").createFile()

        expect:
        succeeds()