return new RelativeFileNameTransformer(rootDir, currentDirectory);
    }

    public static Transformer<String, File> from(File file) {
        if (file.isFile()) {
            File parentFile = file.getParentFile();
            return new RelativeFileNameTransformer(parentFile, parentFile);
        }
        return new RelativeFileNameTransformer(file, file);
    }

    zipTo(zipFile, fileEntriesRelativeTo(baseDir, files))
}


private
fun fileEntriesRelativeTo(baseDir: File, files: Sequence<File>): Sequence<Pair<String, ByteArray>> =
    files.filter { it.isFile }.map { file ->
        val path = file.normalisedPathRelativeTo(baseDir)
        val bytes = file.readBytes()
        path to bytes
    }


internal
fun File.normalisedPathRelativeTo(baseDir: File) =

      "$prefix/samples/guide/src/main/java/okhttp3/recipes",
      "$prefix/samples/guide/src/main/java/okhttp3/recipes/kt",
    ).map { File(it) }

  return directories.flatMap {
    it.listFiles().orEmpty().filter { f -> f.isFile }.toList()
  }
}

internal class MainTestProvider : SimpleProvider() {
  override fun arguments(): List<Any> {
    val mainFiles = mainFiles()
    return mainFiles.map {

    @TaskAction
    fun action() {
        KotlinExtensionsForGradleApiFacade(
            DefaultClassPath.of(sharedRuntimeClasspath)
        ).use { facade ->
            destinationDirectory.get().asFile.let { outputDir ->
                outputDir.deleteRecursively()
                outputDir.mkdirs()
                GradleJars(classpath.files).run {
                    facade.writeBuiltinPluginIdExtensionsTo(

            final File noImageFile = new File(outputFile.getAbsolutePath() + NOIMAGE_FILE_SUFFIX);
            if (!noImageFile.isFile() || systemHelper.getCurrentTimeAsLong() - noImageFile.lastModified() > noImageExpired) {
                if (noImageFile.isFile() && !noImageFile.delete()) {
                    logger.warn("Failed to delete {}", noImageFile.getAbsolutePath());
                }

     */
    fun sourceFileAndSourceRootFor(sourceFilePath: String): Pair<File, File> =
        sourceRoots.asSequence()
            .map { it.resolve(sourceFilePath) to it }
            .firstOrNull { it.first.isFile }
            ?: throw IllegalStateException("Source file '$sourceFilePath' not found, searched in source roots:\n  - ${sourceRoots.joinToString("\n  - ")}")

    private
    val KtFile.normalizedPath: String?

    }

    private void deletePreviousOutput(StaticLibraryArchiverSpec spec) {
        // Need to delete the previous archive, otherwise stale object files will remain
        if (!spec.getOutputFile().isFile()) {
            return;
        }
        if (!spec.getOutputFile().delete()) {
            throw new GradleException("Create static archive failed: could not delete previous archive");
        }
    }

     */
    public ExtensionDescriptor build(File extensionJar) throws IOException {
        ExtensionDescriptor extensionDescriptor = null;

        if (extensionJar.isFile()) {
            try (JarFile pluginJar = new JarFile(extensionJar, false)) {
                ZipEntry pluginDescriptorEntry = pluginJar.getEntry(getExtensionDescriptorLocation());

     * The manifest if this is a jar file and has a manifest, null otherwise.
     */
    private static Manifest findManifest(File possibleJarFile) throws IOException {
        if (!possibleJarFile.exists() || !possibleJarFile.isFile()) {
            return null;
        }
        JarFile jarFile;
        try {
            jarFile = new JarFile(possibleJarFile);
        } catch (ZipException e) {
            // Not a zip file

            }
        """

        when:
        succeeds TASK_NAME

        then:
        def metadataFile = file("build/$TASK_NAME/$METADATA_FILE_NAME")
        metadataFile.exists() && metadataFile.isFile()
        !GUtil.loadProperties(metadataFile).containsKey(IMPLEMENTATION_CLASSPATH_PROP_KEY)
    }

    def "can reconfigure output directory for metadata file"() {
        given:
        buildFile << """