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

                    def outputDirectory = outputFile.parentFile
                    println("Transforming \$input in output directory \$outputDirectory")
                    java.nio.file.Files.copy(input.toPath(), outputFile.toPath())
                }
            }

            dependencies {
                implementation 'org.test:buildB:1.2'
                implementation 'org.test:buildC:1.2'

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !purego

package maphash

import (
	"unsafe"
)

//go:linkname runtime_rand runtime.rand
func runtime_rand() uint64

//go:linkname runtime_memhash runtime.memhash
//go:noescape
func runtime_memhash(p unsafe.Pointer, seed, s uintptr) uintptr

            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 {

        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
    }

	handleFile := func(filename string, d fs.DirEntry, err error) error {
		if err != nil {
			t.Error(err)
			return nil
		}
		// don't descend into testdata directories
		if isGoFile(d) && !strings.Contains(filepath.ToSlash(filename), "/testdata/") {
			filenames <- filename
			nfiles++
		}
		return nil
	}

	// test Go files provided via -files, if any
	if *files != "" {

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

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

    public abstract ListProperty<String> getReadmePatterns();

    @TaskAction
    void verifyServiceReadme() throws IOException {
        String readmeContents = new String (Files.readAllBytes(getReadme().getAsFile().get().toPath()));
        for (String requiredSection : getReadmePatterns().get()) {
            Pattern pattern = Pattern.compile(requiredSection, Pattern.MULTILINE);
            if (!pattern.matcher(readmeContents).find()) {

    }

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