clone.setFile(artifact.getFile());

        clone.setAvailableVersions(copyList(artifact.getAvailableVersions()));
        if (artifact.getVersion() != null) {
            clone.setBaseVersion(artifact.getBaseVersion());
        }
        clone.setDependencyFilter(artifact.getDependencyFilter());
        clone.setDependencyTrail(copyList(artifact.getDependencyTrail()));
        clone.setDownloadUrl(artifact.getDownloadUrl());

	for _, n := range l.Nodes {
		n.writeTo(sb)
	}
}

func (l *ListNode) CopyList() *ListNode {
	if l == nil {
		return l
	}
	n := l.tr.newList(l.Pos)
	for _, elem := range l.Nodes {
		n.append(elem.Copy())
	}
	return n
}

func (l *ListNode) Copy() Node {
	return l.CopyList()
}

// TextNode holds plain text.
type TextNode struct {
	NodeType
	Pos

// Copy returns a copy of the [Tree]. Any parsing state is discarded.
func (t *Tree) Copy() *Tree {
	if t == nil {
		return nil
	}
	return &Tree{
		Name:      t.Name,
		ParseName: t.ParseName,
		Root:      t.Root.CopyList(),
		text:      t.text,
	}
}

// Parse returns a map from template name to [Tree], created by parsing the
// templates described in the argument string. The top-level template will be

		// with different top level templates, or clone if necessary.
		dt := e.template(dname)
		if dt == nil {
			dt = template.New(dname)
			dt.Tree = &parse.Tree{Name: dname, Root: t.Root.CopyList()}
			e.derived[dname] = dt
		}
		t = dt
	}
	return e.computeOutCtx(c, t), dname
}

// computeOutCtx takes a template and its start context and computes the output

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.tasks

class CopyTest extends AbstractCopyTaskContractTest {
    private Copy task

    def setup() {
        task = createTask(Copy)
    }

    @Override
    AbstractCopyTask getTask() {
        return task
    }

String, String, String); public static java.util.Map artifactMapByVersion(java.util.Collection); public static java.util.Map artifactMapByArtifac(java.util.Collection); public static Artifact copyArtifact(Artifact); private static java.util.List copyList(java.util.List); } org/apache/maven/artifact/DefaultArtifact.class package org.apache.maven.artifact; public synchronized class DefaultArtifact implements Artifact { private String groupId; private String artifactId; private String baseVersion; private...

String, String, String); public static java.util.Map artifactMapByVersion(java.util.Collection); public static java.util.Map artifactMapByArtifac(java.util.Collection); public static Artifact copyArtifact(Artifact); private static java.util.List copyList(java.util.List); } org/apache/maven/artifact/DefaultArtifact.class package org.apache.maven.artifact; public synchronized class DefaultArtifact implements Artifact { private String groupId; private String artifactId; private String baseVersion; private...

if x%2==x-no-clean...

	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) {
	copyTest(t, AtomicCopy)
}

func TestAtomicWrite(t *testing.T) {
	d := t.TempDir()
	file := filepath.Join(d, "test")
	data := []byte("hello world")
	err := AtomicWrite(file, data, 0o750)

                delegate.duplicatesStrategy "include"
            }
        }

        expect:
        project.copy {
            copyRootCalled = true
            into copyDest
            with copySpec
            from copySource
            from copySource, {
                delegate.duplicatesStrategy "include"
                eachFile {
                    copyNestedEachFileCalled = true