}

  @VisibleForTesting
  static long murmurHash64WithSeed(byte[] bytes, int offset, int length, long seed) {
    long mul = K3;
    int topBit = 0x7;

    int lengthAligned = length & ~topBit;
    int lengthRemainder = length & topBit;
    long hash = seed ^ (length * mul);

    for (int i = 0; i < lengthAligned; i += 8) {
      long loaded = load64(bytes, offset + i);

            }
        });
    }

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

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

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

    }

    protected FileOwnerAttributeView parseFileOwnerAttribute(final ResponseData responseData, final File file) {
        try {
            final FileOwnerAttributeView ownerAttrView = Files.getFileAttributeView(file.toPath(), FileOwnerAttributeView.class);
            if (ownerAttrView != null) {
                final UserPrincipal owner = ownerAttrView.getOwner();
                if (owner != null) {

    @Test
    public void canRunTask() throws IOException {
        // Setup the test build
        File projectDir = new File("build/functionalTest");
        Files.createDirectories(projectDir.toPath());
        writeString(new File(projectDir, "settings.gradle"), "");
        writeString(new File(projectDir, "build.gradle"),
            "plugins {" +
                "  id('com.example.plugin.greeting')" +