</dependency>
  </dependencies>
  <build>
    <resources>
      <resource>
        <directory>..</directory>
        <includes>
          <include>LICENSE</include> <!-- copied from the parent pom because I couldn't figure out a way to make combine.children="append" work -->
          <include>proguard/*</include>
        </includes>
        <targetPath>META-INF</targetPath>
      </resource>

			break
		}
		pkg = path.Dir(pkg)
		dst = filepath.Dir(dst)
		src = filepath.Dir(src)
	}
}

// metaPrefixes is the list of metadata file prefixes.
// Vendoring copies metadata files from parents of copied directories.
// Note that this list could be arbitrarily extended, and it is longer
// in other tools (such as godep or dep). By using this limited set of

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package atomic

import "unsafe"

// Int32 is an atomically accessed int32 value.
//
// An Int32 must not be copied.
type Int32 struct {
	noCopy noCopy
	value  int32
}

// Load accesses and returns the value atomically.
//
//go:nosplit
func (i *Int32) Load() int32 {
	return Loadint32(&i.value)
}

        then:
        succeeds("showBuildscript")
        // A jar coming from some file repo is copied into the transformation cache and served from there.
        inArtifactTransformCache("test-1.3-BUILD-SNAPSHOT.jar")
        // A jar coming from remote repo is cached in the global modules cache and served from there.
        // It isn't copied into the transformation cache.

		t.Fatal(err)
	}
	f, err := os.Open(filepath.Join(d, "out"))
	if err != nil {
		t.Fatal(err)
	}
	m, _ := f.Stat()
	// Mode should be copied
	assert.Equal(t, m.Mode(), 0o750)

	body, _ := io.ReadAll(f)
	// Contents should be copied
	assert.Equal(t, body, []byte("hello world"))
}

func TestCopy(t *testing.T) {
	copyTest(t, Copy)
}

func TestAtomicCopy(t *testing.T) {

        outputEventListener.toString().contains("[WARN] [org.gradle.api.internal.file.copy.DuplicateHandlingCopyActionDecorator] file 'path/file1.txt' will be copied to '/root/path/file1.txt', overwriting file 'path/file1.txt', which has already been copied there.")
    }


    def duplicatesWarnByPerFileConfiguration() {
        given:
        files 'path/file1.txt', 'path/file2.txt', 'path/file1.txt'

		}
	}
}

// ClearVariants removes any variants previously added, including those
// copied from a Tag in SetTag.
func (b *Builder) ClearVariants() {
	b.variants = b.variants[:0]
}

// ClearExtensions removes any extensions previously added, including those
// copied from a Tag in SetTag.
func (b *Builder) ClearExtensions() {
	b.private = ""
	b.extensions = b.extensions[:0]
}

	if len(blocks) == 0 {
		return nil, fmt.Errorf("no blocks parsed from annotation %s", groups)
	}
	return blocks, nil
}

// Functions below were copied from
// https://github.com/openshift/library-go/blob/561433066966536ac17f3c9852d7d85f7b7e1e36/pkg/security/uid/uid.go
// Copied here to avoid bringing tons of dependencies
// License is Apache 2.0: https://github.com/openshift/library-go/blob/561433066966536ac17f3c9852d7d85f7b7e1e36/LICENSE

All files from ~/.gradle-bisect-override will be copied to the working directory. Make changes to files under that directory since the script will reset any changes.
This means that all the files we modified before should be copied into this directory.

usage:

```bash
mkdir ~/.gradle-bisect-override

import java.util.Collection;
import java.util.List;

/**
 * This interface is copied and trimmed from org.gradle.api.specs.Spec because older versions of Tooling API have issues with
 * the original due to different versions of classes loaded.
 *
 */
interface Spec<T> {
    boolean isSatisfiedBy(T element);
}

/**
 * This class is copied and trimmed from org.gradle.api.specs.Specs because older versions of Tooling API have issues with