});

        copyResource("jquery.min-3.5.1.js", outputDirectory);
        copyResource("flot-0.8.1-min.js", outputDirectory);
        copyResource("flot.selection.min.js", outputDirectory);
        copyResource("style.css", outputDirectory);
        copyResource("report.js", outputDirectory);
        copyResource("performanceGraph.js", outputDirectory);
        copyResource("performanceReport.js", outputDirectory);
    }

        File targetDir = new File(outputDirectory, dirName);
        targetDir.mkdirs();
        copyResource(fileName, new File(targetDir, fileName));
    }

    private void copyResource(String name, File outputFile) {
        try (InputStream in = getClass().getResourceAsStream(name)) {

    def "using a tasks from same project as 'files(#type)' input is allowed"() {
        file("copy1source.txt") << "Copy 1"
        file("copy2source.txt") << "Copy 2"

        buildFile << """
            def copy1 = tasks.register("copy1", Copy) {
                destinationDir = layout.buildDirectory.dir("copy1").get().asFile
                from file("copy1source.txt")
            }

            def copy2 = tasks.register("copy2", Copy) {

        def copyEachFileCalled = false
        def copyNestedEachFileCalled = false

        copySource.createFile("file")
        def copySpec = project.copySpec {
            copySpecRootCalled = true
            delegate.duplicatesStrategy "include"
            from copySource

            from copySource, {
                delegate.duplicatesStrategy "include"
                delegate.eachFile {

		},
		copySource:     false,
		metadata:       nil,
		encryptionType: "",
		err:            crypto.ErrInvalidCustomerKey,
	}, // 2
	{
		headers:        http.Header{xhttp.AmzServerSideEncryption: []string{"AES256"}},
		copySource:     false,
		metadata:       nil,
		encryptionType: encrypt.S3,
		err:            nil,
	}, // 3
	{

		values := f.NamedValues[*name]
		for i, v := range values {
			if v.Op == OpCopy {
				values[i] = v.Args[0]
			}
		}
	}
}

// copySource returns the (non-copy) op which is the
// ultimate source of v.  v must be a copy op.
func copySource(v *Value) *Value {
	w := v.Args[0]

	// This loop is just:
	// for w.Op == OpCopy {
	//     w = w.Args[0]
	// }
	// but we take some extra care to make sure we

    @PathSensitive(PathSensitivity.RELATIVE)
    @InputDirectory
    public File getProjectTemplate() {
        resolveTemplate(projectTemplateName)
    }

    @TaskAction
    void generate() {
        copyResources()
        generateRootProject()
        generateSubprojects()
    }

    void generateRootProject() {
        generateSettings()
        generateGradleProperties()
    }

		header:            h,
		bucket:            bucket,
		object:            object,
		customerKeyHeader: h.Get(xhttp.AmzServerSideEncryptionCustomerKey),
		copySource:        copySource,
		metadata:          cloneMSS(oi.UserDefined),
	}

	if w.copySource {
		w.customerKeyHeader = h.Get(xhttp.AmzServerSideEncryptionCopyCustomerKey)
	}

	if err := w.buildDecrypter(w.parts[w.partIndex].Number); err != nil {

	"github.com/minio/minio-go/v7/pkg/encrypt"
	"github.com/minio/minio/internal/crypto"
	"github.com/minio/minio/internal/hash"
	xhttp "github.com/minio/minio/internal/http"
)

func getDefaultOpts(header http.Header, copySource bool, metadata map[string]string) (opts ObjectOptions, err error) {
	var clientKey [32]byte
	var sse encrypt.ServerSide

	opts = ObjectOptions{UserDefined: metadata}
	if v, ok := header[xhttp.MinIOSourceProxyRequest]; ok {

		fn = func(inputReader io.Reader, h http.Header, cFns ...func()) (r *GetObjectReader, err error) {
			if isEncrypted {
				copySource := h.Get(xhttp.AmzServerSideEncryptionCopyCustomerAlgorithm) != ""
				// Attach decrypter on inputReader
				inputReader, err = DecryptBlocksRequestR(inputReader, h, seqNum, firstPart, oi, copySource)
				if err != nil {
					// Call the cleanup funcs
					for i := len(cFns) - 1; i >= 0; i-- {
						cFns[i]()