a strong {
    color: inherit;
}

img {
    max-width: 100%;
}

table {
    width: 100%;
    font-size: 85%;
    border: 1px solid #e5e5e5;
    border-collapse: collapse;
}

.table-contents {
    overflow-x: auto;
    padding-left: 0.6rem;
    margin-bottom: 1rem;
}

td,
th {
    padding: .25rem .5rem;
    border: 1px solid #e5e5e5;
}

th {
    text-align: left;
}

    private void printFileTree(File dir) {
        def list = []
        if (dir.exists()) {
            dir.eachFileRecurse { file ->
                list << file
            }
        }

        println "Contents of $dir.absolutePath:"
        list.each {
            println it.path
        }
    }

    def "fails when user home directory is used and Gradle has not been run before"() {
        when:

        }
    }

    @Nonnull
    private TestFile fromFile(URL resource) throws URISyntaxException {
        return new TestFile(resource.toURI());
    }

    /**
     * Extracts the contents of the jar file containing the given resource so that an (unzipped) file pointing to the
     * requested resources within the resource jar can be returned.
     *

        '\n'    | 'LF'
    }

    def "does not normalize content for binary files with #description"() {
        def file = file('foo') << contents

        expect:
        !hasher.hashContent(file).isPresent()

        where:
        description               | contents
        "png content"             | content.PNG_CONTENT
        "jpg content"             | content.JPG_CONTENT

            assert !generatedFile.exists()
            assert details.file == generatedFile
            assert generatedFile.text == "contents!"
        }
        1 * generationListener.execute(generatedFile)
        1 * contentWriter.execute(_) >> { OutputStream outputStream ->
            outputStream << "contents!"
        }
        0 * _
    }

    def "visiting does not create file if visitor does not query the file location"() {

        installation == null

        where:
        jarDirectory << ['other', 'other/plugins']
    }

    private void createJarFile(TestFile jar) {
        TestFile contents = tmpDir.createDir('contents')
        TestFile classFile = contents.createFile('org/gradle/MyClass.class')

        ClassNode classNode = new ClassNode()
        classNode.version = Opcodes.V1_6
        classNode.access = Opcodes.ACC_PUBLIC

                    "--destination", new File(bundleDir, "Contents/Frameworks").getAbsolutePath(),
                    "--platform", "macosx",
                    "--resource-destination", new File(bundleDir, "Contents/Resources").getAbsolutePath(),
                    "--scan-folder", new File(bundleDir, "Contents/Frameworks").getAbsolutePath()
                );
            }

        def archive = file("archive.${extension}")
        def contents = file("archiveContents").createDir()
        def ignoredFile = contents.file("ignored.txt")
        ignoredFile << "this file is ignored"
        def nonIgnoredFile = contents.file("not-ignored.txt")
        nonIgnoredFile << "this file is not ignored"
        contents.zipTo(archive)
        buildFile << """
            normalization {

        !result.reusedOutputOriginMetadata.present
        result.executionReasons == ["Output property 'dir' file ${outputDirFile.absolutePath} has changed."]
    }

    def "out of date when any output file has changed contents"() {
        given:
        execute(unitOfWork)

        when:
        outputFile << "new content"
        def result = execute(unitOfWork)
        then:

As input normalization is declared by the task _consuming_ the data as input, different tasks can define different ways to normalize the same data.

When it comes to file inputs, Gradle can normalize the path of the files as well as their contents.

[[relocatability]]
=== Path sensitivity and relocatability

When sharing cached results between computers, it's rare that everyone runs the build from the exact same location on their computers.