test/copy.go

   1 // $G $F.go && $L $F.$A && ./$A.out
   2
   3 // Copyright 2009 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 // Semi-exhaustive test for copy()
   8
   9 package main
  10
  11 import (
  12         "fmt"
  13         "os"
  14 )
  15
  16 const N = 40
  17
  18 var input8 = make([]uint8, N)
  19 var output8 = make([]uint8, N)
  20 var input16 = make([]uint16, N)
  21 var output16 = make([]uint16, N)
  22 var input32 = make([]uint32, N)
  23 var output32 = make([]uint32, N)
  24 var input64 = make([]uint64, N)
  25 var output64 = make([]uint64, N)
  26 var inputS string
  27 var outputS = make([]uint8, N)
  28
  29 type my8 []uint8
  30 type my16 []uint16
  31 type my32 []uint32
  32 type my32b []uint32
  33 type my64 []uint64
  34 type myS string
  35
  36 func u8(i int) uint8 {
  37         i = 'a' + i%26
  38         return uint8(i)
  39 }
  40
  41 func u16(ii int) uint16 {
  42         var i = uint16(ii)
  43         i = 'a' + i%26
  44         i |= i << 8
  45         return i
  46 }
  47
  48 func u32(ii int) uint32 {
  49         var i = uint32(ii)
  50         i = 'a' + i%26
  51         i |= i << 8
  52         i |= i << 16
  53         return i
  54 }
  55
  56 func u64(ii int) uint64 {
  57         var i = uint64(ii)
  58         i = 'a' + i%26
  59         i |= i << 8
  60         i |= i << 16
  61         i |= i << 32
  62         return i
  63 }
  64
  65 func reset() {
  66         // swap in and out to exercise copy-up and copy-down
  67         input8, output8 = output8, input8
  68         input16, output16 = output16, input16
  69         input32, output32 = output32, input32
  70         input64, output64 = output64, input64
  71         in := 0
  72         out := 13
  73         for i := range input8 {
  74                 input8[i] = u8(in)
  75                 output8[i] = u8(out)
  76                 outputS[i] = u8(out)
  77                 input16[i] = u16(in)
  78                 output16[i] = u16(out)
  79                 input32[i] = u32(in)
  80                 output32[i] = u32(out)
  81                 input64[i] = u64(in)
  82                 output64[i] = u64(out)
  83                 in++
  84                 out++
  85         }
  86         inputS = string(input8)
  87 }
  88
  89 func clamp(n int) int {
  90         if n > N {
  91                 return N
  92         }
  93         return n
  94 }
  95
  96 func ncopied(length, in, out int) int {
  97         n := length
  98         if in+n > N {
  99                 n = N - in
 100         }
 101         if out+n > N {
 102                 n = N - out
 103         }
 104         return n
 105 }
 106
 107 func doAllSlices(length, in, out int) {
 108         reset()
 109         n := copy(my8(output8[out:clamp(out+length)]), input8[in:clamp(in+length)])
 110         verify8(length, in, out, n)
 111         n = copy(my8(outputS[out:clamp(out+length)]), myS(inputS[in:clamp(in+length)]))
 112         verifyS(length, in, out, n)
 113         n = copy(my16(output16[out:clamp(out+length)]), input16[in:clamp(in+length)])
 114         verify16(length, in, out, n)
 115         n = copy(my32(output32[out:clamp(out+length)]), my32b(input32[in:clamp(in+length)]))
 116         verify32(length, in, out, n)
 117         n = copy(my64(output64[out:clamp(out+length)]), input64[in:clamp(in+length)])
 118         verify64(length, in, out, n)
 119 }
 120
 121 func bad8(state string, i, length, in, out int) {
 122         fmt.Printf("%s bad(%d %d %d): %c not %c:\n\t%s\n\t%s\n",
 123                 state,
 124                 length, in, out,
 125                 output8[i],
 126                 uint8(i+13),
 127                 input8, output8)
 128         os.Exit(1)
 129 }
 130
 131 func verify8(length, in, out, m int) {
 132         n := ncopied(length, in, out)
 133         if m != n {
 134                 fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
 135                 return
 136         }
 137         // before
 138         var i int
 139         for i = 0; i < out; i++ {
 140                 if output8[i] != u8(i+13) {
 141                         bad8("before8", i, length, in, out)
 142                         return
 143                 }
 144         }
 145         // copied part
 146         for ; i < out+n; i++ {
 147                 if output8[i] != u8(i+in-out) {
 148                         bad8("copied8", i, length, in, out)
 149                         return
 150                 }
 151         }
 152         // after
 153         for ; i < len(output8); i++ {
 154                 if output8[i] != u8(i+13) {
 155                         bad8("after8", i, length, in, out)
 156                         return
 157                 }
 158         }
 159 }
 160
 161 func badS(state string, i, length, in, out int) {
 162         fmt.Printf("%s bad(%d %d %d): %c not %c:\n\t%s\n\t%s\n",
 163                 state,
 164                 length, in, out,
 165                 outputS[i],
 166                 uint8(i+13),
 167                 inputS, outputS)
 168         os.Exit(1)
 169 }
 170
 171 func verifyS(length, in, out, m int) {
 172         n := ncopied(length, in, out)
 173         if m != n {
 174                 fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
 175                 return
 176         }
 177         // before
 178         var i int
 179         for i = 0; i < out; i++ {
 180                 if outputS[i] != u8(i+13) {
 181                         badS("beforeS", i, length, in, out)
 182                         return
 183                 }
 184         }
 185         // copied part
 186         for ; i < out+n; i++ {
 187                 if outputS[i] != u8(i+in-out) {
 188                         badS("copiedS", i, length, in, out)
 189                         return
 190                 }
 191         }
 192         // after
 193         for ; i < len(outputS); i++ {
 194                 if outputS[i] != u8(i+13) {
 195                         badS("afterS", i, length, in, out)
 196                         return
 197                 }
 198         }
 199 }
 200
 201 func bad16(state string, i, length, in, out int) {
 202         fmt.Printf("%s bad(%d %d %d): %x not %x:\n\t%v\n\t%v\n",
 203                 state,
 204                 length, in, out,
 205                 output16[i],
 206                 uint16(i+13),
 207                 input16, output16)
 208         os.Exit(1)
 209 }
 210
 211 func verify16(length, in, out, m int) {
 212         n := ncopied(length, in, out)
 213         if m != n {
 214                 fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
 215                 return
 216         }
 217         // before
 218         var i int
 219         for i = 0; i < out; i++ {
 220                 if output16[i] != u16(i+13) {
 221                         bad16("before16", i, length, in, out)
 222                         return
 223                 }
 224         }
 225         // copied part
 226         for ; i < out+n; i++ {
 227                 if output16[i] != u16(i+in-out) {
 228                         bad16("copied16", i, length, in, out)
 229                         return
 230                 }
 231         }
 232         // after
 233         for ; i < len(output16); i++ {
 234                 if output16[i] != u16(i+13) {
 235                         bad16("after16", i, length, in, out)
 236                         return
 237                 }
 238         }
 239 }
 240
 241 func bad32(state string, i, length, in, out int) {
 242         fmt.Printf("%s bad(%d %d %d): %x not %x:\n\t%v\n\t%v\n",
 243                 state,
 244                 length, in, out,
 245                 output32[i],
 246                 uint32(i+13),
 247                 input32, output32)
 248         os.Exit(1)
 249 }
 250
 251 func verify32(length, in, out, m int) {
 252         n := ncopied(length, in, out)
 253         if m != n {
 254                 fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
 255                 return
 256         }
 257         // before
 258         var i int
 259         for i = 0; i < out; i++ {
 260                 if output32[i] != u32(i+13) {
 261                         bad32("before32", i, length, in, out)
 262                         return
 263                 }
 264         }
 265         // copied part
 266         for ; i < out+n; i++ {
 267                 if output32[i] != u32(i+in-out) {
 268                         bad32("copied32", i, length, in, out)
 269                         return
 270                 }
 271         }
 272         // after
 273         for ; i < len(output32); i++ {
 274                 if output32[i] != u32(i+13) {
 275                         bad32("after32", i, length, in, out)
 276                         return
 277                 }
 278         }
 279 }
 280
 281 func bad64(state string, i, length, in, out int) {
 282         fmt.Printf("%s bad(%d %d %d): %x not %x:\n\t%v\n\t%v\n",
 283                 state,
 284                 length, in, out,
 285                 output64[i],
 286                 uint64(i+13),
 287                 input64, output64)
 288         os.Exit(1)
 289 }
 290
 291 func verify64(length, in, out, m int) {
 292         n := ncopied(length, in, out)
 293         if m != n {
 294                 fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n)
 295                 return
 296         }
 297         // before
 298         var i int
 299         for i = 0; i < out; i++ {
 300                 if output64[i] != u64(i+13) {
 301                         bad64("before64", i, length, in, out)
 302                         return
 303                 }
 304         }
 305         // copied part
 306         for ; i < out+n; i++ {
 307                 if output64[i] != u64(i+in-out) {
 308                         bad64("copied64", i, length, in, out)
 309                         return
 310                 }
 311         }
 312         // after
 313         for ; i < len(output64); i++ {
 314                 if output64[i] != u64(i+13) {
 315                         bad64("after64", i, length, in, out)
 316                         return
 317                 }
 318         }
 319 }
 320
 321 func slice() {
 322         for length := 0; length < N; length++ {
 323                 for in := 0; in <= 32; in++ {
 324                         for out := 0; out <= 32; out++ {
 325                                 doAllSlices(length, in, out)
 326                         }
 327                 }
 328         }
 329 }
 330
 331 // Array test. Can be much simpler. It's only checking for correct handling of [0:].
 332 func array() {
 333         var array [N]uint8
 334         reset()
 335         copy(array[0:], input8)
 336         for i := 0; i < N; i++ {
 337                 output8[i] = 0
 338         }
 339         copy(output8, array[0:])
 340         verify8(N, 0, 0, N)
 341 }
 342
 343 func main() {
 344         slice()
 345         array()
 346 }