}

    def sdkDir(String name) {
        def dir = tmpDir.createDir(name)
        dir.createFile("bin/rc.exe")
        dir.createFile("lib/kernel32.lib")
        return dir
    }

    def kitDir(String name) {
        def dir = tmpDir.createDir(name)
        dir.createFile("bin/x86/rc.exe")
        dir.createFile("lib/win8/um/x86/kernel32.lib")
        return dir
    }

                }
            }
        """

        upstreamSource = file("upstream/src/main/java/Upstream.java") << "class Upstream {}"
        downstreamSource = file("downstream/src/main/java/Downstream.java").createFile() << "class Downstream extends Upstream {}"

        // MacOS builds with Intel machines can be too fast on CI and
        // changes generated during build are picked up only after the build which retriggers the build

            { -> outputsCleaner },
            delegate)
    }

    def "skips when work has empty sources and previous outputs (#description)"() {
        def previousOutputFile = file("output.txt").createFile()
        def outputFileSnapshot = snapshot(previousOutputFile)

        when:
        def result = step.execute(work, context)

        then:
        interaction {

            task taskWithInputs(type: TaskWithInputs) {
                input = ${nonDirectoryInput.value}
                outputFile = file("\${buildDir}/output")
            }
        """

        file('foo').createFile()

        when:
        fails("taskWithInputs")

        then:
        failureDescriptionContains(
            incompatibleAnnotations {
                type('TaskWithInputs').property('input')

        if (caseSensitive == null) {

            String content = generateUniqueContent();
            File file = null;
            try {
                checkJavaIoTmpDirExists();
                file = createFile(content);
                caseSensitive = probeCaseSensitive(file, content);
            } catch (IOException e) {
                throw new RuntimeException(e);
            } finally {

            }
        """
        def headerDir = file('src/main/headers')
        def src1 = file('src/main/cpp/app.cpp').createFile()
        def src2 = file('src/main/cpp/app-impl.cpp').createFile()

        when:
        def project = withConnection { connection -> connection.getModel(CppProject.class) }

        then:
        project.projectIdentifier.projectPath == ':'

    def "adds extension with convention for source layout and base name"() {
        given:
        def src = projectDir.file("src/main/cpp/main.cpp").createFile()
        def publicHeaders = projectDir.file("src/main/public").createDir()

        when:
        project.pluginManager.apply(CppLibraryPlugin)

        then:
        project.library instanceof CppLibrary

    def "adds extension with convention for source layout and module name"() {
        given:
        def src = projectDir.file("src/main/swift/main.swift").createFile()

        when:
        project.pluginManager.apply(SwiftLibraryPlugin)
        project.evaluate()

        then:
        project.library instanceof SwiftLibrary

    @Rule TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def "permissions on file can be read"() {
        def stat = Mock(Stat)
        def f = tmpDir.createFile("f")
        FileTreeElement e = new DefaultFileTreeElement(f, null, Stub(Chmod), stat)

        given:
        stat.getUnixMode(f) >> 0644

        expect:
        e.getPermissions().toUnixNumeric() == 0644

        }
        return prefix;
    }

    public TestFile file(Object... path) {
        return getTestDirectory().file(path);
    }

    public TestFile createFile(Object... path) {
        return file(path).createFile();
    }

    public TestFile createDir(Object... path) {
        return file(path).createDir();
    }