OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [go.test/] [test/] [copy.go] - Blame information for rev 700

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 700 jeremybenn 
// $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 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.