val konanHome = KotlinNativePaths.homePath
        doTestKotlinStdLibResolve(
            NativePlatforms.unspecifiedNativePlatform,
            konanHome.resolve(konanCommonLibraryPath(KONAN_STDLIB_NAME)).toPath()
        )
    }

import java.io.Serializable;

public class CacheDirTagMarkingStrategy implements MarkingStrategy, Serializable {
    @Override
    public void tryMarkCacheDirectory(File file) {
        CacheDirUtil.tryMarkCacheDirectoryByTag(file.toPath());
    }

            Set<ResolvedComponentResult> seen = new HashSet<>();
            reportComponent(getRootComponent().get(), writer, seen, "");
        }
        try (Stream<String> stream = Files.lines(outputFile.toPath())) {
            stream.forEach(System.out::println);
        }
    }

    private void reportComponent(
        ResolvedComponentResult component,
        PrintWriter writer,

        return logFile
    }

    String getText() throws IOException {
        return logFile.getText(charset.name())
    }

    Stream<String> lines() throws IOException {
        return Files.lines(logFile.toPath(), charset)
    }

    @Override
    String toString() {
        return "DaemonLogFile(${logFile.absolutePath}, charset=${charset.name()})"
    }

                // to delete on exit
            }
        } else if (metadataFile.exists()) {
            try (InputStream input = Files.newInputStream(metadataFile.toPath())) {
                metadata = new Metadata(new MetadataStaxReader().read(input, false));
            }
        }

        boolean changed;

        // If file could not be found or was not valid, start from scratch

import okhttp3.Cache
import okhttp3.Dns
import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.testing.PlatformRule
import okio.Buffer
import okio.ByteString.Companion.decodeHex
import okio.Path.Companion.toPath
import okio.fakefilesystem.FakeFileSystem
import org.junit.jupiter.api.Assertions.fail
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test

        boolean deletedSomething = false
        gradleUserHome.eachFileRecurse(FileType.FILES) { file ->
            if (file.name.startsWith("gradle-launcher")) {
                Files.delete(file.toPath())
                println("Deleting " + file)
                deletedSomething = true
            }
        }
        and:
        result = executer.withTasks("hello").run()
        then:
        deletedSomething

        }
        if (entry.isDirectory) {
            output.mkdirs()
        } else {
            output.parentFile.mkdirs()
            zip.getInputStream(entry).withCloseable { Files.copy(it, output.toPath()) }
        }
// tag::artifact-transform-unzip[]
    }
}
// end::artifact-transform-unzip[]

def usage = Attribute.of('usage', String)
// tag::artifact-transform-registration[]

public abstract class FileBytesValueSource extends FileContentValueSource<byte[]> {

    @Override
    protected byte[] obtainFrom(File file) {
        try {
            return Files.readAllBytes(file.toPath());
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

        }
    }

    private static void moveFile(File sourceFile, File destinationFile) {
        try {
            destinationFile.getParentFile().mkdirs();
            Files.move(sourceFile.toPath(), destinationFile.toPath(), REPLACE_EXISTING);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    private static class StashedFile {
        private final File sourceFile;