fun fingerprintOf(fileCollection: FileCollectionInternal): HashCode
        fun hashCodeAndTypeOf(file: File): Pair<HashCode, FileType>
        fun hashCodeOf(file: File): HashCode?
        fun hashCodeOfDirectoryContent(file: File): HashCode?
        fun displayNameOf(fileOrDirectory: File): String
        fun instantiateValueSourceOf(obtainedValue: ObtainedValue): ValueSource<Any, ValueSourceParameters>

        override fun hashCodeOf(file: File) =
            fileSystemAccess.read(file.absolutePath).hash

        override fun hashCodeOfDirectoryChildrenNames(file: File): HashCode = directoryChildrenNamesHash(file)

        override fun displayNameOf(file: File): String =
            GFileUtils.relativePathOf(file, rootDirectory)

        problems.assertFailureHasProblems(failure) {
            withProblem("Build file 'inc/sub/build.gradle': line 2: registration of listener on 'Gradle.buildFinished' is unsupported".replace('/', File.separator))
            withProblem("Build file 'inc/sub/build.gradle': line 5: invocation of 'Task.project' at execution time is unsupported.".replace('/', File.separator))

        concurrent.start {
            jarFile1 = defaultGeneratedGradleJarCache.get(CACHE_IDENTIFIER, new Action<File>() {
                @Override
                void execute(File file) {
                    startSecondInvocation.countDown()
                    Thread.sleep(JAR_GENERATION_TIME_MS)
                    touch(file)
                }
            })
        }

        concurrent.start {

    ) : ConfigurationCacheFingerprint()

    data class InputFile(
        val file: File,
        val hash: HashCode
    ) : ConfigurationCacheFingerprint()

    data class DirectoryChildren(
        val file: File,
        val hash: HashCode
    ) : ConfigurationCacheFingerprint()

    data class InputFileSystemEntry(
        val file: File,
        val fileType: FileType
    ) : ConfigurationCacheFingerprint()

                inputFiles.from($fileTree.$pattern)
            }
        """
        def srcDir = createDir('src') {
            file('foo.ok').write('')
            file('foo.fail').write('')
        }
        if (isZip) {
            srcDir.zipTo(file('src.zip'))
        }

        and:
        def configurationCache = newConfigurationCacheFixture()

        when:
        configurationCacheRun 'ok'

import org.gradle.internal.cc.impl.inputs.process.AbstractProcessIntegrationTest
import org.gradle.test.fixtures.file.TestFile
import org.gradle.util.internal.TextUtil

class FilesInTransformIntegrationTest extends AbstractProcessIntegrationTest {
    def setup() {
        inputFile.text = "INPUT FILE CONTENT"
    }

    def "reading a file in transform action with #task does not create a build input"() {
        given:

        def confCacheDir = file("./app/.gradle/configuration-cache")
        confCacheDir.isDirectory()
        def confCacheFiles = confCacheDir.allDescendants().findAll { it != 'configuration-cache.lock' && it != 'gc.properties' }
        confCacheFiles.size() == 5 // header, 2 * fingerprint, root build state file, included build state file

import java.io.File


/**
 * Defines specific configuration inputs that should not be included in the configuration cache fingerprint.
 */
@ServiceScope(Scope.BuildTree::class)
interface IgnoredConfigurationInputs {
    /**
     * Checks if the [file] should be excluded from the configuration inputs fingerprint if it participates
     * in file system checks, such as [File.exists], [File.isFile] etc.
     */

                void apply(Project project) {
                    getClass().classLoader.getResources("file.txt").each { url ->
                        println("resource = " + url.text)
                    }
                }
            }
        """
        file("buildSrc/resources1/file.txt") << "one"
        file("buildSrc/resources2/file.txt") << "two"
        buildFile << """
            apply plugin: SomePlugin
        """