// and assumes that having "/" as a separator in Windows path is fine. It isn't.
        Path basePath = baseDir.absoluteFile.toPath()
        Path scriptPath = scriptFile.absoluteFile.toPath()

        return basePath.relativize(scriptPath).toString()
    }

    private static class WindowsScript extends ShellScript {
        private WindowsScript(TestFile scriptFile) {

	if dir == "" {
		fmt.Printf("binary contains an empty %s\n", desc)
		return
	}
	containsDir := bytes.Contains(data, []byte(dir))
	containsSlashDir := bytes.Contains(data, []byte(filepath.ToSlash(dir)))
	fmt.Printf("binary contains %s: %v\n", desc, containsDir || containsSlashDir)
}
-- overlay.json --
{ "Replace": { "overlaydir/paths.go": "paths.go" } }
-- go.mod --
module paths

                // use an undeclared input so we can test --refresh-dependencies
                // URL.text is not tracked for now; we'll have to change it once we start to track it
                message.set(file("message").toPath().toUri().toURL().text)
            }
        """
        file("message") << "foo"

        when:
        configurationCacheRun "myTask"

        then:
        outputContains("foo")

    @Nullable
    public static GroovyJarFile parse(File file) {
        try {
            if (file.getName().contains("groovy")) {
                // Resolve a symlink file to the real location
                file = file.toPath().toRealPath().toFile();
            }
        } catch (IOException e) {
            // Let the code use the original File otherwise
        }
        Matcher matcher = FILE_NAME_PATTERN.matcher(file.getName());

                    require(reportDir.mkdirs()) {
                        "Could not create configuration cache report directory '$reportDir'"
                    }
                    Files.move(spoolFile.toPath(), reportFile.toPath())
                }
                return reportFile
            }

            private
            fun reportHash() =
                hashingStream.hash().toCompactString()
        }

            dependencies {
                testImplementation 'junit:junit:4.13'
            }
            test {
                executable = new File(".").getCanonicalFile().toPath().relativize(new File("${executable}").toPath()).toString()
            }
        """
        when:
        executer.expectDocumentedDeprecationWarning("Configuring a Java executable via a relative path. " +

        String parentContent = new String(Files.readAllBytes(parent.toPath()), StandardCharsets.UTF_8);
        parentContent = parentContent.replace(
                "<packaging>pom</packaging>",
                "<packaging>pom</packaging><properties><addedProperty>addedValue</addedProperty></properties>");
        Files.write(parent.toPath(), parentContent.getBytes(StandardCharsets.UTF_8));
        // re-build pom with modified parent

            if (i > 0) {
                pathBuilder.append("/");
            }
            pathBuilder.append(path[i]);
        }
        return new File(baseDirFactory.create(), pathBuilder.toString()).toPath().normalize().toFile();
    }

    @Override
    public File newTemporaryDirectory(String... path) {
        File dir = newTemporaryFile(path);
        forceMkdir(dir);
        return dir;
    }

            metadata.setVersioning(recessive.getVersioning());
        }
    }

    @Deprecated
    @Override
    public MavenMetadata setFile(File file) {
        return new PluginsMetadata(pluginInfo, file.toPath(), timestamp);
    }

    @Override
    public MavenMetadata setPath(Path path) {
        return new PluginsMetadata(pluginInfo, path, timestamp);
    }

    @Override
    public String getGroupId() {

            return FileDeletionResult.withoutException(Files.deleteIfExists(file.toPath()));
        } catch (IOException original) {
            // Let's try again after making it writable, as this is needed on Windows in some cases
            if (file.setWritable(true)) {
                try {
                    return FileDeletionResult.withoutException(Files.deleteIfExists(file.toPath()));
                } catch (IOException ignored) {