if _, err := file.Write(b.Bytes()); err != nil {
				return nil, err
			}
			if copyBuf == nil {
				copyBuf = make([]byte, 32*1024) // same buffer size as io.Copy uses
			}
			// os.File.ReadFrom will allocate its own copy buffer if we let io.Copy use it.
			type writerOnly struct{ io.Writer }
			remainingSize, err := io.CopyBuffer(writerOnly{file}, p, copyBuf)
			if err != nil {
				return nil, err
			}

//
// If src implements [WriterTo],
// the copy is implemented by calling src.WriteTo(dst).
// Otherwise, if dst implements [ReaderFrom],
// the copy is implemented by calling dst.ReadFrom(src).
func Copy(dst Writer, src Reader) (written int64, err error) {
	return copyBuffer(dst, src, nil)
}

// CopyBuffer is identical to Copy except that it stages through the
// provided buffer (if one is required) rather than allocating a

	}
	if size > go122.MaxBatchSize {
		return batch{}, gen, fmt.Errorf("invalid batch size %d, maximum is %d", size, go122.MaxBatchSize)
	}

	// Copy out the batch for later processing.
	var data bytes.Buffer
	data.Grow(int(size))
	n, err := io.CopyN(&data, r, int64(size))
	if n != int64(size) {
		return batch{}, gen, fmt.Errorf("failed to read full batch: read %d but wanted %d", n, size)
	}
	if err != nil {

		f, err := os.CreateTemp("", "net-http-newfilefunc")
		if err != nil {
			return nil, nil, err
		}

		// Write some bytes to the file to enable reading.
		if _, err := io.CopyN(f, rand.Reader, nBytes); err != nil {
			return nil, nil, fmt.Errorf("failed to write data to file: %v", err)
		}
		if _, err := f.Seek(0, 0); err != nil {
			return nil, nil, fmt.Errorf("failed to seek to front: %v", err)

            val t7: Copy = tasks.create("cathedral", Copy::class)
            val t8: Copy = tasks.create<Copy>("cabin")

            val t9: Task = tasks.create("castle") {
                description += "!"
            }
            val t10: Copy = tasks.create("valley", Copy::class) {
                description += "!"
                destinationDir = file("out")
            }
            val t11: Copy = tasks.create<Copy>("hill") {

        buildFile """
            task copy(type: Copy) {
                from "input.txt"
                destinationDir buildDir
            }
        """

        when:
        succeeds "copy"
        then:
        executedAndNotSkipped(":copy")

        file('build/input.txt').makeOlder()

        when:
        succeeds "copy"
        then:
        skipped ":copy"

        buildFile << """

        buildScript '''
            task (copy, type:Copy) {
               from 'files'
               into 'dest'
            }
        '''

        when:
        run 'copy'
        then:
        executedAndNotSkipped(":copy")

        when:
        file("files/sub/empty").createDir()
        run 'copy'
        then:
        executedAndNotSkipped(":copy")

        when:
        run 'copy'

    }
}
// end::copy-task-with-patterns[]

// tag::copy-task-2[]
tasks.register<Copy>("anotherCopyTask") {
    // Copy everything under src/main/webapp
    from("src/main/webapp")
    // Copy a single file
    from("src/staging/index.html")
    // Copy the output of a task
    from(copyTask)
    // Copy the output of a task using Task outputs explicitly.

            details.file.text.contains('DRAFT')
    }
}
// end::copy-task-with-patterns[]

// tag::copy-task-2[]
tasks.register('anotherCopyTask', Copy) {
    // Copy everything under src/main/webapp
    from 'src/main/webapp'
    // Copy a single file
    from 'src/staging/index.html'
    // Copy the output of a task
    from copyTask
    // Copy the output of a task using Task outputs explicitly.

        then:
        property.isFinalized()
    }

    def "can obtain shallow copy of property"() {
        given:
        def property = propertyWithValue(someValue())

        when:
        def copy = property.shallowCopy()

        then:
        copy.orNull == someValue()
    }

    def "shallow copy of property does not follow changes to original"() {
        given: