Artifact artifact = createArtifact("artifact", "1.0");

            File file = new File(artifactBasedir, "artifact-1.0.jar");
            assertEquals("dummy", new String(Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8).trim());

            artifactDeployer.deploy(file, artifact, remoteRepository(), localRepository());

            ArtifactRepository remoteRepository = remoteRepository();

                try {
                    Path dest = download.getPath();
                    Files.createDirectories(dest.getParent());
                    Files.copy(remoteFile.toPath(), dest);
                } catch (IOException e) {
                    if (!remoteFile.exists()) {
                        download.setException(new ArtifactNotFoundException(download.getArtifact(), repository));

 *     source-compatible</a> since 4.0)
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
/*
 * The type parameter is <T> rather than <T extends @Nullable> so that we can use T in the
 * doEquivalent and doHash methods to indicate that the parameter cannot be null.
 */
public abstract class Equivalence<T> {
  /** Constructor for use by subclasses. */
  protected Equivalence() {}

  /**

            File remoteFile = new File(remoteRepo.getBasedir(), remoteRepo.pathOf(artifact));

            Files.createDirectories(localFile.toPath().getParent());
            Files.copy(remoteFile.toPath(), localFile.toPath());
        }

        artifact.setResolved(true);
    }

    public void retrieve(
            ArtifactRepository repository,
            File destination,

    }

    @Nonnull
    @Override
    public Path getPomPath() {
        return nonNull(project.getFile(), "pomPath").toPath();
    }

    @Override
    public Path getBasedir() {
        return nonNull(project.getBasedir(), "basedir").toPath();
    }

    @Nonnull
    @Override
    public List<DependencyCoordinate> getDependencies() {

import okio.BufferedSink
import okio.ByteString
import okio.ByteString.Companion.encodeUtf8
import okio.FileSystem
import okio.Path
import okio.Path.Companion.toPath
import okio.buffer
import okio.gzip

/**
 * Downloads the public suffix list from https://publicsuffix.org/list/public_suffix_list.dat and
 * transforms the file into an efficient format used by OkHttp.
 *
 *

        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

        buildFile << """
            tasks.withType(JavaExec) {
                executable = new File(".").getCanonicalFile().toPath().relativize(new File("${executable}").toPath()).toString()
            }
        """

        when:
        executer.expectDocumentedDeprecationWarning("Configuring a Java executable via a relative path. " +

     * @return the tail of the log or a special {@code "<<empty>>"} string if the log is empty
     */
    static String tail(File file, int tailSize) throws IOException {
        try (Stream<String> lines = Files.lines(file.toPath(), StandardCharsets.UTF_8)) {
            EvictingQueue<String> tailLines = lines.collect(Collectors.toCollection(() -> EvictingQueue.create(tailSize)));

    }

    public File getGradleHome() {
        return dir;
    }

    public List<File> getLibDirs() {
        return libDirs;
    }

    public File getSrcDir() {
        return dir.toPath().resolve("src").toFile();
    }

    private static List<File> findLibDirs(File dir) {
        List<File> libDirAndSubdirs = new ArrayList<File>();
        collectWithSubdirectories(new File(dir, "lib"), libDirAndSubdirs);