static void assertUrlContentContains(URL url, String contents) {
        assert url.text.contains(contents)
    }

    /**
     * Asserts that the content at the specified url matches the content in the provided String
     */
    static void assertUrlContent(URL url, String contents) {
        assert TextUtil.normaliseLineSeparators(url.text) == TextUtil.normaliseLineSeparators(contents)
    }

    /**

        def task2 = Mock(TaskInternal.class)
        def category = DryRunBuildExecutionAction.class.name
        def contents = Mock(QueryableExecutionPlan)

        given:
        startParameter.isDryRun() >> true
        executionPlan.contents >> contents
        contents.tasks >> toList(task1, task2)

        when:
        action.execute(gradle, executionPlan)

        then:

    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()
                );
            }

 * This annotation cannot be used on a {@link java.io.File} object. If you want to refer to the file path,
 * independently of its contents, return a {@link java.lang.String String} instead which returns the absolute
 * path.
 * If, instead, you want to refer to the contents and path of a file or a directory, use
 * {@link org.gradle.api.tasks.InputFile} or {@link org.gradle.api.tasks.InputDirectory} respectively.
 */
@Documented

class LineEndingNormalizingFileSystemLocationSnapshotHasherTest extends Specification {
    @TempDir
    File tempDir

    def "calculates hash for text file with #description"() {
        def file = file('foo') << contents
        def delegate = Mock(LineEndingNormalizingFileSystemLocationSnapshotHasher)
        def hasher = LineEndingNormalizingFileSystemLocationSnapshotHasher.wrap(delegate, LineEndingSensitivity.NORMALIZE_LINE_ENDINGS)