summaryrefslogtreecommitdiffstats
path: root/test/copy.go
diff options
context:
space:
mode:
Diffstat (limited to 'test/copy.go')
-rw-r--r--test/copy.go351
1 files changed, 351 insertions, 0 deletions
diff --git a/test/copy.go b/test/copy.go
new file mode 100644
index 0000000..e6108d9
--- /dev/null
+++ b/test/copy.go
@@ -0,0 +1,351 @@
+// run
+
+// 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 the copy predeclared function.
+
+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)
+var inputS string
+var outputS = make([]uint8, N)
+
+type my8 []uint8
+type my16 []uint16
+type my32 []uint32
+type my32b []uint32
+type my64 []uint64
+type myS string
+
+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() {
+ // swap in and out to exercise copy-up and copy-down
+ input8, output8 = output8, input8
+ input16, output16 = output16, input16
+ input32, output32 = output32, input32
+ input64, output64 = output64, input64
+ in := 0
+ out := 13
+ for i := range input8 {
+ input8[i] = u8(in)
+ output8[i] = u8(out)
+ outputS[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++
+ }
+ inputS = string(input8)
+}
+
+func clamp(n int) int {
+ if n > N {
+ return N
+ }
+ return n
+}
+
+func ncopied(length, in, out int) int {
+ n := length
+ if in+n > N {
+ n = N - in
+ }
+ if out+n > N {
+ n = N - out
+ }
+ return n
+}
+
+func doAllSlices(length, in, out int) {
+ reset()
+ n := copy(my8(output8[out:clamp(out+length)]), input8[in:clamp(in+length)])
+ verify8(length, in, out, n)
+ n = copy(my8(outputS[out:clamp(out+length)]), myS(inputS[in:clamp(in+length)]))
+ verifyS(length, in, out, n)
+ n = copy(my16(output16[out:clamp(out+length)]), input16[in:clamp(in+length)])
+ verify16(length, in, out, n)
+ n = copy(my32(output32[out:clamp(out+length)]), my32b(input32[in:clamp(in+length)]))
+ verify32(length, in, out, n)
+ n = copy(my64(output64[out:clamp(out+length)]), input64[in:clamp(in+length)])
+ verify64(length, in, out, n)
+}
+
+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, m int) {
+ n := ncopied(length, in, out)
+ if m != n {
+ fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
+ os.Exit(1)
+ return
+ }
+ // before
+ var i int
+ for i = 0; i < out; i++ {
+ if output8[i] != u8(i+13) {
+ bad8("before8", i, length, in, out)
+ return
+ }
+ }
+ // copied part
+ for ; i < out+n; i++ {
+ if output8[i] != u8(i+in-out) {
+ bad8("copied8", i, length, in, out)
+ return
+ }
+ }
+ // after
+ for ; i < len(output8); i++ {
+ if output8[i] != u8(i+13) {
+ bad8("after8", i, length, in, out)
+ return
+ }
+ }
+}
+
+func badS(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,
+ outputS[i],
+ uint8(i+13),
+ inputS, outputS)
+ os.Exit(1)
+}
+
+func verifyS(length, in, out, m int) {
+ n := ncopied(length, in, out)
+ if m != n {
+ fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
+ os.Exit(1)
+ return
+ }
+ // before
+ var i int
+ for i = 0; i < out; i++ {
+ if outputS[i] != u8(i+13) {
+ badS("beforeS", i, length, in, out)
+ return
+ }
+ }
+ // copied part
+ for ; i < out+n; i++ {
+ if outputS[i] != u8(i+in-out) {
+ badS("copiedS", i, length, in, out)
+ return
+ }
+ }
+ // after
+ for ; i < len(outputS); i++ {
+ if outputS[i] != u8(i+13) {
+ badS("afterS", i, length, in, out)
+ return
+ }
+ }
+}
+
+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, m int) {
+ n := ncopied(length, in, out)
+ if m != n {
+ fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
+ os.Exit(1)
+ return
+ }
+ // before
+ var i int
+ for i = 0; i < out; i++ {
+ if output16[i] != u16(i+13) {
+ bad16("before16", i, length, in, out)
+ return
+ }
+ }
+ // copied part
+ for ; i < out+n; i++ {
+ if output16[i] != u16(i+in-out) {
+ bad16("copied16", i, length, in, out)
+ return
+ }
+ }
+ // after
+ for ; i < len(output16); i++ {
+ if output16[i] != u16(i+13) {
+ bad16("after16", i, length, in, out)
+ return
+ }
+ }
+}
+
+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, m int) {
+ n := ncopied(length, in, out)
+ if m != n {
+ fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
+ os.Exit(1)
+ return
+ }
+ // before
+ var i int
+ for i = 0; i < out; i++ {
+ if output32[i] != u32(i+13) {
+ bad32("before32", i, length, in, out)
+ return
+ }
+ }
+ // copied part
+ for ; i < out+n; i++ {
+ if output32[i] != u32(i+in-out) {
+ bad32("copied32", i, length, in, out)
+ return
+ }
+ }
+ // after
+ for ; i < len(output32); i++ {
+ if output32[i] != u32(i+13) {
+ bad32("after32", i, length, in, out)
+ return
+ }
+ }
+}
+
+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, m int) {
+ n := ncopied(length, in, out)
+ if m != n {
+ fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
+ os.Exit(1)
+ return
+ }
+ // before
+ var i int
+ for i = 0; i < out; i++ {
+ if output64[i] != u64(i+13) {
+ bad64("before64", i, length, in, out)
+ return
+ }
+ }
+ // copied part
+ for ; i < out+n; i++ {
+ if output64[i] != u64(i+in-out) {
+ bad64("copied64", i, length, in, out)
+ return
+ }
+ }
+ // after
+ for ; i < len(output64); i++ {
+ if output64[i] != u64(i+13) {
+ bad64("after64", i, length, in, out)
+ return
+ }
+ }
+}
+
+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 only checking for correct handling of [0:].
+func array() {
+ var array [N]uint8
+ reset()
+ copy(array[0:], input8)
+ for i := 0; i < N; i++ {
+ output8[i] = 0
+ }
+ copy(output8, array[0:])
+ verify8(N, 0, 0, N)
+}
+
+func main() {
+ slice()
+ array()
+}