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:

		contents, err := os.ReadFile(absDockerConfigFileLocation)
		if os.IsNotExist(err) {
			continue
		}
		if err != nil {
			klog.V(4).Infof("while trying to read %s: %v", absDockerConfigFileLocation, err)
			continue
		}
		cfg, err := ReadDockerConfigFileFromBytes(contents)
		if err != nil {
			klog.V(4).Infof("couldn't get the config from %q contents: %v", absDockerConfigFileLocation, err)

        '\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

            }
        }
    }
}

tasks.register("zip", Zip) {
    from "archive-contents"
    archiveFileName = "archive.zip"
}

tasks.register("tar", Tar) {
    from "archive-contents"
    archiveFileName = "archive.tar"
}

tasks.register("tarGz", Tar) {
    from "archive-contents"
    archiveFileName = "archive.tar.gz"
    compression = 'gzip'
}

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

    /**

            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"() {

		h[i] = w.contentHash(syms[i])
	}

	tests := []struct {
		a, b  int
		equal bool
	}{
		{0, 1, true},  // same contents, no relocs
		{0, 2, false}, // different contents
		{3, 4, true},  // same contents, same relocs
		{3, 5, true},  // recursively same contents
		{3, 6, false}, // same contents, different relocs
	}
	for _, test := range tests {
		if (h[test.a] == h[test.b]) != test.equal {
			eq := "equal"

        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

./file.txt file contents ./sub/subfile.txt sub file contents...

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