diff options
Diffstat (limited to 'gcc-4.9/gcc/testsuite/go.test/test/copy.go')
| -rw-r--r-- | gcc-4.9/gcc/testsuite/go.test/test/copy.go | 351 |
1 files changed, 351 insertions, 0 deletions
diff --git a/gcc-4.9/gcc/testsuite/go.test/test/copy.go b/gcc-4.9/gcc/testsuite/go.test/test/copy.go new file mode 100644 index 000000000..e6108d905 --- /dev/null +++ b/gcc-4.9/gcc/testsuite/go.test/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() +} |