1
2
3
4
5 package big
6
7 import (
8 "fmt"
9 "os"
10 "strings"
11 "testing"
12 )
13
14 var cmpTests = []struct {
15 x, y nat
16 r int
17 }{
18 {nil, nil, 0},
19 {nil, nat{}, 0},
20 {nat{}, nil, 0},
21 {nat{}, nat{}, 0},
22 {nat{0}, nat{0}, 0},
23 {nat{0}, nat{1}, -1},
24 {nat{1}, nat{0}, 1},
25 {nat{1}, nat{1}, 0},
26 {nat{0, _M}, nat{1}, 1},
27 {nat{1}, nat{0, _M}, -1},
28 {nat{1, _M}, nat{0, _M}, 1},
29 {nat{0, _M}, nat{1, _M}, -1},
30 {nat{16, 571956, 8794, 68}, nat{837, 9146, 1, 754489}, -1},
31 {nat{34986, 41, 105, 1957}, nat{56, 7458, 104, 1957}, 1},
32 }
33
34 func TestCmp(t *testing.T) {
35 for i, a := range cmpTests {
36 r := a.x.cmp(a.y)
37 if r != a.r {
38 t.Errorf("#%d got r = %v; want %v", i, r, a.r)
39 }
40 }
41 }
42
43 type funNN func(z, x, y nat) nat
44 type argNN struct {
45 z, x, y nat
46 }
47
48 var sumNN = []argNN{
49 {},
50 {nat{1}, nil, nat{1}},
51 {nat{1111111110}, nat{123456789}, nat{987654321}},
52 {nat{0, 0, 0, 1}, nil, nat{0, 0, 0, 1}},
53 {nat{0, 0, 0, 1111111110}, nat{0, 0, 0, 123456789}, nat{0, 0, 0, 987654321}},
54 {nat{0, 0, 0, 1}, nat{0, 0, _M}, nat{0, 0, 1}},
55 }
56
57 var prodNN = []argNN{
58 {},
59 {nil, nil, nil},
60 {nil, nat{991}, nil},
61 {nat{991}, nat{991}, nat{1}},
62 {nat{991 * 991}, nat{991}, nat{991}},
63 {nat{0, 0, 991 * 991}, nat{0, 991}, nat{0, 991}},
64 {nat{1 * 991, 2 * 991, 3 * 991, 4 * 991}, nat{1, 2, 3, 4}, nat{991}},
65 {nat{4, 11, 20, 30, 20, 11, 4}, nat{1, 2, 3, 4}, nat{4, 3, 2, 1}},
66 }
67
68 func TestSet(t *testing.T) {
69 for _, a := range sumNN {
70 z := nat(nil).set(a.z)
71 if z.cmp(a.z) != 0 {
72 t.Errorf("got z = %v; want %v", z, a.z)
73 }
74 }
75 }
76
77 func testFunNN(t *testing.T, msg string, f funNN, a argNN) {
78 z := f(nil, a.x, a.y)
79 if z.cmp(a.z) != 0 {
80 t.Errorf("%s%+v\n\tgot z = %v; want %v", msg, a, z, a.z)
81 }
82 }
83
84 func TestFunNN(t *testing.T) {
85 for _, a := range sumNN {
86 arg := a
87 testFunNN(t, "add", nat.add, arg)
88
89 arg = argNN{a.z, a.y, a.x}
90 testFunNN(t, "add symmetric", nat.add, arg)
91
92 arg = argNN{a.x, a.z, a.y}
93 testFunNN(t, "sub", nat.sub, arg)
94
95 arg = argNN{a.y, a.z, a.x}
96 testFunNN(t, "sub symmetric", nat.sub, arg)
97 }
98
99 for _, a := range prodNN {
100 arg := a
101 testFunNN(t, "mul", nat.mul, arg)
102
103 arg = argNN{a.z, a.y, a.x}
104 testFunNN(t, "mul symmetric", nat.mul, arg)
105 }
106 }
107
108 var mulRangesN = []struct {
109 a, b uint64
110 prod string
111 }{
112 {0, 0, "0"},
113 {1, 1, "1"},
114 {1, 2, "2"},
115 {1, 3, "6"},
116 {10, 10, "10"},
117 {0, 100, "0"},
118 {0, 1e9, "0"},
119 {1, 0, "1"},
120 {100, 1, "1"},
121 {1, 10, "3628800"},
122 {1, 20, "2432902008176640000"},
123 {1, 100,
124 "933262154439441526816992388562667004907159682643816214685929" +
125 "638952175999932299156089414639761565182862536979208272237582" +
126 "51185210916864000000000000000000000000",
127 },
128 }
129
130 func TestMulRangeN(t *testing.T) {
131 for i, r := range mulRangesN {
132 prod := nat(nil).mulRange(r.a, r.b).decimalString()
133 if prod != r.prod {
134 t.Errorf("#%d: got %s; want %s", i, prod, r.prod)
135 }
136 }
137 }
138
139 var mulArg, mulTmp nat
140
141 func init() {
142 const n = 1000
143 mulArg = make(nat, n)
144 for i := 0; i < n; i++ {
145 mulArg[i] = _M
146 }
147 }
148
149 func benchmarkMulLoad() {
150 for j := 1; j <= 10; j++ {
151 x := mulArg[0 : j*100]
152 mulTmp.mul(x, x)
153 }
154 }
155
156 func BenchmarkMul(b *testing.B) {
157 for i := 0; i < b.N; i++ {
158 benchmarkMulLoad()
159 }
160 }
161
162 func toString(x nat, charset string) string {
163 base := len(charset)
164
165
166 switch {
167 case base < 2:
168 panic("illegal base")
169 case len(x) == 0:
170 return string(charset[0])
171 }
172
173
174 i := x.bitLen()/log2(Word(base)) + 1
175 s := make([]byte, i)
176
177
178 q := nat(nil).set(x)
179
180
181 for len(q) > 0 {
182 i--
183 var r Word
184 q, r = q.divW(q, Word(base))
185 s[i] = charset[r]
186 }
187
188 return string(s[i:])
189 }
190
191 var strTests = []struct {
192 x nat
193 c string
194 s string
195 }{
196 {nil, "01", "0"},
197 {nat{1}, "01", "1"},
198 {nat{0xc5}, "01", "11000101"},
199 {nat{03271}, lowercaseDigits[0:8], "3271"},
200 {nat{10}, lowercaseDigits[0:10], "10"},
201 {nat{1234567890}, uppercaseDigits[0:10], "1234567890"},
202 {nat{0xdeadbeef}, lowercaseDigits[0:16], "deadbeef"},
203 {nat{0xdeadbeef}, uppercaseDigits[0:16], "DEADBEEF"},
204 {nat{0x229be7}, lowercaseDigits[0:17], "1a2b3c"},
205 {nat{0x309663e6}, uppercaseDigits[0:32], "O9COV6"},
206 }
207
208 func TestString(t *testing.T) {
209 for _, a := range strTests {
210 s := a.x.string(a.c)
211 if s != a.s {
212 t.Errorf("string%+v\n\tgot s = %s; want %s", a, s, a.s)
213 }
214
215 x, b, err := nat(nil).scan(strings.NewReader(a.s), len(a.c))
216 if x.cmp(a.x) != 0 {
217 t.Errorf("scan%+v\n\tgot z = %v; want %v", a, x, a.x)
218 }
219 if b != len(a.c) {
220 t.Errorf("scan%+v\n\tgot b = %d; want %d", a, b, len(a.c))
221 }
222 if err != nil {
223 t.Errorf("scan%+v\n\tgot error = %s", a, err)
224 }
225 }
226 }
227
228 var natScanTests = []struct {
229 s string
230 base int
231 x nat
232 b int
233 ok bool
234 next int
235 }{
236
237 {base: -1},
238 {base: 1},
239 {base: 37},
240
241
242 {},
243 {s: "?"},
244 {base: 10},
245 {base: 36},
246 {s: "?", base: 10},
247 {s: "0x"},
248 {s: "345", base: 2},
249
250
251 {"0", 0, nil, 10, true, 0},
252 {"0", 10, nil, 10, true, 0},
253 {"0", 36, nil, 36, true, 0},
254 {"1", 0, nat{1}, 10, true, 0},
255 {"1", 10, nat{1}, 10, true, 0},
256 {"0 ", 0, nil, 10, true, ' '},
257 {"08", 0, nil, 10, true, '8'},
258 {"018", 0, nat{1}, 8, true, '8'},
259 {"0b1", 0, nat{1}, 2, true, 0},
260 {"0b11000101", 0, nat{0xc5}, 2, true, 0},
261 {"03271", 0, nat{03271}, 8, true, 0},
262 {"10ab", 0, nat{10}, 10, true, 'a'},
263 {"1234567890", 0, nat{1234567890}, 10, true, 0},
264 {"xyz", 36, nat{(33*36+34)*36 + 35}, 36, true, 0},
265 {"xyz?", 36, nat{(33*36+34)*36 + 35}, 36, true, '?'},
266 {"0x", 16, nil, 16, true, 'x'},
267 {"0xdeadbeef", 0, nat{0xdeadbeef}, 16, true, 0},
268 {"0XDEADBEEF", 0, nat{0xdeadbeef}, 16, true, 0},
269 }
270
271 func TestScanBase(t *testing.T) {
272 for _, a := range natScanTests {
273 r := strings.NewReader(a.s)
274 x, b, err := nat(nil).scan(r, a.base)
275 if err == nil && !a.ok {
276 t.Errorf("scan%+v\n\texpected error", a)
277 }
278 if err != nil {
279 if a.ok {
280 t.Errorf("scan%+v\n\tgot error = %s", a, err)
281 }
282 continue
283 }
284 if x.cmp(a.x) != 0 {
285 t.Errorf("scan%+v\n\tgot z = %v; want %v", a, x, a.x)
286 }
287 if b != a.b {
288 t.Errorf("scan%+v\n\tgot b = %d; want %d", a, b, a.base)
289 }
290 next, _, err := r.ReadRune()
291 if err == os.EOF {
292 next = 0
293 err = nil
294 }
295 if err == nil && next != a.next {
296 t.Errorf("scan%+v\n\tgot next = %q; want %q", a, next, a.next)
297 }
298 }
299 }
300
301 var pi = "3" +
302 "14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651" +
303 "32823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461" +
304 "28475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920" +
305 "96282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179" +
306 "31051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798" +
307 "60943702770539217176293176752384674818467669405132000568127145263560827785771342757789609173637178721468440901" +
308 "22495343014654958537105079227968925892354201995611212902196086403441815981362977477130996051870721134999999837" +
309 "29780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083" +
310 "81420617177669147303598253490428755468731159562863882353787593751957781857780532171226806613001927876611195909" +
311 "21642019893809525720106548586327886593615338182796823030195203530185296899577362259941389124972177528347913151" +
312 "55748572424541506959508295331168617278558890750983817546374649393192550604009277016711390098488240128583616035" +
313 "63707660104710181942955596198946767837449448255379774726847104047534646208046684259069491293313677028989152104" +
314 "75216205696602405803815019351125338243003558764024749647326391419927260426992279678235478163600934172164121992" +
315 "45863150302861829745557067498385054945885869269956909272107975093029553211653449872027559602364806654991198818" +
316 "34797753566369807426542527862551818417574672890977772793800081647060016145249192173217214772350141441973568548" +
317 "16136115735255213347574184946843852332390739414333454776241686251898356948556209921922218427255025425688767179" +
318 "04946016534668049886272327917860857843838279679766814541009538837863609506800642251252051173929848960841284886" +
319 "26945604241965285022210661186306744278622039194945047123713786960956364371917287467764657573962413890865832645" +
320 "99581339047802759009946576407895126946839835259570982582262052248940772671947826848260147699090264013639443745" +
321 "53050682034962524517493996514314298091906592509372216964615157098583874105978859597729754989301617539284681382" +
322 "68683868942774155991855925245953959431049972524680845987273644695848653836736222626099124608051243884390451244" +
323 "13654976278079771569143599770012961608944169486855584840635342207222582848864815845602850601684273945226746767" +
324 "88952521385225499546667278239864565961163548862305774564980355936345681743241125150760694794510965960940252288" +
325 "79710893145669136867228748940560101503308617928680920874760917824938589009714909675985261365549781893129784821" +
326 "68299894872265880485756401427047755513237964145152374623436454285844479526586782105114135473573952311342716610" +
327 "21359695362314429524849371871101457654035902799344037420073105785390621983874478084784896833214457138687519435" +
328 "06430218453191048481005370614680674919278191197939952061419663428754440643745123718192179998391015919561814675" +
329 "14269123974894090718649423196156794520809514655022523160388193014209376213785595663893778708303906979207734672" +
330 "21825625996615014215030680384477345492026054146659252014974428507325186660021324340881907104863317346496514539" +
331 "05796268561005508106658796998163574736384052571459102897064140110971206280439039759515677157700420337869936007" +
332 "23055876317635942187312514712053292819182618612586732157919841484882916447060957527069572209175671167229109816" +
333 "90915280173506712748583222871835209353965725121083579151369882091444210067510334671103141267111369908658516398" +
334 "31501970165151168517143765761835155650884909989859982387345528331635507647918535893226185489632132933089857064" +
335 "20467525907091548141654985946163718027098199430992448895757128289059232332609729971208443357326548938239119325" +
336 "97463667305836041428138830320382490375898524374417029132765618093773444030707469211201913020330380197621101100" +
337 "44929321516084244485963766983895228684783123552658213144957685726243344189303968642624341077322697802807318915" +
338 "44110104468232527162010526522721116603966655730925471105578537634668206531098965269186205647693125705863566201" +
339 "85581007293606598764861179104533488503461136576867532494416680396265797877185560845529654126654085306143444318" +
340 "58676975145661406800700237877659134401712749470420562230538994561314071127000407854733269939081454664645880797" +
341 "27082668306343285878569830523580893306575740679545716377525420211495576158140025012622859413021647155097925923" +
342 "09907965473761255176567513575178296664547791745011299614890304639947132962107340437518957359614589019389713111" +
343 "79042978285647503203198691514028708085990480109412147221317947647772622414254854540332157185306142288137585043" +
344 "06332175182979866223717215916077166925474873898665494945011465406284336639379003976926567214638530673609657120" +
345 "91807638327166416274888800786925602902284721040317211860820419000422966171196377921337575114959501566049631862" +
346 "94726547364252308177036751590673502350728354056704038674351362222477158915049530984448933309634087807693259939" +
347 "78054193414473774418426312986080998886874132604721569516239658645730216315981931951673538129741677294786724229" +
348 "24654366800980676928238280689964004824354037014163149658979409243237896907069779422362508221688957383798623001" +
349 "59377647165122893578601588161755782973523344604281512627203734314653197777416031990665541876397929334419521541" +
350 "34189948544473456738316249934191318148092777710386387734317720754565453220777092120190516609628049092636019759" +
351 "88281613323166636528619326686336062735676303544776280350450777235547105859548702790814356240145171806246436267" +
352 "94561275318134078330336254232783944975382437205835311477119926063813346776879695970309833913077109870408591337"
353
354
355 func TestScanPi(t *testing.T) {
356 var x nat
357 z, _, err := x.scan(strings.NewReader(pi), 10)
358 if err != nil {
359 t.Errorf("scanning pi: %s", err)
360 }
361 if s := z.decimalString(); s != pi {
362 t.Errorf("scanning pi: got %s", s)
363 }
364 }
365
366 func BenchmarkScanPi(b *testing.B) {
367 for i := 0; i < b.N; i++ {
368 var x nat
369 x.scan(strings.NewReader(pi), 10)
370 }
371 }
372
373 const (
374
375
376
377
378
379 shortBase = 314
380 shortExponent = 271
381
382
383
384
385
386
387 mediumBase = 3141
388 mediumExponent = 2718
389
390
391
392
393
394
395 longBase = 31415
396 longExponent = 27182
397 )
398
399 func BenchmarkScanShort2(b *testing.B) {
400 ScanHelper(b, 2, shortBase, shortExponent)
401 }
402
403 func BenchmarkScanShort8(b *testing.B) {
404 ScanHelper(b, 8, shortBase, shortExponent)
405 }
406
407 func BenchmarkScanSort10(b *testing.B) {
408 ScanHelper(b, 10, shortBase, shortExponent)
409 }
410
411 func BenchmarkScanShort16(b *testing.B) {
412 ScanHelper(b, 16, shortBase, shortExponent)
413 }
414
415 func BenchmarkScanMedium2(b *testing.B) {
416 ScanHelper(b, 2, mediumBase, mediumExponent)
417 }
418
419 func BenchmarkScanMedium8(b *testing.B) {
420 ScanHelper(b, 8, mediumBase, mediumExponent)
421 }
422
423 func BenchmarkScanMedium10(b *testing.B) {
424 ScanHelper(b, 10, mediumBase, mediumExponent)
425 }
426
427 func BenchmarkScanMedium16(b *testing.B) {
428 ScanHelper(b, 16, mediumBase, mediumExponent)
429 }
430
431 func BenchmarkScanLong2(b *testing.B) {
432 ScanHelper(b, 2, longBase, longExponent)
433 }
434
435 func BenchmarkScanLong8(b *testing.B) {
436 ScanHelper(b, 8, longBase, longExponent)
437 }
438
439 func BenchmarkScanLong10(b *testing.B) {
440 ScanHelper(b, 10, longBase, longExponent)
441 }
442
443 func BenchmarkScanLong16(b *testing.B) {
444 ScanHelper(b, 16, longBase, longExponent)
445 }
446
447 func ScanHelper(b *testing.B, base int, xv, yv Word) {
448 b.StopTimer()
449 var x, y, z nat
450 x = x.setWord(xv)
451 y = y.setWord(yv)
452 z = z.expNN(x, y, nil)
453
454 var s string
455 s = z.string(lowercaseDigits[0:base])
456 if t := toString(z, lowercaseDigits[0:base]); t != s {
457 panic(fmt.Sprintf("scanning: got %s; want %s", s, t))
458 }
459 b.StartTimer()
460
461 for i := 0; i < b.N; i++ {
462 x.scan(strings.NewReader(s), base)
463 }
464 }
465
466 func BenchmarkStringShort2(b *testing.B) {
467 StringHelper(b, 2, shortBase, shortExponent)
468 }
469
470 func BenchmarkStringShort8(b *testing.B) {
471 StringHelper(b, 8, shortBase, shortExponent)
472 }
473
474 func BenchmarkStringShort10(b *testing.B) {
475 StringHelper(b, 10, shortBase, shortExponent)
476 }
477
478 func BenchmarkStringShort16(b *testing.B) {
479 StringHelper(b, 16, shortBase, shortExponent)
480 }
481
482 func BenchmarkStringMedium2(b *testing.B) {
483 StringHelper(b, 2, mediumBase, mediumExponent)
484 }
485
486 func BenchmarkStringMedium8(b *testing.B) {
487 StringHelper(b, 8, mediumBase, mediumExponent)
488 }
489
490 func BenchmarkStringMedium10(b *testing.B) {
491 StringHelper(b, 10, mediumBase, mediumExponent)
492 }
493
494 func BenchmarkStringMedium16(b *testing.B) {
495 StringHelper(b, 16, mediumBase, mediumExponent)
496 }
497
498 func BenchmarkStringLong2(b *testing.B) {
499 StringHelper(b, 2, longBase, longExponent)
500 }
501
502 func BenchmarkStringLong8(b *testing.B) {
503 StringHelper(b, 8, longBase, longExponent)
504 }
505
506 func BenchmarkStringLong10(b *testing.B) {
507 StringHelper(b, 10, longBase, longExponent)
508 }
509
510 func BenchmarkStringLong16(b *testing.B) {
511 StringHelper(b, 16, longBase, longExponent)
512 }
513
514 func StringHelper(b *testing.B, base int, xv, yv Word) {
515 b.StopTimer()
516 var x, y, z nat
517 x = x.setWord(xv)
518 y = y.setWord(yv)
519 z = z.expNN(x, y, nil)
520 b.StartTimer()
521
522 for i := 0; i < b.N; i++ {
523 z.string(lowercaseDigits[0:base])
524 }
525 }
526
527 func TestLeadingZeros(t *testing.T) {
528 var x Word = _B >> 1
529 for i := 0; i <= _W; i++ {
530 if int(leadingZeros(x)) != i {
531 t.Errorf("failed at %x: got %d want %d", x, leadingZeros(x), i)
532 }
533 x >>= 1
534 }
535 }
536
537 type shiftTest struct {
538 in nat
539 shift uint
540 out nat
541 }
542
543 var leftShiftTests = []shiftTest{
544 {nil, 0, nil},
545 {nil, 1, nil},
546 {natOne, 0, natOne},
547 {natOne, 1, natTwo},
548 {nat{1 << (_W - 1)}, 1, nat{0}},
549 {nat{1 << (_W - 1), 0}, 1, nat{0, 1}},
550 }
551
552 func TestShiftLeft(t *testing.T) {
553 for i, test := range leftShiftTests {
554 var z nat
555 z = z.shl(test.in, test.shift)
556 for j, d := range test.out {
557 if j >= len(z) || z[j] != d {
558 t.Errorf("#%d: got: %v want: %v", i, z, test.out)
559 break
560 }
561 }
562 }
563 }
564
565 var rightShiftTests = []shiftTest{
566 {nil, 0, nil},
567 {nil, 1, nil},
568 {natOne, 0, natOne},
569 {natOne, 1, nil},
570 {natTwo, 1, natOne},
571 {nat{0, 1}, 1, nat{1 << (_W - 1)}},
572 {nat{2, 1, 1}, 1, nat{1<<(_W-1) + 1, 1 << (_W - 1)}},
573 }
574
575 func TestShiftRight(t *testing.T) {
576 for i, test := range rightShiftTests {
577 var z nat
578 z = z.shr(test.in, test.shift)
579 for j, d := range test.out {
580 if j >= len(z) || z[j] != d {
581 t.Errorf("#%d: got: %v want: %v", i, z, test.out)
582 break
583 }
584 }
585 }
586 }
587
588 type modWTest struct {
589 in string
590 dividend string
591 out string
592 }
593
594 var modWTests32 = []modWTest{
595 {"23492635982634928349238759823742", "252341", "220170"},
596 }
597
598 var modWTests64 = []modWTest{
599 {"6527895462947293856291561095690465243862946", "524326975699234", "375066989628668"},
600 }
601
602 func runModWTests(t *testing.T, tests []modWTest) {
603 for i, test := range tests {
604 in, _ := new(Int).SetString(test.in, 10)
605 d, _ := new(Int).SetString(test.dividend, 10)
606 out, _ := new(Int).SetString(test.out, 10)
607
608 r := in.abs.modW(d.abs[0])
609 if r != out.abs[0] {
610 t.Errorf("#%d failed: got %s want %s", i, r, out)
611 }
612 }
613 }
614
615 func TestModW(t *testing.T) {
616 if _W >= 32 {
617 runModWTests(t, modWTests32)
618 }
619 if _W >= 64 {
620 runModWTests(t, modWTests64)
621 }
622 }
623
624 func TestTrailingZeroBits(t *testing.T) {
625 var x Word
626 x--
627 for i := 0; i < _W; i++ {
628 if trailingZeroBits(x) != i {
629 t.Errorf("Failed at step %d: x: %x got: %d", i, x, trailingZeroBits(x))
630 }
631 x <<= 1
632 }
633 }
634
635 var expNNTests = []struct {
636 x, y, m string
637 out string
638 }{
639 {"0x8000000000000000", "2", "", "0x40000000000000000000000000000000"},
640 {"0x8000000000000000", "2", "6719", "4944"},
641 {"0x8000000000000000", "3", "6719", "5447"},
642 {"0x8000000000000000", "1000", "6719", "1603"},
643 {"0x8000000000000000", "1000000", "6719", "3199"},
644 {
645 "2938462938472983472983659726349017249287491026512746239764525612965293865296239471239874193284792387498274256129746192347",
646 "298472983472983471903246121093472394872319615612417471234712061",
647 "29834729834729834729347290846729561262544958723956495615629569234729836259263598127342374289365912465901365498236492183464",
648 "23537740700184054162508175125554701713153216681790245129157191391322321508055833908509185839069455749219131480588829346291",
649 },
650 }
651
652 func TestExpNN(t *testing.T) {
653 for i, test := range expNNTests {
654 x, _, _ := nat(nil).scan(strings.NewReader(test.x), 0)
655 y, _, _ := nat(nil).scan(strings.NewReader(test.y), 0)
656 out, _, _ := nat(nil).scan(strings.NewReader(test.out), 0)
657
658 var m nat
659
660 if len(test.m) > 0 {
661 m, _, _ = nat(nil).scan(strings.NewReader(test.m), 0)
662 }
663
664 z := nat(nil).expNN(x, y, m)
665 if z.cmp(out) != 0 {
666 t.Errorf("#%d got %v want %v", i, z, out)
667 }
668 }
669 }