println("exists = " + new File(projectDir, "file2.txt").exists())
            println("exists = " + new File(projectDir, "file3.txt").exists())
        """)

        when:
        file("gradle.properties") << """
            $IGNORE_FS_CHECKS_PROPERTY=file1.txt;file2.txt
        """
        configurationCacheRun()

        then:
        problems.assertResultHasProblems(result) {

            [fromString(), "command.execute(['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],
            [fromGroovyString(), "command.execute(['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],
            [fromStringArray(), "command.execute(['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],
            [fromStringList(), "command.execute(['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],

                inFile = file("in.txt")
                outFile = layout.buildDirectory.file("out.txt")
            }
            task transformer(type: InputTask) {
                inValue = producer.outFile.map { f -> f.asFile.text as Integer }.map { i -> i + 2 }
                outFile = file("out.txt")
            }
        """
        def input = file("in.txt")
        def output = file("out.txt")

        assertTrue(instance.isFileSystemCheckIgnoredFor(File("abc")))
        assertFalse(instance.isFileSystemCheckIgnoredFor(File("abcdef")))
        assertFalse(instance.isFileSystemCheckIgnoredFor(File("123abc")))
        assertFalse(instance.isFileSystemCheckIgnoredFor(File("abc/def")))
        assertFalse(instance.isFileSystemCheckIgnoredFor(File("xyz/abc")))
    }

    @Test

            [fromObjectList(), "ProcessGroovyMethods.execute(command, new String[] {'FOOBAR=foobar'}, file('$pwd'))", pwd, "foobar"],
            [fromString(), "ProcessGroovyMethods.execute(command, ['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],
            [fromGroovyString(), "ProcessGroovyMethods.execute(command, ['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],

        else file

    private
    fun maybeRelativize(file: File): File =
        if (!file.isAbsolute) file else File(GFileUtils.relativePathOf(file, rootDirectory))

    private
    fun wildcardsToRegexPatternString(pathWithWildcards: String): String {
        fun String.runIfNotEmpty(action: String.() -> String): String =
            if (this.isEmpty()) this else action()

    /**
     * A compile operation. It should return a File where classes are compiled to.
     */
    protected abstract File compile(File workspace);

    /**
     * Provides a File where instrumented output will be written to.
     */
    protected abstract File instrumentedOutput(File workspace);

    @Override

                ProcessGroovyMethodsExecute.execute("some string", envpList, project.file("test"));

                ProcessGroovyMethodsExecute.execute(commandArray);
                ProcessGroovyMethodsExecute.execute(commandArray, envpArray, project.file("test"));
                ProcessGroovyMethodsExecute.execute(commandArray, envpList, project.file("test"));

            String getJavaExpression() {
                "new File(\"$directoryPath\").listFiles((File f) -> true)"
            }

            @Override
            String getGroovyExpression() {
                "new File(\"$directoryPath\").listFiles((FileFilter) (File file) -> true)"
            }
        }
    }

    static UndeclaredFileAccess directoryContentWithFilenameFilter(String directoryPath) {

        def classFile = file("build/classes/java/main/Thing.class")
        classFile.isFile()
        def jarFile = file("build/libs/somelib.jar")
        jarFile.isFile()

        when:
        configurationCacheRun "clean"

        then:
        assertStateStored()
        !file("build").exists()

        when:
        configurationCacheRun "assemble"