"path/filepath"
	"testing"

	"istio.io/istio/pkg/test/util/assert"
)

func copyTest(t *testing.T, copyFn func(srcFilepath, targetDir, targetFilename string) error) {
	t.Helper()
	d := t.TempDir()
	if err := os.WriteFile(filepath.Join(d, "in"), []byte("hello world"), 0o750); err != nil {
		t.Fatal(err)
	}
	if err := copyFn(filepath.Join(d, "in"), d, "out"); err != nil {
		t.Fatal(err)
	}
	f, err := os.Open(filepath.Join(d, "out"))

	return threadCreateProfileInternal(len(p), func(r profilerecord.StackRecord) {
		copy(p[0].Stack0[:], r.Stack)
		p = p[1:]
	})
}

// threadCreateProfileInternal returns the number of records n in the profile.
// If there are less than size records, copyFn is invoked for each record, and
// ok returns true.
func threadCreateProfileInternal(size int, copyFn func(profilerecord.StackRecord)) (n int, ok bool) {

	// make this special case work.

	copy_four, copy_five = four, five
	copy_x               = x
	// copy_y = y // static init of copied strings defeats link -X; see #34675
	copy_nilslice = nilslice
	copy_nilmap   = nilmap
	copy_nilfunc  = nilfunc
	copy_nilchan  = nilchan
	copy_nilptr   = nilptr
)

var copy_a = a
var copy_s = s
var copy_c = c

var copy_aa = aa
var copy_as = as

var copy_sa = sa

package main

import (
	"bytes"
	"fmt"
	"go/format"
	"log"
	"os"
)

// This program generates tests to verify that copying operations
// copy the data they are supposed to and clobber no adjacent values.

// run as `go run copyGen.go`.  A file called copy.go
// will be written into the parent directory containing the tests.

Copyright (C) 2017-2022 Alec Thomas

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

		// In this case, the file is moved by copying and then deleting the source file,
		// although it is less efficient than os.Rename().
		klog.V(4).Infof("cannot rename %v to %v due to %v, attempting an alternative method", src, dest, err)
		if err := CopyFile(src, dest); err != nil {
			return errors.Wrapf(err, "failed to copy file %v to %v", src, dest)
		}
		return os.Remove(src)
	}
	return err

	n, err = CopyN(b, strings.NewReader("foo"), 3) // b has read from
	if n != 3 || err != nil {
		t.Errorf("CopyN(bytes.Buffer, foo, 3) = %d, %v; want 3, nil", n, err)
	}

	n, err = CopyN(b, strings.NewReader("foo"), 4) // b has read from
	if n != 3 || err != EOF {
		t.Errorf("CopyN(bytes.Buffer, foo, 4) = %d, %v; want 3, EOF", n, err)
	}

	n, err = CopyN(b, wantedAndErrReader{}, 5)
	if n != 5 || err != nil {

    // Casts without copying.
    ImmutableMap<C, ImmutableMap<R, V>> columnMap = this.columnMap;
    return ImmutableMap.<C, Map<R, V>>copyOf(columnMap);
  }

  @Override
  public ImmutableMap<R, Map<C, V>> rowMap() {
    // Casts without copying.
    ImmutableMap<R, ImmutableMap<C, V>> rowMap = this.rowMap;
    return ImmutableMap.<R, Map<C, V>>copyOf(rowMap);
  }

  @Override

 */

package org.gradle.api.tasks;

import org.gradle.api.InvalidUserDataException;
import org.gradle.api.internal.file.copy.CopyAction;
import org.gradle.api.internal.file.copy.CopySpecInternal;
import org.gradle.api.internal.file.copy.DestinationRootCopySpec;
import org.gradle.api.internal.file.copy.FileCopyAction;
import org.gradle.work.DisableCachingByDefault;

import java.io.File;

/**

	// ppc64x:-".*memmove"
	copy(x[1:], x[:])
}

func movesmall7() {
	x := [...]byte{1, 2, 3, 4, 5, 6, 7}
	// 386:-".*memmove"
	// amd64:-".*memmove"
	// arm64:-".*memmove"
	// ppc64x:-".*memmove"
	copy(x[1:], x[:])
}

func movesmall16() {
	x := [...]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
	// amd64:-".*memmove"
	// ppc64x:".*memmove"
	copy(x[1:], x[:])
}

var x [256]byte