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

            File backupFile = new File(classBackupDir, classFile.getName() + uniqueIndex.incrementAndGet());
            copy(classFile.toPath(), backupFile.toPath());
            result.getBackupClassFiles().put(classFile.getAbsolutePath(), backupFile.getAbsolutePath());
        }
    }

    private static void copy(Path from, Path to) {
        try {

    private List<String> listAllFiles(File file) {
        return Files.find(file.toPath(), 99, { path, attributes -> attributes.isRegularFile() })
            .collect { file.toPath().relativize(it).toString().replace("\\", "/") }
            .toSorted()
    }

    private boolean hasOnlyDirectories(File file) {
        try (Stream<Path> stream = Files.walk(file.toPath())) {
            return stream.allMatch { Files.isDirectory(it) }
        }

        then:
        conditions.eventually {
            waitingForChangesMessageAppears()
        }

        when:
        changeListeners.broadcastChange(FileWatcherRegistry.Type.MODIFIED, file.toPath())

        then:
        conditions.eventually {
            rebuiltBecauseOfChange()
        }

        cleanup:
        cancellationToken.cancel()
        buildExits(runningBuild)
    }

            }
        });
    }

    private void storeInsideLock(HashCode key, File sourceFile) {
        File targetFile = getCacheEntryFile(key);
        try {
            Files.move(sourceFile.toPath(), targetFile.toPath(), StandardCopyOption.ATOMIC_MOVE);
        } catch (FileAlreadyExistsException ignore) {
            // We already have the file in the build cache

        addSigningProperties()
        createJarTaskOutputFile('jar')

        when:
        Sign signTask = signing.sign(jar).first()

        then:
        def outputPath = jar.outputs.files.singleFile.toPath().toAbsolutePath().toString()
        signTask.signaturesByKey.containsKey(outputPath)
        signTask.signaturesByKey.get(outputPath) == signTask.singleSignature
    }

tasks.register('ensureDirectory') {
    // Store target directory into a variable to avoid project reference in the configuration cache
    def directory = file("images")

    doLast {
        Files.createDirectories(directory.toPath())
    }
}
// end::mkdir-example[]

// tag::move-example[]
tasks.register('moveReports') {
    // Store the build directory into a variable to avoid project reference in the configuration cache

                .run()
        then:
        outputContains(javaHome)
    }

    private static String relativePath(TestFile from, String to) {
        from.toPath().relativize(new File(to).toPath()).toString()
    }

        when:
        File actualJar1 = withConnection { ProjectConnection connection ->
            connection.action(action1).run()
        }
        cl1.close()
        Files.delete(implJar.toPath())

        then:
        actualJar1 != implJar
        actualJar1.name == implJar.name

        when:
        builder.sourceFile('ActionImpl.java').text = """

import okhttp3.survey.types.SuiteId
import okio.FileSystem
import okio.Path.Companion.toPath
import org.conscrypt.Conscrypt

@Suppress("ktlint:standard:property-naming")
suspend fun main() {
  val includeConscrypt = false

  val client =
    OkHttpClient.Builder()
      .cache(Cache(FileSystem.SYSTEM, "build/okhttp_cache".toPath(), 100_000_000))
      .build()

  val sslLabsClients = SslLabsClient(client).clients()