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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [strconv/] [atoi_test.go] - Blame information for rev 747

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 747 jeremybenn
// Copyright 2009 The Go Authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style
3
// license that can be found in the LICENSE file.
4
 
5
package strconv_test
6
 
7
import (
8
        "reflect"
9
        . "strconv"
10
        "testing"
11
)
12
 
13
type atoui64Test struct {
14
        in  string
15
        out uint64
16
        err error
17
}
18
 
19
var atoui64tests = []atoui64Test{
20
        {"", 0, ErrSyntax},
21
        {"0", 0, nil},
22
        {"1", 1, nil},
23
        {"12345", 12345, nil},
24
        {"012345", 12345, nil},
25
        {"12345x", 0, ErrSyntax},
26
        {"98765432100", 98765432100, nil},
27
        {"18446744073709551615", 1<<64 - 1, nil},
28
        {"18446744073709551616", 1<<64 - 1, ErrRange},
29
        {"18446744073709551620", 1<<64 - 1, ErrRange},
30
}
31
 
32
var btoui64tests = []atoui64Test{
33
        {"", 0, ErrSyntax},
34
        {"0", 0, nil},
35
        {"1", 1, nil},
36
        {"12345", 12345, nil},
37
        {"012345", 012345, nil},
38
        {"0x12345", 0x12345, nil},
39
        {"0X12345", 0x12345, nil},
40
        {"12345x", 0, ErrSyntax},
41
        {"98765432100", 98765432100, nil},
42
        {"18446744073709551615", 1<<64 - 1, nil},
43
        {"18446744073709551616", 1<<64 - 1, ErrRange},
44
        {"18446744073709551620", 1<<64 - 1, ErrRange},
45
        {"0xFFFFFFFFFFFFFFFF", 1<<64 - 1, nil},
46
        {"0x10000000000000000", 1<<64 - 1, ErrRange},
47
        {"01777777777777777777777", 1<<64 - 1, nil},
48
        {"01777777777777777777778", 0, ErrSyntax},
49
        {"02000000000000000000000", 1<<64 - 1, ErrRange},
50
        {"0200000000000000000000", 1 << 61, nil},
51
}
52
 
53
type atoi64Test struct {
54
        in  string
55
        out int64
56
        err error
57
}
58
 
59
var atoi64tests = []atoi64Test{
60
        {"", 0, ErrSyntax},
61
        {"0", 0, nil},
62
        {"-0", 0, nil},
63
        {"1", 1, nil},
64
        {"-1", -1, nil},
65
        {"12345", 12345, nil},
66
        {"-12345", -12345, nil},
67
        {"012345", 12345, nil},
68
        {"-012345", -12345, nil},
69
        {"98765432100", 98765432100, nil},
70
        {"-98765432100", -98765432100, nil},
71
        {"9223372036854775807", 1<<63 - 1, nil},
72
        {"-9223372036854775807", -(1<<63 - 1), nil},
73
        {"9223372036854775808", 1<<63 - 1, ErrRange},
74
        {"-9223372036854775808", -1 << 63, nil},
75
        {"9223372036854775809", 1<<63 - 1, ErrRange},
76
        {"-9223372036854775809", -1 << 63, ErrRange},
77
}
78
 
79
var btoi64tests = []atoi64Test{
80
        {"", 0, ErrSyntax},
81
        {"0", 0, nil},
82
        {"-0", 0, nil},
83
        {"1", 1, nil},
84
        {"-1", -1, nil},
85
        {"12345", 12345, nil},
86
        {"-12345", -12345, nil},
87
        {"012345", 012345, nil},
88
        {"-012345", -012345, nil},
89
        {"0x12345", 0x12345, nil},
90
        {"-0X12345", -0x12345, nil},
91
        {"12345x", 0, ErrSyntax},
92
        {"-12345x", 0, ErrSyntax},
93
        {"98765432100", 98765432100, nil},
94
        {"-98765432100", -98765432100, nil},
95
        {"9223372036854775807", 1<<63 - 1, nil},
96
        {"-9223372036854775807", -(1<<63 - 1), nil},
97
        {"9223372036854775808", 1<<63 - 1, ErrRange},
98
        {"-9223372036854775808", -1 << 63, nil},
99
        {"9223372036854775809", 1<<63 - 1, ErrRange},
100
        {"-9223372036854775809", -1 << 63, ErrRange},
101
}
102
 
103
type atoui32Test struct {
104
        in  string
105
        out uint32
106
        err error
107
}
108
 
109
var atoui32tests = []atoui32Test{
110
        {"", 0, ErrSyntax},
111
        {"0", 0, nil},
112
        {"1", 1, nil},
113
        {"12345", 12345, nil},
114
        {"012345", 12345, nil},
115
        {"12345x", 0, ErrSyntax},
116
        {"987654321", 987654321, nil},
117
        {"4294967295", 1<<32 - 1, nil},
118
        {"4294967296", 1<<32 - 1, ErrRange},
119
}
120
 
121
type atoi32Test struct {
122
        in  string
123
        out int32
124
        err error
125
}
126
 
127
var atoi32tests = []atoi32Test{
128
        {"", 0, ErrSyntax},
129
        {"0", 0, nil},
130
        {"-0", 0, nil},
131
        {"1", 1, nil},
132
        {"-1", -1, nil},
133
        {"12345", 12345, nil},
134
        {"-12345", -12345, nil},
135
        {"012345", 12345, nil},
136
        {"-012345", -12345, nil},
137
        {"12345x", 0, ErrSyntax},
138
        {"-12345x", 0, ErrSyntax},
139
        {"987654321", 987654321, nil},
140
        {"-987654321", -987654321, nil},
141
        {"2147483647", 1<<31 - 1, nil},
142
        {"-2147483647", -(1<<31 - 1), nil},
143
        {"2147483648", 1<<31 - 1, ErrRange},
144
        {"-2147483648", -1 << 31, nil},
145
        {"2147483649", 1<<31 - 1, ErrRange},
146
        {"-2147483649", -1 << 31, ErrRange},
147
}
148
 
149
func init() {
150
        // The atoi routines return NumErrors wrapping
151
        // the error and the string.  Convert the tables above.
152
        for i := range atoui64tests {
153
                test := &atoui64tests[i]
154
                if test.err != nil {
155
                        test.err = &NumError{"ParseUint", test.in, test.err}
156
                }
157
        }
158
        for i := range btoui64tests {
159
                test := &btoui64tests[i]
160
                if test.err != nil {
161
                        test.err = &NumError{"ParseUint", test.in, test.err}
162
                }
163
        }
164
        for i := range atoi64tests {
165
                test := &atoi64tests[i]
166
                if test.err != nil {
167
                        test.err = &NumError{"ParseInt", test.in, test.err}
168
                }
169
        }
170
        for i := range btoi64tests {
171
                test := &btoi64tests[i]
172
                if test.err != nil {
173
                        test.err = &NumError{"ParseInt", test.in, test.err}
174
                }
175
        }
176
        for i := range atoui32tests {
177
                test := &atoui32tests[i]
178
                if test.err != nil {
179
                        test.err = &NumError{"ParseUint", test.in, test.err}
180
                }
181
        }
182
        for i := range atoi32tests {
183
                test := &atoi32tests[i]
184
                if test.err != nil {
185
                        test.err = &NumError{"ParseInt", test.in, test.err}
186
                }
187
        }
188
}
189
 
190
func TestParseUint64(t *testing.T) {
191
        for i := range atoui64tests {
192
                test := &atoui64tests[i]
193
                out, err := ParseUint(test.in, 10, 64)
194
                if test.out != out || !reflect.DeepEqual(test.err, err) {
195
                        t.Errorf("Atoui64(%q) = %v, %v want %v, %v",
196
                                test.in, out, err, test.out, test.err)
197
                }
198
        }
199
}
200
 
201
func TestParseUint64Base(t *testing.T) {
202
        for i := range btoui64tests {
203
                test := &btoui64tests[i]
204
                out, err := ParseUint(test.in, 0, 64)
205
                if test.out != out || !reflect.DeepEqual(test.err, err) {
206
                        t.Errorf("ParseUint(%q) = %v, %v want %v, %v",
207
                                test.in, out, err, test.out, test.err)
208
                }
209
        }
210
}
211
 
212
func TestParseInt64(t *testing.T) {
213
        for i := range atoi64tests {
214
                test := &atoi64tests[i]
215
                out, err := ParseInt(test.in, 10, 64)
216
                if test.out != out || !reflect.DeepEqual(test.err, err) {
217
                        t.Errorf("Atoi64(%q) = %v, %v want %v, %v",
218
                                test.in, out, err, test.out, test.err)
219
                }
220
        }
221
}
222
 
223
func TestParseInt64Base(t *testing.T) {
224
        for i := range btoi64tests {
225
                test := &btoi64tests[i]
226
                out, err := ParseInt(test.in, 0, 64)
227
                if test.out != out || !reflect.DeepEqual(test.err, err) {
228
                        t.Errorf("ParseInt(%q) = %v, %v want %v, %v",
229
                                test.in, out, err, test.out, test.err)
230
                }
231
        }
232
}
233
 
234
func TestParseUint(t *testing.T) {
235
        switch IntSize {
236
        case 32:
237
                for i := range atoui32tests {
238
                        test := &atoui32tests[i]
239
                        out, err := ParseUint(test.in, 10, 0)
240
                        if test.out != uint32(out) || !reflect.DeepEqual(test.err, err) {
241
                                t.Errorf("Atoui(%q) = %v, %v want %v, %v",
242
                                        test.in, out, err, test.out, test.err)
243
                        }
244
                }
245
        case 64:
246
                for i := range atoui64tests {
247
                        test := &atoui64tests[i]
248
                        out, err := ParseUint(test.in, 10, 0)
249
                        if test.out != uint64(out) || !reflect.DeepEqual(test.err, err) {
250
                                t.Errorf("Atoui(%q) = %v, %v want %v, %v",
251
                                        test.in, out, err, test.out, test.err)
252
                        }
253
                }
254
        }
255
}
256
 
257
func TestParseInt(t *testing.T) {
258
        switch IntSize {
259
        case 32:
260
                for i := range atoi32tests {
261
                        test := &atoi32tests[i]
262
                        out, err := ParseInt(test.in, 10, 0)
263
                        if test.out != int32(out) || !reflect.DeepEqual(test.err, err) {
264
                                t.Errorf("Atoi(%q) = %v, %v want %v, %v",
265
                                        test.in, out, err, test.out, test.err)
266
                        }
267
                }
268
        case 64:
269
                for i := range atoi64tests {
270
                        test := &atoi64tests[i]
271
                        out, err := ParseInt(test.in, 10, 0)
272
                        if test.out != int64(out) || !reflect.DeepEqual(test.err, err) {
273
                                t.Errorf("Atoi(%q) = %v, %v want %v, %v",
274
                                        test.in, out, err, test.out, test.err)
275
                        }
276
                }
277
        }
278
}
279
 
280
func BenchmarkAtoi(b *testing.B) {
281
        for i := 0; i < b.N; i++ {
282
                ParseInt("12345678", 10, 0)
283
        }
284
}
285
 
286
func BenchmarkAtoiNeg(b *testing.B) {
287
        for i := 0; i < b.N; i++ {
288
                ParseInt("-12345678", 10, 0)
289
        }
290
}
291
 
292
func BenchmarkAtoi64(b *testing.B) {
293
        for i := 0; i < b.N; i++ {
294
                ParseInt("12345678901234", 10, 64)
295
        }
296
}
297
 
298
func BenchmarkAtoi64Neg(b *testing.B) {
299
        for i := 0; i < b.N; i++ {
300
                ParseInt("-12345678901234", 10, 64)
301
        }
302
}

powered by: WebSVN 2.1.0

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