want7 := [7]byte{7, 8, 9, 10, 11, 12, 13}
	if a != want7 {
		t.Errorf("tu7copy got=%v, want %v\n", a, want7)
	}
}
func TestCopy(t *testing.T) {
	testCopy1(t)
	testCopy2(t)
	testCopy3(t)
	testCopy4(t)
	testCopy5(t)
	testCopy6(t)
	testCopy7(t)
	testCopy8(t)
	testCopy9(t)
	testCopy10(t)
	testCopy15(t)
	testCopy16(t)
	testCopy17(t)
	testCopy23(t)
	testCopy24(t)
	testCopy25(t)

		fmt.Fprintf(w, "  }\n")
		fmt.Fprintf(w, "}\n")
	}

	// boilerplate at end
	fmt.Fprintf(w, "func TestCopy(t *testing.T) {\n")
	for _, s := range sizes {
		fmt.Fprintf(w, "  testCopy%d(t)\n", s)
	}
	for _, s := range usizes {
		fmt.Fprintf(w, "  testUnalignedCopy%d(t)\n", s)
	}
	fmt.Fprintf(w, "}\n")

	// gofmt result
	b := w.Bytes()

	s1.Add("world")
	if got := s1.Len(); got != 2 {
		panic(fmt.Sprintf("(%v).Len() == %d, want 2", s1, got))
	}
	if a.Equal(s1, s2) {
		panic(fmt.Sprintf("a.Equal(%v, %v) = true, want false", s1, s2))
	}
}

func TestCopy() {
	s1 := a.Make[float64]()
	s1.Add(0)
	s2 := s1.Copy()
	if !a.Equal(s1, s2) {
		panic(fmt.Sprintf("a.Equal(%v, %v) = false, want true", s1, s2))
	}
	s1.Add(1)
	if a.Equal(s1, s2) {

	}

	// Comparing NaN for equality is expected to fail.
	mf := map[int]float64{1: 0, 2: math.NaN()}
	if a.Equal(mf, mf) {
		panic(fmt.Sprintf("a.Equal(%v, %v) = true, want false", mf, mf))
	}
}

func TestCopy() {
	m2 := a.Copy(m1)
	if !a.Equal(m1, m2) {
		panic(fmt.Sprintf("a.Copy(%v) = %v, want %v", m1, m2, m1))
	}
	m2[16] = 32
	if a.Equal(m1, m2) {
		panic(fmt.Sprintf("a.Equal(%v, %v) = true, want false", m1, m2))

func TestAppend() {
	s := []int{1, 2, 3}
	s = a.Append(s, 4, 5, 6)
	want := []int{1, 2, 3, 4, 5, 6}
	if !a.Equal(s, want) {
		panic(fmt.Sprintf("after a.Append got %v, want %v", s, want))
	}
}

func TestCopy() {
	s1 := []int{1, 2, 3}
	s2 := []int{4, 5}
	if got := a.Copy(s1, s2); got != 2 {
		panic(fmt.Sprintf("a.Copy returned %d, want 2", got))
	}
	want := []int{4, 5, 3}
	if !a.Equal(s1, want) {

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

func TestAtomicWrite(t *testing.T) {
	d := t.TempDir()
	file := filepath.Join(d, "test")

func TestAppend() {
	s := []int{1, 2, 3}
	s = _Append(s, 4, 5, 6)
	want := []int{1, 2, 3, 4, 5, 6}
	if !_Equal(s, want) {
		panic(fmt.Sprintf("after _Append got %v, want %v", s, want))
	}
}

func TestCopy() {
	s1 := []int{1, 2, 3}
	s2 := []int{4, 5}
	if got := _Copy(s1, s2); got != 2 {
		panic(fmt.Sprintf("_Copy returned %d, want 2", got))
	}
	want := []int{4, 5, 3}
	if !_Equal(s1, want) {

	}

	// Comparing NaN for equality is expected to fail.
	mf := map[int]float64{1: 0, 2: math.NaN()}
	if _Equal(mf, mf) {
		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", mf, mf))
	}
}

func TestCopy() {
	m2 := _Copy(m1)
	if !_Equal(m1, m2) {
		panic(fmt.Sprintf("_Copy(%v) = %v, want %v", m1, m2, m1))
	}
	m2[16] = 32
	if _Equal(m1, m2) {
		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", m1, m2))

	if got := s1.Len(); got != 2 {
		panic(fmt.Sprintf("(%v).Len() == %d, want 2", s1, got))
	}
	if _Equal(s1, s2) {
		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", s1, s2))
	}
}

func TestCopy() {
	s1 := _Make[float64]()
	s1.Add(0)
	s2 := s1.Copy()
	if !_Equal(s1, s2) {
		panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s2))
	}
	s1.Add(1)
	if _Equal(s1, s2) {

            def testImplHolder = configurations.create("uasdf")
            def testCopy = configurations.testImplementation.copy()
            configurations.add(testCopy)
            testImplHolder.extendsFrom(testCopy)

            task assertCopyCanBeResolved {
                def resolved = testImplHolder
                doLast {