--- /dev/null
+// $G $F.go && $L $F.$A && ./$A.out
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Semi-exhaustive test for copy()
+
+package main
+
+import (
+ "fmt";
+ "os";
+)
+
+const N = 40
+
+var input8 = make([]uint8, N)
+var output8 = make([]uint8, N)
+var input16 = make([]uint16, N)
+var output16 = make([]uint16, N)
+var input32 = make([]uint32, N)
+var output32 = make([]uint32, N)
+var input64 = make([]uint64, N)
+var output64 = make([]uint64, N)
+
+func u8(i int) uint8 {
+ i = 'a' + i%26;
+ return uint8(i);
+}
+
+func u16(ii int) uint16 {
+ var i = uint16(ii);
+ i = 'a' + i%26;
+ i |= i << 8;
+ return i;
+}
+
+func u32(ii int) uint32 {
+ var i = uint32(ii);
+ i = 'a' + i%26;
+ i |= i << 8;
+ i |= i << 16;
+ return i;
+}
+
+func u64(ii int) uint64 {
+ var i = uint64(ii);
+ i = 'a' + i%26;
+ i |= i << 8;
+ i |= i << 16;
+ i |= i << 32;
+ return i;
+}
+
+func reset() {
+ in := 0;
+ out := 13;
+ for i := range input8 {
+ input8[i] = u8(in);
+ output8[i] = u8(out);
+ input16[i] = u16(in);
+ output16[i] = u16(out);
+ input32[i] = u32(in);
+ output32[i] = u32(out);
+ input64[i] = u64(in);
+ output64[i] = u64(out);
+ in++;
+ out++;
+ }
+}
+
+func clamp(n int) int {
+ if n > N {
+ return N
+ }
+ return n;
+}
+
+func doAllSlices(length, in, out int) {
+ reset();
+ copy(output8[out:clamp(out+length)], input8[in:clamp(in+length)]);
+ verify8(length, in, out);
+ copy(output16[out:clamp(out+length)], input16[in:clamp(in+length)]);
+ verify16(length, in, out);
+ copy(output32[out:clamp(out+length)], input32[in:clamp(in+length)]);
+ verify32(length, in, out);
+ copy(output64[out:clamp(out+length)], input64[in:clamp(in+length)]);
+ verify64(length, in, out);
+}
+
+func bad8(state string, i, length, in, out int) {
+ fmt.Printf("%s bad(%d %d %d): %c not %c:\n\t%s\n\t%s\n",
+ state,
+ length, in, out,
+ output8[i],
+ uint8(i+13),
+ input8, output8);
+ os.Exit(1);
+}
+
+func verify8(length, in, out int) {
+ for i := 0; i < out; i++ {
+ if output8[i] != u8(i+13) {
+ bad8("preamble8", i, length, in, out);
+ break;
+ }
+ }
+}
+
+func bad16(state string, i, length, in, out int) {
+ fmt.Printf("%s bad(%d %d %d): %x not %x:\n\t%v\n\t%v\n",
+ state,
+ length, in, out,
+ output16[i],
+ uint16(i+13),
+ input16, output16);
+ os.Exit(1);
+}
+
+func verify16(length, in, out int) {
+ for i := 0; i < out; i++ {
+ if output16[i] != u16(i+13) {
+ bad16("preamble16", i, length, in, out);
+ break;
+ }
+ }
+}
+
+func bad32(state string, i, length, in, out int) {
+ fmt.Printf("%s bad(%d %d %d): %x not %x:\n\t%v\n\t%v\n",
+ state,
+ length, in, out,
+ output32[i],
+ uint32(i+13),
+ input32, output32);
+ os.Exit(1);
+}
+
+func verify32(length, in, out int) {
+ for i := 0; i < out; i++ {
+ if output32[i] != u32(i+13) {
+ bad32("preamble32", i, length, in, out);
+ break;
+ }
+ }
+}
+
+func bad64(state string, i, length, in, out int) {
+ fmt.Printf("%s bad(%d %d %d): %x not %x:\n\t%v\n\t%v\n",
+ state,
+ length, in, out,
+ output64[i],
+ uint64(i+13),
+ input64, output64);
+ os.Exit(1);
+}
+
+func verify64(length, in, out int) {
+ for i := 0; i < out; i++ {
+ if output64[i] != u64(i+13) {
+ bad64("preamble64", i, length, in, out);
+ break;
+ }
+ }
+}
+
+func slice() {
+ for length := 0; length < N; length++ {
+ for in := 0; in <= 32; in++ {
+ for out := 0; out <= 32; out++ {
+ doAllSlices(length, in, out)
+ }
+ }
+ }
+}
+
+// Array test. Can be much simpler. It's mostly checking for promotion of *[N] to []
+func array() {
+ var array [N]uint8;
+ reset();
+ copy(&array, input8);
+ for i := 0; i < N; i++ {
+ output8[i] = 0
+ }
+ copy(output8, &array);
+ verify8(N, 0, 0);
+}
+
+func main() {
+ slice();
+ array();
+}