1 // Copyright 2010 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28 #include <stdlib.h>
29 #include <string.h>
30
31
32 #include "double-conversion/bignum.h"
33 #include "cctest.h"
34 #include "double-conversion/utils.h"
35
36 using namespace double_conversion;
37
38
39 static const int kBufferSize = 1024;
40
AssignHexString(Bignum * bignum,const char * str)41 static void AssignHexString(Bignum* bignum, const char* str) {
42 bignum->AssignHexString(Vector<const char>(str, strlen(str)));
43 }
44
45
AssignDecimalString(Bignum * bignum,const char * str)46 static void AssignDecimalString(Bignum* bignum, const char* str) {
47 bignum->AssignDecimalString(Vector<const char>(str, strlen(str)));
48 }
49
50
TEST(Assign)51 TEST(Assign) {
52 char buffer[kBufferSize];
53 Bignum bignum;
54 Bignum bignum2;
55 bignum.AssignUInt16(0);
56 CHECK(bignum.ToHexString(buffer, kBufferSize));
57 CHECK_EQ("0", buffer);
58 bignum.AssignUInt16(0xA);
59 CHECK(bignum.ToHexString(buffer, kBufferSize));
60 CHECK_EQ("A", buffer);
61 bignum.AssignUInt16(0x20);
62 CHECK(bignum.ToHexString(buffer, kBufferSize));
63 CHECK_EQ("20", buffer);
64
65
66 bignum.AssignUInt64(0);
67 CHECK(bignum.ToHexString(buffer, kBufferSize));
68 CHECK_EQ("0", buffer);
69 bignum.AssignUInt64(0xA);
70 CHECK(bignum.ToHexString(buffer, kBufferSize));
71 CHECK_EQ("A", buffer);
72 bignum.AssignUInt64(0x20);
73 CHECK(bignum.ToHexString(buffer, kBufferSize));
74 CHECK_EQ("20", buffer);
75 bignum.AssignUInt64(0x100);
76 CHECK(bignum.ToHexString(buffer, kBufferSize));
77 CHECK_EQ("100", buffer);
78
79 // The first real test, since this will not fit into one bigit.
80 bignum.AssignUInt64(0x12345678);
81 CHECK(bignum.ToHexString(buffer, kBufferSize));
82 CHECK_EQ("12345678", buffer);
83
84 uint64_t big = DOUBLE_CONVERSION_UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF);
85 bignum.AssignUInt64(big);
86 CHECK(bignum.ToHexString(buffer, kBufferSize));
87 CHECK_EQ("FFFFFFFFFFFFFFFF", buffer);
88
89 big = DOUBLE_CONVERSION_UINT64_2PART_C(0x12345678, 9ABCDEF0);
90 bignum.AssignUInt64(big);
91 CHECK(bignum.ToHexString(buffer, kBufferSize));
92 CHECK_EQ("123456789ABCDEF0", buffer);
93
94 bignum2.AssignBignum(bignum);
95 CHECK(bignum2.ToHexString(buffer, kBufferSize));
96 CHECK_EQ("123456789ABCDEF0", buffer);
97
98 AssignDecimalString(&bignum, "0");
99 CHECK(bignum.ToHexString(buffer, kBufferSize));
100 CHECK_EQ("0", buffer);
101
102 AssignDecimalString(&bignum, "1");
103 CHECK(bignum.ToHexString(buffer, kBufferSize));
104 CHECK_EQ("1", buffer);
105
106 AssignDecimalString(&bignum, "1234567890");
107 CHECK(bignum.ToHexString(buffer, kBufferSize));
108 CHECK_EQ("499602D2", buffer);
109
110 AssignHexString(&bignum, "0");
111 CHECK(bignum.ToHexString(buffer, kBufferSize));
112 CHECK_EQ("0", buffer);
113
114 AssignHexString(&bignum, "123456789ABCDEF0");
115 CHECK(bignum.ToHexString(buffer, kBufferSize));
116 CHECK_EQ("123456789ABCDEF0", buffer);
117 }
118
119
TEST(ShiftLeft)120 TEST(ShiftLeft) {
121 char buffer[kBufferSize];
122 Bignum bignum;
123 AssignHexString(&bignum, "0");
124 bignum.ShiftLeft(100);
125 CHECK(bignum.ToHexString(buffer, kBufferSize));
126 CHECK_EQ("0", buffer);
127
128 AssignHexString(&bignum, "1");
129 bignum.ShiftLeft(1);
130 CHECK(bignum.ToHexString(buffer, kBufferSize));
131 CHECK_EQ("2", buffer);
132
133 AssignHexString(&bignum, "1");
134 bignum.ShiftLeft(4);
135 CHECK(bignum.ToHexString(buffer, kBufferSize));
136 CHECK_EQ("10", buffer);
137
138 AssignHexString(&bignum, "1");
139 bignum.ShiftLeft(32);
140 CHECK(bignum.ToHexString(buffer, kBufferSize));
141 CHECK_EQ("100000000", buffer);
142
143 AssignHexString(&bignum, "1");
144 bignum.ShiftLeft(64);
145 CHECK(bignum.ToHexString(buffer, kBufferSize));
146 CHECK_EQ("10000000000000000", buffer);
147
148 AssignHexString(&bignum, "123456789ABCDEF");
149 bignum.ShiftLeft(64);
150 CHECK(bignum.ToHexString(buffer, kBufferSize));
151 CHECK_EQ("123456789ABCDEF0000000000000000", buffer);
152 bignum.ShiftLeft(1);
153 CHECK(bignum.ToHexString(buffer, kBufferSize));
154 CHECK_EQ("2468ACF13579BDE0000000000000000", buffer);
155 }
156
157
TEST(AddUInt64)158 TEST(AddUInt64) {
159 char buffer[kBufferSize];
160 Bignum bignum;
161 AssignHexString(&bignum, "0");
162 bignum.AddUInt64(0xA);
163 CHECK(bignum.ToHexString(buffer, kBufferSize));
164 CHECK_EQ("A", buffer);
165
166 AssignHexString(&bignum, "1");
167 bignum.AddUInt64(0xA);
168 CHECK(bignum.ToHexString(buffer, kBufferSize));
169 CHECK_EQ("B", buffer);
170
171 AssignHexString(&bignum, "1");
172 bignum.AddUInt64(0x100);
173 CHECK(bignum.ToHexString(buffer, kBufferSize));
174 CHECK_EQ("101", buffer);
175
176 AssignHexString(&bignum, "1");
177 bignum.AddUInt64(0xFFFF);
178 CHECK(bignum.ToHexString(buffer, kBufferSize));
179 CHECK_EQ("10000", buffer);
180
181 AssignHexString(&bignum, "FFFFFFF");
182 bignum.AddUInt64(0x1);
183 CHECK(bignum.ToHexString(buffer, kBufferSize));
184 CHECK_EQ("10000000", buffer);
185
186 AssignHexString(&bignum, "10000000000000000000000000000000000000000000");
187 bignum.AddUInt64(0xFFFF);
188 CHECK(bignum.ToHexString(buffer, kBufferSize));
189 CHECK_EQ("1000000000000000000000000000000000000000FFFF", buffer);
190
191 AssignHexString(&bignum, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
192 bignum.AddUInt64(0x1);
193 CHECK(bignum.ToHexString(buffer, kBufferSize));
194 CHECK_EQ("100000000000000000000000000000000000000000000", buffer);
195
196 bignum.AssignUInt16(0x1);
197 bignum.ShiftLeft(100);
198 bignum.AddUInt64(1);
199 CHECK(bignum.ToHexString(buffer, kBufferSize));
200 CHECK_EQ("10000000000000000000000001", buffer);
201
202 bignum.AssignUInt16(0x1);
203 bignum.ShiftLeft(100);
204 bignum.AddUInt64(0xFFFF);
205 CHECK(bignum.ToHexString(buffer, kBufferSize));
206 CHECK_EQ("1000000000000000000000FFFF", buffer);
207
208 AssignHexString(&bignum, "0");
209 bignum.AddUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0xA, 00000000));
210 CHECK(bignum.ToHexString(buffer, kBufferSize));
211 CHECK_EQ("A00000000", buffer);
212
213 AssignHexString(&bignum, "1");
214 bignum.AddUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0xA, 00000000));
215 CHECK(bignum.ToHexString(buffer, kBufferSize));
216 CHECK_EQ("A00000001", buffer);
217
218 AssignHexString(&bignum, "1");
219 bignum.AddUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0x100, 00000000));
220 CHECK(bignum.ToHexString(buffer, kBufferSize));
221 CHECK_EQ("10000000001", buffer);
222
223 AssignHexString(&bignum, "1");
224 bignum.AddUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0xFFFF, 00000000));
225 CHECK(bignum.ToHexString(buffer, kBufferSize));
226 CHECK_EQ("FFFF00000001", buffer);
227
228 AssignHexString(&bignum, "FFFFFFF");
229 bignum.AddUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0x1, 00000000));
230 CHECK(bignum.ToHexString(buffer, kBufferSize));
231 CHECK_EQ("10FFFFFFF", buffer);
232
233 AssignHexString(&bignum, "10000000000000000000000000000000000000000000");
234 bignum.AddUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0xFFFF, 00000000));
235 CHECK(bignum.ToHexString(buffer, kBufferSize));
236 CHECK_EQ("10000000000000000000000000000000FFFF00000000", buffer);
237
238 AssignHexString(&bignum, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
239 bignum.AddUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0x1, 00000000));
240 CHECK(bignum.ToHexString(buffer, kBufferSize));
241 CHECK_EQ("1000000000000000000000000000000000000FFFFFFFF", buffer);
242
243 bignum.AssignUInt16(0x1);
244 bignum.ShiftLeft(100);
245 bignum.AddUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0x1, 00000000));
246 CHECK(bignum.ToHexString(buffer, kBufferSize));
247 CHECK_EQ("10000000000000000100000000", buffer);
248
249 bignum.AssignUInt16(0x1);
250 bignum.ShiftLeft(100);
251 bignum.AddUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0xFFFF, 00000000));
252 CHECK(bignum.ToHexString(buffer, kBufferSize));
253 CHECK_EQ("10000000000000FFFF00000000", buffer);
254 }
255
256
TEST(AddBignum)257 TEST(AddBignum) {
258 char buffer[kBufferSize];
259 Bignum bignum;
260 Bignum other;
261
262 AssignHexString(&other, "1");
263 AssignHexString(&bignum, "0");
264 bignum.AddBignum(other);
265 CHECK(bignum.ToHexString(buffer, kBufferSize));
266 CHECK_EQ("1", buffer);
267
268 AssignHexString(&bignum, "1");
269 bignum.AddBignum(other);
270 CHECK(bignum.ToHexString(buffer, kBufferSize));
271 CHECK_EQ("2", buffer);
272
273 AssignHexString(&bignum, "FFFFFFF");
274 bignum.AddBignum(other);
275 CHECK(bignum.ToHexString(buffer, kBufferSize));
276 CHECK_EQ("10000000", buffer);
277
278 AssignHexString(&bignum, "FFFFFFFFFFFFFF");
279 bignum.AddBignum(other);
280 CHECK(bignum.ToHexString(buffer, kBufferSize));
281 CHECK_EQ("100000000000000", buffer);
282
283 AssignHexString(&bignum, "10000000000000000000000000000000000000000000");
284 bignum.AddBignum(other);
285 CHECK(bignum.ToHexString(buffer, kBufferSize));
286 CHECK_EQ("10000000000000000000000000000000000000000001", buffer);
287
288 AssignHexString(&other, "1000000000000");
289
290 AssignHexString(&bignum, "1");
291 bignum.AddBignum(other);
292 CHECK(bignum.ToHexString(buffer, kBufferSize));
293 CHECK_EQ("1000000000001", buffer);
294
295 AssignHexString(&bignum, "FFFFFFF");
296 bignum.AddBignum(other);
297 CHECK(bignum.ToHexString(buffer, kBufferSize));
298 CHECK_EQ("100000FFFFFFF", buffer);
299
300 AssignHexString(&bignum, "10000000000000000000000000000000000000000000");
301 bignum.AddBignum(other);
302 CHECK(bignum.ToHexString(buffer, kBufferSize));
303 CHECK_EQ("10000000000000000000000000000001000000000000", buffer);
304
305 AssignHexString(&bignum, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
306 bignum.AddBignum(other);
307 CHECK(bignum.ToHexString(buffer, kBufferSize));
308 CHECK_EQ("1000000000000000000000000000000FFFFFFFFFFFF", buffer);
309
310 bignum.AssignUInt16(0x1);
311 bignum.ShiftLeft(100);
312 bignum.AddBignum(other);
313 CHECK(bignum.ToHexString(buffer, kBufferSize));
314 CHECK_EQ("10000000000001000000000000", buffer);
315
316 other.ShiftLeft(64);
317 CHECK(other.ToHexString(buffer, kBufferSize));
318 CHECK_EQ("10000000000000000000000000000", buffer);
319
320 bignum.AssignUInt16(0x1);
321 CHECK(bignum.ToHexString(buffer, kBufferSize));
322 CHECK_EQ("1", buffer);
323
324 bignum.AddBignum(other);
325 CHECK(bignum.ToHexString(buffer, kBufferSize));
326 CHECK_EQ("10000000000000000000000000001", buffer);
327
328 AssignHexString(&bignum, "FFFFFFF");
329 bignum.AddBignum(other);
330 CHECK(bignum.ToHexString(buffer, kBufferSize));
331 CHECK_EQ("1000000000000000000000FFFFFFF", buffer);
332
333 AssignHexString(&bignum, "10000000000000000000000000000000000000000000");
334 bignum.AddBignum(other);
335 CHECK(bignum.ToHexString(buffer, kBufferSize));
336 CHECK_EQ("10000000000000010000000000000000000000000000", buffer);
337
338 AssignHexString(&bignum, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
339 bignum.AddBignum(other);
340 CHECK(bignum.ToHexString(buffer, kBufferSize));
341 CHECK_EQ("100000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFF", buffer);
342
343 bignum.AssignUInt16(0x1);
344 bignum.ShiftLeft(100);
345 bignum.AddBignum(other);
346 CHECK(bignum.ToHexString(buffer, kBufferSize));
347 CHECK_EQ("10010000000000000000000000000", buffer);
348 }
349
350
TEST(SubtractBignum)351 TEST(SubtractBignum) {
352 char buffer[kBufferSize];
353 Bignum bignum;
354 Bignum other;
355
356 AssignHexString(&bignum, "1");
357 AssignHexString(&other, "0");
358 bignum.SubtractBignum(other);
359 CHECK(bignum.ToHexString(buffer, kBufferSize));
360 CHECK_EQ("1", buffer);
361
362 AssignHexString(&bignum, "2");
363 AssignHexString(&other, "0");
364 bignum.SubtractBignum(other);
365 CHECK(bignum.ToHexString(buffer, kBufferSize));
366 CHECK_EQ("2", buffer);
367
368 AssignHexString(&bignum, "10000000");
369 AssignHexString(&other, "1");
370 bignum.SubtractBignum(other);
371 CHECK(bignum.ToHexString(buffer, kBufferSize));
372 CHECK_EQ("FFFFFFF", buffer);
373
374 AssignHexString(&bignum, "100000000000000");
375 AssignHexString(&other, "1");
376 bignum.SubtractBignum(other);
377 CHECK(bignum.ToHexString(buffer, kBufferSize));
378 CHECK_EQ("FFFFFFFFFFFFFF", buffer);
379
380 AssignHexString(&bignum, "10000000000000000000000000000000000000000001");
381 AssignHexString(&other, "1");
382 bignum.SubtractBignum(other);
383 CHECK(bignum.ToHexString(buffer, kBufferSize));
384 CHECK_EQ("10000000000000000000000000000000000000000000", buffer);
385
386 AssignHexString(&bignum, "1000000000001");
387 AssignHexString(&other, "1000000000000");
388 bignum.SubtractBignum(other);
389 CHECK(bignum.ToHexString(buffer, kBufferSize));
390 CHECK_EQ("1", buffer);
391
392 AssignHexString(&bignum, "100000FFFFFFF");
393 AssignHexString(&other, "1000000000000");
394 bignum.SubtractBignum(other);
395 CHECK(bignum.ToHexString(buffer, kBufferSize));
396 CHECK_EQ("FFFFFFF", buffer);
397
398 AssignHexString(&bignum, "10000000000000000000000000000001000000000000");
399 AssignHexString(&other, "1000000000000");
400 bignum.SubtractBignum(other);
401 CHECK(bignum.ToHexString(buffer, kBufferSize));
402 CHECK_EQ("10000000000000000000000000000000000000000000", buffer);
403
404 AssignHexString(&bignum, "1000000000000000000000000000000FFFFFFFFFFFF");
405 AssignHexString(&other, "1000000000000");
406 bignum.SubtractBignum(other);
407 CHECK(bignum.ToHexString(buffer, kBufferSize));
408 CHECK_EQ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", buffer);
409
410 bignum.AssignUInt16(0x1);
411 bignum.ShiftLeft(100);
412 // "10 0000 0000 0000 0000 0000 0000"
413 AssignHexString(&other, "1000000000000");
414 bignum.SubtractBignum(other);
415 CHECK(bignum.ToHexString(buffer, kBufferSize));
416 CHECK_EQ("FFFFFFFFFFFFF000000000000", buffer);
417
418 AssignHexString(&other, "1000000000000");
419 other.ShiftLeft(48);
420 // other == "1000000000000000000000000"
421
422 bignum.AssignUInt16(0x1);
423 bignum.ShiftLeft(100);
424 // bignum == "10000000000000000000000000"
425 bignum.SubtractBignum(other);
426 CHECK(bignum.ToHexString(buffer, kBufferSize));
427 CHECK_EQ("F000000000000000000000000", buffer);
428
429 other.AssignUInt16(0x1);
430 other.ShiftLeft(35);
431 // other == "800000000"
432 AssignHexString(&bignum, "FFFFFFF");
433 bignum.ShiftLeft(60);
434 // bignum = FFFFFFF000000000000000
435 bignum.SubtractBignum(other);
436 CHECK(bignum.ToHexString(buffer, kBufferSize));
437 CHECK_EQ("FFFFFFEFFFFFF800000000", buffer);
438
439 AssignHexString(&bignum, "10000000000000000000000000000000000000000000");
440 bignum.SubtractBignum(other);
441 CHECK(bignum.ToHexString(buffer, kBufferSize));
442 CHECK_EQ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF800000000", buffer);
443
444 AssignHexString(&bignum, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
445 bignum.SubtractBignum(other);
446 CHECK(bignum.ToHexString(buffer, kBufferSize));
447 CHECK_EQ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFF", buffer);
448 }
449
450
TEST(MultiplyUInt32)451 TEST(MultiplyUInt32) {
452 char buffer[kBufferSize];
453 Bignum bignum;
454
455 AssignHexString(&bignum, "0");
456 bignum.MultiplyByUInt32(0x25);
457 CHECK(bignum.ToHexString(buffer, kBufferSize));
458 CHECK_EQ("0", buffer);
459
460 AssignHexString(&bignum, "2");
461 bignum.MultiplyByUInt32(0x5);
462 CHECK(bignum.ToHexString(buffer, kBufferSize));
463 CHECK_EQ("A", buffer);
464
465 AssignHexString(&bignum, "10000000");
466 bignum.MultiplyByUInt32(0x9);
467 CHECK(bignum.ToHexString(buffer, kBufferSize));
468 CHECK_EQ("90000000", buffer);
469
470 AssignHexString(&bignum, "100000000000000");
471 bignum.MultiplyByUInt32(0xFFFF);
472 CHECK(bignum.ToHexString(buffer, kBufferSize));
473 CHECK_EQ("FFFF00000000000000", buffer);
474
475 AssignHexString(&bignum, "100000000000000");
476 bignum.MultiplyByUInt32(0xFFFFFFFF);
477 CHECK(bignum.ToHexString(buffer, kBufferSize));
478 CHECK_EQ("FFFFFFFF00000000000000", buffer);
479
480 AssignHexString(&bignum, "1234567ABCD");
481 bignum.MultiplyByUInt32(0xFFF);
482 CHECK(bignum.ToHexString(buffer, kBufferSize));
483 CHECK_EQ("12333335552433", buffer);
484
485 AssignHexString(&bignum, "1234567ABCD");
486 bignum.MultiplyByUInt32(0xFFFFFFF);
487 CHECK(bignum.ToHexString(buffer, kBufferSize));
488 CHECK_EQ("12345679998A985433", buffer);
489
490 AssignHexString(&bignum, "FFFFFFFFFFFFFFFF");
491 bignum.MultiplyByUInt32(0x2);
492 CHECK(bignum.ToHexString(buffer, kBufferSize));
493 CHECK_EQ("1FFFFFFFFFFFFFFFE", buffer);
494
495 AssignHexString(&bignum, "FFFFFFFFFFFFFFFF");
496 bignum.MultiplyByUInt32(0x4);
497 CHECK(bignum.ToHexString(buffer, kBufferSize));
498 CHECK_EQ("3FFFFFFFFFFFFFFFC", buffer);
499
500 AssignHexString(&bignum, "FFFFFFFFFFFFFFFF");
501 bignum.MultiplyByUInt32(0xF);
502 CHECK(bignum.ToHexString(buffer, kBufferSize));
503 CHECK_EQ("EFFFFFFFFFFFFFFF1", buffer);
504
505 AssignHexString(&bignum, "FFFFFFFFFFFFFFFF");
506 bignum.MultiplyByUInt32(0xFFFFFF);
507 CHECK(bignum.ToHexString(buffer, kBufferSize));
508 CHECK_EQ("FFFFFEFFFFFFFFFF000001", buffer);
509
510 bignum.AssignUInt16(0x1);
511 bignum.ShiftLeft(100);
512 // "10 0000 0000 0000 0000 0000 0000"
513 bignum.MultiplyByUInt32(2);
514 CHECK(bignum.ToHexString(buffer, kBufferSize));
515 CHECK_EQ("20000000000000000000000000", buffer);
516
517 bignum.AssignUInt16(0x1);
518 bignum.ShiftLeft(100);
519 // "10 0000 0000 0000 0000 0000 0000"
520 bignum.MultiplyByUInt32(0xF);
521 CHECK(bignum.ToHexString(buffer, kBufferSize));
522 CHECK_EQ("F0000000000000000000000000", buffer);
523
524 bignum.AssignUInt16(0xFFFF);
525 bignum.ShiftLeft(100);
526 // "FFFF0 0000 0000 0000 0000 0000 0000"
527 bignum.MultiplyByUInt32(0xFFFF);
528 CHECK(bignum.ToHexString(buffer, kBufferSize));
529 CHECK_EQ("FFFE00010000000000000000000000000", buffer);
530
531 bignum.AssignUInt16(0xFFFF);
532 bignum.ShiftLeft(100);
533 // "FFFF0 0000 0000 0000 0000 0000 0000"
534 bignum.MultiplyByUInt32(0xFFFFFFFF);
535 CHECK(bignum.ToHexString(buffer, kBufferSize));
536 CHECK_EQ("FFFEFFFF00010000000000000000000000000", buffer);
537
538 bignum.AssignUInt16(0xFFFF);
539 bignum.ShiftLeft(100);
540 // "FFFF0 0000 0000 0000 0000 0000 0000"
541 bignum.MultiplyByUInt32(0xFFFFFFFF);
542 CHECK(bignum.ToHexString(buffer, kBufferSize));
543 CHECK_EQ("FFFEFFFF00010000000000000000000000000", buffer);
544
545 AssignDecimalString(&bignum, "15611230384529777");
546 bignum.MultiplyByUInt32(10000000);
547 CHECK(bignum.ToHexString(buffer, kBufferSize));
548 CHECK_EQ("210EDD6D4CDD2580EE80", buffer);
549 }
550
551
TEST(MultiplyUInt64)552 TEST(MultiplyUInt64) {
553 char buffer[kBufferSize];
554 Bignum bignum;
555
556 AssignHexString(&bignum, "0");
557 bignum.MultiplyByUInt64(0x25);
558 CHECK(bignum.ToHexString(buffer, kBufferSize));
559 CHECK_EQ("0", buffer);
560
561 AssignHexString(&bignum, "2");
562 bignum.MultiplyByUInt64(0x5);
563 CHECK(bignum.ToHexString(buffer, kBufferSize));
564 CHECK_EQ("A", buffer);
565
566 AssignHexString(&bignum, "10000000");
567 bignum.MultiplyByUInt64(0x9);
568 CHECK(bignum.ToHexString(buffer, kBufferSize));
569 CHECK_EQ("90000000", buffer);
570
571 AssignHexString(&bignum, "100000000000000");
572 bignum.MultiplyByUInt64(0xFFFF);
573 CHECK(bignum.ToHexString(buffer, kBufferSize));
574 CHECK_EQ("FFFF00000000000000", buffer);
575
576 AssignHexString(&bignum, "100000000000000");
577 bignum.MultiplyByUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF));
578 CHECK(bignum.ToHexString(buffer, kBufferSize));
579 CHECK_EQ("FFFFFFFFFFFFFFFF00000000000000", buffer);
580
581 AssignHexString(&bignum, "1234567ABCD");
582 bignum.MultiplyByUInt64(0xFFF);
583 CHECK(bignum.ToHexString(buffer, kBufferSize));
584 CHECK_EQ("12333335552433", buffer);
585
586 AssignHexString(&bignum, "1234567ABCD");
587 bignum.MultiplyByUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0xFF, FFFFFFFF));
588 CHECK(bignum.ToHexString(buffer, kBufferSize));
589 CHECK_EQ("1234567ABCBDCBA985433", buffer);
590
591 AssignHexString(&bignum, "FFFFFFFFFFFFFFFF");
592 bignum.MultiplyByUInt64(0x2);
593 CHECK(bignum.ToHexString(buffer, kBufferSize));
594 CHECK_EQ("1FFFFFFFFFFFFFFFE", buffer);
595
596 AssignHexString(&bignum, "FFFFFFFFFFFFFFFF");
597 bignum.MultiplyByUInt64(0x4);
598 CHECK(bignum.ToHexString(buffer, kBufferSize));
599 CHECK_EQ("3FFFFFFFFFFFFFFFC", buffer);
600
601 AssignHexString(&bignum, "FFFFFFFFFFFFFFFF");
602 bignum.MultiplyByUInt64(0xF);
603 CHECK(bignum.ToHexString(buffer, kBufferSize));
604 CHECK_EQ("EFFFFFFFFFFFFFFF1", buffer);
605
606 AssignHexString(&bignum, "FFFFFFFFFFFFFFFF");
607 bignum.MultiplyByUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF));
608 CHECK(bignum.ToHexString(buffer, kBufferSize));
609 CHECK_EQ("FFFFFFFFFFFFFFFE0000000000000001", buffer);
610
611 bignum.AssignUInt16(0x1);
612 bignum.ShiftLeft(100);
613 // "10 0000 0000 0000 0000 0000 0000"
614 bignum.MultiplyByUInt64(2);
615 CHECK(bignum.ToHexString(buffer, kBufferSize));
616 CHECK_EQ("20000000000000000000000000", buffer);
617
618 bignum.AssignUInt16(0x1);
619 bignum.ShiftLeft(100);
620 // "10 0000 0000 0000 0000 0000 0000"
621 bignum.MultiplyByUInt64(0xF);
622 CHECK(bignum.ToHexString(buffer, kBufferSize));
623 CHECK_EQ("F0000000000000000000000000", buffer);
624
625 bignum.AssignUInt16(0xFFFF);
626 bignum.ShiftLeft(100);
627 // "FFFF0 0000 0000 0000 0000 0000 0000"
628 bignum.MultiplyByUInt64(0xFFFF);
629 CHECK(bignum.ToHexString(buffer, kBufferSize));
630 CHECK_EQ("FFFE00010000000000000000000000000", buffer);
631
632 bignum.AssignUInt16(0xFFFF);
633 bignum.ShiftLeft(100);
634 // "FFFF0 0000 0000 0000 0000 0000 0000"
635 bignum.MultiplyByUInt64(0xFFFFFFFF);
636 CHECK(bignum.ToHexString(buffer, kBufferSize));
637 CHECK_EQ("FFFEFFFF00010000000000000000000000000", buffer);
638
639 bignum.AssignUInt16(0xFFFF);
640 bignum.ShiftLeft(100);
641 // "FFFF0 0000 0000 0000 0000 0000 0000"
642 bignum.MultiplyByUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF));
643 CHECK(bignum.ToHexString(buffer, kBufferSize));
644 CHECK_EQ("FFFEFFFFFFFFFFFF00010000000000000000000000000", buffer);
645
646 AssignDecimalString(&bignum, "15611230384529777");
647 bignum.MultiplyByUInt64(DOUBLE_CONVERSION_UINT64_2PART_C(0x8ac72304, 89e80000));
648 CHECK(bignum.ToHexString(buffer, kBufferSize));
649 CHECK_EQ("1E10EE4B11D15A7F3DE7F3C7680000", buffer);
650 }
651
652
TEST(MultiplyPowerOfTen)653 TEST(MultiplyPowerOfTen) {
654 char buffer[kBufferSize];
655 Bignum bignum;
656
657 AssignDecimalString(&bignum, "1234");
658 bignum.MultiplyByPowerOfTen(1);
659 CHECK(bignum.ToHexString(buffer, kBufferSize));
660 CHECK_EQ("3034", buffer);
661
662 AssignDecimalString(&bignum, "1234");
663 bignum.MultiplyByPowerOfTen(2);
664 CHECK(bignum.ToHexString(buffer, kBufferSize));
665 CHECK_EQ("1E208", buffer);
666
667 AssignDecimalString(&bignum, "1234");
668 bignum.MultiplyByPowerOfTen(3);
669 CHECK(bignum.ToHexString(buffer, kBufferSize));
670 CHECK_EQ("12D450", buffer);
671
672 AssignDecimalString(&bignum, "1234");
673 bignum.MultiplyByPowerOfTen(4);
674 CHECK(bignum.ToHexString(buffer, kBufferSize));
675 CHECK_EQ("BC4B20", buffer);
676
677 AssignDecimalString(&bignum, "1234");
678 bignum.MultiplyByPowerOfTen(5);
679 CHECK(bignum.ToHexString(buffer, kBufferSize));
680 CHECK_EQ("75AEF40", buffer);
681
682 AssignDecimalString(&bignum, "1234");
683 bignum.MultiplyByPowerOfTen(6);
684 CHECK(bignum.ToHexString(buffer, kBufferSize));
685 CHECK_EQ("498D5880", buffer);
686
687 AssignDecimalString(&bignum, "1234");
688 bignum.MultiplyByPowerOfTen(7);
689 CHECK(bignum.ToHexString(buffer, kBufferSize));
690 CHECK_EQ("2DF857500", buffer);
691
692 AssignDecimalString(&bignum, "1234");
693 bignum.MultiplyByPowerOfTen(8);
694 CHECK(bignum.ToHexString(buffer, kBufferSize));
695 CHECK_EQ("1CBB369200", buffer);
696
697 AssignDecimalString(&bignum, "1234");
698 bignum.MultiplyByPowerOfTen(9);
699 CHECK(bignum.ToHexString(buffer, kBufferSize));
700 CHECK_EQ("11F5021B400", buffer);
701
702 AssignDecimalString(&bignum, "1234");
703 bignum.MultiplyByPowerOfTen(10);
704 CHECK(bignum.ToHexString(buffer, kBufferSize));
705 CHECK_EQ("B3921510800", buffer);
706
707 AssignDecimalString(&bignum, "1234");
708 bignum.MultiplyByPowerOfTen(11);
709 CHECK(bignum.ToHexString(buffer, kBufferSize));
710 CHECK_EQ("703B4D2A5000", buffer);
711
712 AssignDecimalString(&bignum, "1234");
713 bignum.MultiplyByPowerOfTen(12);
714 CHECK(bignum.ToHexString(buffer, kBufferSize));
715 CHECK_EQ("4625103A72000", buffer);
716
717 AssignDecimalString(&bignum, "1234");
718 bignum.MultiplyByPowerOfTen(13);
719 CHECK(bignum.ToHexString(buffer, kBufferSize));
720 CHECK_EQ("2BD72A24874000", buffer);
721
722 AssignDecimalString(&bignum, "1234");
723 bignum.MultiplyByPowerOfTen(14);
724 CHECK(bignum.ToHexString(buffer, kBufferSize));
725 CHECK_EQ("1B667A56D488000", buffer);
726
727 AssignDecimalString(&bignum, "1234");
728 bignum.MultiplyByPowerOfTen(15);
729 CHECK(bignum.ToHexString(buffer, kBufferSize));
730 CHECK_EQ("11200C7644D50000", buffer);
731
732 AssignDecimalString(&bignum, "1234");
733 bignum.MultiplyByPowerOfTen(16);
734 CHECK(bignum.ToHexString(buffer, kBufferSize));
735 CHECK_EQ("AB407C9EB0520000", buffer);
736
737 AssignDecimalString(&bignum, "1234");
738 bignum.MultiplyByPowerOfTen(17);
739 CHECK(bignum.ToHexString(buffer, kBufferSize));
740 CHECK_EQ("6B084DE32E3340000", buffer);
741
742 AssignDecimalString(&bignum, "1234");
743 bignum.MultiplyByPowerOfTen(18);
744 CHECK(bignum.ToHexString(buffer, kBufferSize));
745 CHECK_EQ("42E530ADFCE0080000", buffer);
746
747 AssignDecimalString(&bignum, "1234");
748 bignum.MultiplyByPowerOfTen(19);
749 CHECK(bignum.ToHexString(buffer, kBufferSize));
750 CHECK_EQ("29CF3E6CBE0C0500000", buffer);
751
752 AssignDecimalString(&bignum, "1234");
753 bignum.MultiplyByPowerOfTen(20);
754 CHECK(bignum.ToHexString(buffer, kBufferSize));
755 CHECK_EQ("1A218703F6C783200000", buffer);
756
757 AssignDecimalString(&bignum, "1234");
758 bignum.MultiplyByPowerOfTen(21);
759 CHECK(bignum.ToHexString(buffer, kBufferSize));
760 CHECK_EQ("1054F4627A3CB1F400000", buffer);
761
762 AssignDecimalString(&bignum, "1234");
763 bignum.MultiplyByPowerOfTen(22);
764 CHECK(bignum.ToHexString(buffer, kBufferSize));
765 CHECK_EQ("A3518BD8C65EF38800000", buffer);
766
767 AssignDecimalString(&bignum, "1234");
768 bignum.MultiplyByPowerOfTen(23);
769 CHECK(bignum.ToHexString(buffer, kBufferSize));
770 CHECK_EQ("6612F7677BFB5835000000", buffer);
771
772 AssignDecimalString(&bignum, "1234");
773 bignum.MultiplyByPowerOfTen(24);
774 CHECK(bignum.ToHexString(buffer, kBufferSize));
775 CHECK_EQ("3FCBDAA0AD7D17212000000", buffer);
776
777 AssignDecimalString(&bignum, "1234");
778 bignum.MultiplyByPowerOfTen(25);
779 CHECK(bignum.ToHexString(buffer, kBufferSize));
780 CHECK_EQ("27DF68A46C6E2E74B4000000", buffer);
781
782 AssignDecimalString(&bignum, "1234");
783 bignum.MultiplyByPowerOfTen(26);
784 CHECK(bignum.ToHexString(buffer, kBufferSize));
785 CHECK_EQ("18EBA166C3C4DD08F08000000", buffer);
786
787 AssignDecimalString(&bignum, "1234");
788 bignum.MultiplyByPowerOfTen(27);
789 CHECK(bignum.ToHexString(buffer, kBufferSize));
790 CHECK_EQ("F9344E03A5B0A259650000000", buffer);
791
792 AssignDecimalString(&bignum, "1234");
793 bignum.MultiplyByPowerOfTen(28);
794 CHECK(bignum.ToHexString(buffer, kBufferSize));
795 CHECK_EQ("9BC0B0C2478E6577DF20000000", buffer);
796
797 AssignDecimalString(&bignum, "1234");
798 bignum.MultiplyByPowerOfTen(29);
799 CHECK(bignum.ToHexString(buffer, kBufferSize));
800 CHECK_EQ("61586E796CB8FF6AEB740000000", buffer);
801
802 AssignDecimalString(&bignum, "1234");
803 bignum.MultiplyByPowerOfTen(30);
804 CHECK(bignum.ToHexString(buffer, kBufferSize));
805 CHECK_EQ("3CD7450BE3F39FA2D32880000000", buffer);
806
807 AssignDecimalString(&bignum, "1234");
808 bignum.MultiplyByPowerOfTen(31);
809 CHECK(bignum.ToHexString(buffer, kBufferSize));
810 CHECK_EQ("26068B276E7843C5C3F9500000000", buffer);
811
812 AssignDecimalString(&bignum, "1234");
813 bignum.MultiplyByPowerOfTen(50);
814 CHECK(bignum.ToHexString(buffer, kBufferSize));
815 CHECK_EQ("149D1B4CFED03B23AB5F4E1196EF45C08000000000000", buffer);
816
817 AssignDecimalString(&bignum, "1234");
818 bignum.MultiplyByPowerOfTen(100);
819 CHECK(bignum.ToHexString(buffer, kBufferSize));
820 CHECK_EQ("5827249F27165024FBC47DFCA9359BF316332D1B91ACEECF471FBAB06D9B2"
821 "0000000000000000000000000", buffer);
822
823 AssignDecimalString(&bignum, "1234");
824 bignum.MultiplyByPowerOfTen(200);
825 CHECK(bignum.ToHexString(buffer, kBufferSize));
826 CHECK_EQ("64C1F5C06C3816AFBF8DAFD5A3D756365BB0FD020E6F084E759C1F7C99E4F"
827 "55B9ACC667CEC477EB958C2AEEB3C6C19BA35A1AD30B35C51EB72040920000"
828 "0000000000000000000000000000000000000000000000", buffer);
829
830 AssignDecimalString(&bignum, "1234");
831 bignum.MultiplyByPowerOfTen(500);
832 CHECK(bignum.ToHexString(buffer, kBufferSize));
833 CHECK_EQ("96741A625EB5D7C91039FEB5C5ACD6D9831EDA5B083D800E6019442C8C8223"
834 "3EAFB3501FE2058062221E15121334928880827DEE1EC337A8B26489F3A40A"
835 "CB440A2423734472D10BFCE886F41B3AF9F9503013D86D088929CA86EEB4D8"
836 "B9C831D0BD53327B994A0326227CFD0ECBF2EB48B02387AAE2D4CCCDF1F1A1"
837 "B8CC4F1FA2C56AD40D0E4DAA9C28CDBF0A549098EA13200000000000000000"
838 "00000000000000000000000000000000000000000000000000000000000000"
839 "0000000000000000000000000000000000000000000000", buffer);
840
841 AssignDecimalString(&bignum, "1234");
842 bignum.MultiplyByPowerOfTen(1000);
843 CHECK(bignum.ToHexString(buffer, kBufferSize));
844 CHECK_EQ("1258040F99B1CD1CC9819C676D413EA50E4A6A8F114BB0C65418C62D399B81"
845 "6361466CA8E095193E1EE97173553597C96673AF67FAFE27A66E7EF2E5EF2E"
846 "E3F5F5070CC17FE83BA53D40A66A666A02F9E00B0E11328D2224B8694C7372"
847 "F3D536A0AD1985911BD361496F268E8B23112500EAF9B88A9BC67B2AB04D38"
848 "7FEFACD00F5AF4F764F9ABC3ABCDE54612DE38CD90CB6647CA389EA0E86B16"
849 "BF7A1F34086E05ADBE00BD1673BE00FAC4B34AF1091E8AD50BA675E0381440"
850 "EA8E9D93E75D816BAB37C9844B1441C38FC65CF30ABB71B36433AF26DD97BD"
851 "ABBA96C03B4919B8F3515B92826B85462833380DC193D79F69D20DD6038C99"
852 "6114EF6C446F0BA28CC772ACBA58B81C04F8FFDE7B18C4E5A3ABC51E637FDF"
853 "6E37FDFF04C940919390F4FF92000000000000000000000000000000000000"
854 "00000000000000000000000000000000000000000000000000000000000000"
855 "00000000000000000000000000000000000000000000000000000000000000"
856 "00000000000000000000000000000000000000000000000000000000000000"
857 "0000000000000000000000000000", buffer);
858
859 Bignum bignum2;
860 AssignHexString(&bignum2, "3DA774C07FB5DF54284D09C675A492165B830D5DAAEB2A7501"
861 "DA17CF9DFA1CA2282269F92A25A97314296B717E3DCBB9FE17"
862 "41A842FE2913F540F40796F2381155763502C58B15AF7A7F88"
863 "6F744C9164FF409A28F7FA0C41F89ED79C1BE9F322C8578B97"
864 "841F1CBAA17D901BE1230E3C00E1C643AF32638B5674E01FEA"
865 "96FC90864E621B856A9E1CE56E6EB545B9C2F8F0CC10DDA88D"
866 "CC6D282605F8DB67044F2DFD3695E7BA63877AE16701536AE6"
867 "567C794D0BFE338DFBB42D92D4215AF3BB22BF0A8B283FDDC2"
868 "C667A10958EA6D2");
869 CHECK(bignum2.ToHexString(buffer, kBufferSize));
870 CHECK_EQ("3DA774C07FB5DF54284D09C675A492165B830D5DAAEB2A7501"
871 "DA17CF9DFA1CA2282269F92A25A97314296B717E3DCBB9FE17"
872 "41A842FE2913F540F40796F2381155763502C58B15AF7A7F88"
873 "6F744C9164FF409A28F7FA0C41F89ED79C1BE9F322C8578B97"
874 "841F1CBAA17D901BE1230E3C00E1C643AF32638B5674E01FEA"
875 "96FC90864E621B856A9E1CE56E6EB545B9C2F8F0CC10DDA88D"
876 "CC6D282605F8DB67044F2DFD3695E7BA63877AE16701536AE6"
877 "567C794D0BFE338DFBB42D92D4215AF3BB22BF0A8B283FDDC2"
878 "C667A10958EA6D2", buffer);
879
880 bignum.AssignBignum(bignum2);
881 bignum.MultiplyByPowerOfTen(1);
882 CHECK(bignum.ToHexString(buffer, kBufferSize));
883 CHECK_EQ("2688A8F84FD1AB949930261C0986DB4DF931E85A8AD2FA8921284EE1C2BC51"
884 "E55915823BBA5789E7EC99E326EEE69F543ECE890929DED9AC79489884BE57"
885 "630AD569E121BB76ED8DAC8FB545A8AFDADF1F8860599AFC47A93B6346C191"
886 "7237F5BD36B73EB29371F4A4EE7A116CB5E8E5808D1BEA4D7F7E3716090C13"
887 "F29E5DDA53F0FD513362A2D20F6505314B9419DB967F8A8A89589FC43917C3"
888 "BB892062B17CBE421DB0D47E34ACCCE060D422CFF60DCBD0277EE038BD509C"
889 "7BC494D8D854F5B76696F927EA99BC00C4A5D7928434", buffer);
890
891 bignum.AssignBignum(bignum2);
892 bignum.MultiplyByPowerOfTen(2);
893 CHECK(bignum.ToHexString(buffer, kBufferSize));
894 CHECK_EQ("1815699B31E30B3CDFBE17D185F44910BBBF313896C3DC95B4B9314D19B5B32"
895 "F57AD71655476B630F3E02DF855502394A74115A5BA2B480BCBCD5F52F6F69D"
896 "E6C5622CB5152A54788BD9D14B896DE8CB73B53C3800DDACC9C51E0C38FAE76"
897 "2F9964232872F9C2738E7150C4AE3F1B18F70583172706FAEE26DC5A78C77A2"
898 "FAA874769E52C01DA5C3499F233ECF3C90293E0FB69695D763DAA3AEDA5535B"
899 "43DAEEDF6E9528E84CEE0EC000C3C8495C1F9C89F6218AF4C23765261CD5ADD"
900 "0787351992A01E5BB8F2A015807AE7A6BB92A08", buffer);
901
902 bignum.AssignBignum(bignum2);
903 bignum.MultiplyByPowerOfTen(5);
904 CHECK(bignum.ToHexString(buffer, kBufferSize));
905 CHECK_EQ("5E13A4863ADEE3E5C9FE8D0A73423D695D62D8450CED15A8C9F368952C6DC3"
906 "F0EE7D82F3D1EFB7AF38A3B3920D410AFCAD563C8F5F39116E141A3C5C14B3"
907 "58CD73077EA35AAD59F6E24AD98F10D5555ABBFBF33AC361EAF429FD5FBE94"
908 "17DA9EF2F2956011F9F93646AA38048A681D984ED88127073443247CCC167C"
909 "B354A32206EF5A733E73CF82D795A1AD598493211A6D613C39515E0E0F6304"
910 "DCD9C810F3518C7F6A7CB6C81E99E02FCC65E8FDB7B7AE97306CC16A8631CE"
911 "0A2AEF6568276BE4C176964A73C153FDE018E34CB4C2F40", buffer);
912
913 bignum.AssignBignum(bignum2);
914 bignum.MultiplyByPowerOfTen(10);
915 CHECK(bignum.ToHexString(buffer, kBufferSize));
916 CHECK_EQ("8F8CB8EB51945A7E815809F6121EF2F4E61EF3405CD9432CAD2709749EEAFD"
917 "1B81E843F14A3667A7BDCCC9E0BB795F63CDFDB62844AC7438976C885A0116"
918 "29607DA54F9C023CC366570B7637ED0F855D931752038A614922D0923E382C"
919 "B8E5F6C975672DB76E0DE471937BB9EDB11E28874F1C122D5E1EF38CECE9D0"
920 "0723056BCBD4F964192B76830634B1D322B7EB0062F3267E84F5C824343A77"
921 "4B7DCEE6DD464F01EBDC8C671BB18BB4EF4300A42474A6C77243F2A12B03BF"
922 "0443C38A1C0D2701EDB393135AE0DEC94211F9D4EB51F990800", buffer);
923
924 bignum.AssignBignum(bignum2);
925 bignum.MultiplyByPowerOfTen(50);
926 CHECK(bignum.ToHexString(buffer, kBufferSize));
927 CHECK_EQ("107A8BE345E24407372FC1DE442CBA696BC23C4FFD5B4BDFD9E5C39559815"
928 "86628CF8472D2D589F2FC2BAD6E0816EC72CBF85CCA663D8A1EC6C51076D8"
929 "2D247E6C26811B7EC4D4300FB1F91028DCB7B2C4E7A60C151161AA7E65E79"
930 "B40917B12B2B5FBE7745984D4E8EFA31F9AE6062427B068B144A9CB155873"
931 "E7C0C9F0115E5AC72DC5A73C4796DB970BF9205AB8C77A6996EB1B417F9D1"
932 "6232431E6313C392203601B9C22CC10DDA88DCC6D282605F8DB67044F2DFD"
933 "3695E7BA63877AE16701536AE6567C794D0BFE338DFBB42D924CF964BD2C0"
934 "F586E03A2FCD35A408000000000000", buffer);
935
936 bignum.AssignBignum(bignum2);
937 bignum.MultiplyByPowerOfTen(100);
938 CHECK(bignum.ToHexString(buffer, kBufferSize));
939 CHECK_EQ("46784A90ACD0ED3E7759CC585FB32D36EB6034A6F78D92604E3BAA5ED3D8B"
940 "6E60E854439BE448897FB4B7EA5A3D873AA0FCB3CFFD80D0530880E45F511"
941 "722A50CE7E058B5A6F5464DB7500E34984EE3202A9441F44FA1554C0CEA96"
942 "B438A36F25E7C9D56D71AE2CD313EC37534DA299AC0854FC48591A7CF3171"
943 "31265AA4AE62DE32344CE7BEEEF894AE686A2DAAFE5D6D9A10971FFD9C064"
944 "5079B209E1048F58B5192D41D84336AC4C8C489EEF00939CFC9D55C122036"
945 "01B9C22CC10DDA88DCC6D282605F8DB67044F2DFD3695E7BA3F67B96D3A32"
946 "E11FB5561B68744C4035B0800DC166D49D98E3FD1D5BB2000000000000000"
947 "0000000000", buffer);
948
949 bignum.AssignBignum(bignum2);
950 bignum.MultiplyByPowerOfTen(200);
951 CHECK(bignum.ToHexString(buffer, kBufferSize));
952 CHECK_EQ("508BD351221DF139D72D88CDC0416845A53EE2D0E6B98352509A9AC312F8C"
953 "6CB1A144889416201E0B6CE66EA3EBE259B5FD79ECFC1FD77963CE516CC7E"
954 "2FE73D4B5B710C19F6BCB092C7A2FD76286543B8DBD2C596DFF2C896720BA"
955 "DFF7BC9C366ACEA3A880AEC287C5E6207DF2739B5326FC19D773BD830B109"
956 "ED36C7086544BF8FDB9D4B73719C2B5BC2F571A5937EC46876CD428281F6B"
957 "F287E1E07F25C1B1D46BC37324FF657A8B2E0071DB83B86123CA34004F406"
958 "001082D7945E90C6E8C9A9FEC2B44BE0DDA46E9F52B152E4D1336D2FCFBC9"
959 "96E30CA0082256737365158FE36482AA7EB9DAF2AB128F10E7551A3CD5BE6"
960 "0A922F3A7D5EED38B634A7EC95BCF7021BA6820A292000000000000000000"
961 "00000000000000000000000000000000", buffer);
962
963 bignum.AssignBignum(bignum2);
964 bignum.MultiplyByPowerOfTen(500);
965 CHECK(bignum.ToHexString(buffer, kBufferSize));
966 CHECK_EQ("7845F900E475B5086885BAAAE67C8E85185ACFE4633727F82A4B06B5582AC"
967 "BE933C53357DA0C98C20C5AC900C4D76A97247DF52B79F48F9E35840FB715"
968 "D392CE303E22622B0CF82D9471B398457DD3196F639CEE8BBD2C146873841"
969 "F0699E6C41F04FC7A54B48CEB995BEB6F50FE81DE9D87A8D7F849CC523553"
970 "7B7BBBC1C7CAAFF6E9650BE03B308C6D31012AEF9580F70D3EE2083ADE126"
971 "8940FA7D6308E239775DFD2F8C97FF7EBD525DAFA6512216F7047A62A93DC"
972 "38A0165BDC67E250DCC96A0181DE935A70B38704DC71819F02FC5261FF7E1"
973 "E5F11907678B0A3E519FF4C10A867B0C26CE02BE6960BA8621A87303C101C"
974 "3F88798BB9F7739655946F8B5744E6B1EAF10B0C5621330F0079209033C69"
975 "20DE2E2C8D324F0624463735D482BF291926C22A910F5B80FA25170B6B57D"
976 "8D5928C7BCA3FE87461275F69BD5A1B83181DAAF43E05FC3C72C4E93111B6"
977 "6205EBF49B28FEDFB7E7526CBDA658A332000000000000000000000000000"
978 "0000000000000000000000000000000000000000000000000000000000000"
979 "0000000000000000000000000000000000000", buffer);
980 }
981
982
TEST(DivideModuloIntBignum)983 TEST(DivideModuloIntBignum) {
984 char buffer[kBufferSize];
985 Bignum bignum;
986 Bignum other;
987 Bignum third;
988
989 bignum.AssignUInt16(10);
990 other.AssignUInt16(2);
991 CHECK_EQ(5, bignum.DivideModuloIntBignum(other));
992 CHECK(bignum.ToHexString(buffer, kBufferSize));
993 CHECK_EQ("0", buffer);
994
995 bignum.AssignUInt16(10);
996 bignum.ShiftLeft(500);
997 other.AssignUInt16(2);
998 other.ShiftLeft(500);
999 CHECK_EQ(5, bignum.DivideModuloIntBignum(other));
1000 CHECK(bignum.ToHexString(buffer, kBufferSize));
1001 CHECK_EQ("0", buffer);
1002
1003 bignum.AssignUInt16(11);
1004 other.AssignUInt16(2);
1005 CHECK_EQ(5, bignum.DivideModuloIntBignum(other));
1006 CHECK(bignum.ToHexString(buffer, kBufferSize));
1007 CHECK_EQ("1", buffer);
1008
1009 bignum.AssignUInt16(10);
1010 bignum.ShiftLeft(500);
1011 other.AssignUInt16(1);
1012 bignum.AddBignum(other);
1013 other.AssignUInt16(2);
1014 other.ShiftLeft(500);
1015 CHECK_EQ(5, bignum.DivideModuloIntBignum(other));
1016 CHECK(bignum.ToHexString(buffer, kBufferSize));
1017 CHECK_EQ("1", buffer);
1018
1019 bignum.AssignUInt16(10);
1020 bignum.ShiftLeft(500);
1021 other.AssignBignum(bignum);
1022 bignum.MultiplyByUInt32(0x1234);
1023 third.AssignUInt16(0xFFF);
1024 bignum.AddBignum(third);
1025 CHECK_EQ(0x1234, bignum.DivideModuloIntBignum(other));
1026 CHECK(bignum.ToHexString(buffer, kBufferSize));
1027 CHECK_EQ("FFF", buffer);
1028
1029 bignum.AssignUInt16(10);
1030 AssignHexString(&other, "1234567890");
1031 CHECK_EQ(0, bignum.DivideModuloIntBignum(other));
1032 CHECK(bignum.ToHexString(buffer, kBufferSize));
1033 CHECK_EQ("A", buffer);
1034
1035 AssignHexString(&bignum, "12345678");
1036 AssignHexString(&other, "3789012");
1037 CHECK_EQ(5, bignum.DivideModuloIntBignum(other));
1038 CHECK(bignum.ToHexString(buffer, kBufferSize));
1039 CHECK_EQ("D9861E", buffer);
1040
1041 AssignHexString(&bignum, "70000001");
1042 AssignHexString(&other, "1FFFFFFF");
1043 CHECK_EQ(3, bignum.DivideModuloIntBignum(other));
1044 CHECK(bignum.ToHexString(buffer, kBufferSize));
1045 CHECK_EQ("10000004", buffer);
1046
1047 AssignHexString(&bignum, "28000000");
1048 AssignHexString(&other, "12A05F20");
1049 CHECK_EQ(2, bignum.DivideModuloIntBignum(other));
1050 CHECK(bignum.ToHexString(buffer, kBufferSize));
1051 CHECK_EQ("2BF41C0", buffer);
1052
1053 bignum.AssignUInt16(10);
1054 bignum.ShiftLeft(500);
1055 other.AssignBignum(bignum);
1056 bignum.MultiplyByUInt32(0x1234);
1057 third.AssignUInt16(0xFFF);
1058 other.SubtractBignum(third);
1059 CHECK_EQ(0x1234, bignum.DivideModuloIntBignum(other));
1060 CHECK(bignum.ToHexString(buffer, kBufferSize));
1061 CHECK_EQ("1232DCC", buffer);
1062 CHECK_EQ(0, bignum.DivideModuloIntBignum(other));
1063 CHECK(bignum.ToHexString(buffer, kBufferSize));
1064 CHECK_EQ("1232DCC", buffer);
1065 }
1066
1067
TEST(Compare)1068 TEST(Compare) {
1069 Bignum bignum1;
1070 Bignum bignum2;
1071 bignum1.AssignUInt16(1);
1072 bignum2.AssignUInt16(1);
1073 CHECK_EQ(0, Bignum::Compare(bignum1, bignum2));
1074 CHECK(Bignum::Equal(bignum1, bignum2));
1075 CHECK(Bignum::LessEqual(bignum1, bignum2));
1076 CHECK(!Bignum::Less(bignum1, bignum2));
1077
1078 bignum1.AssignUInt16(0);
1079 bignum2.AssignUInt16(1);
1080 CHECK_EQ(-1, Bignum::Compare(bignum1, bignum2));
1081 CHECK_EQ(+1, Bignum::Compare(bignum2, bignum1));
1082 CHECK(!Bignum::Equal(bignum1, bignum2));
1083 CHECK(!Bignum::Equal(bignum2, bignum1));
1084 CHECK(Bignum::LessEqual(bignum1, bignum2));
1085 CHECK(!Bignum::LessEqual(bignum2, bignum1));
1086 CHECK(Bignum::Less(bignum1, bignum2));
1087 CHECK(!Bignum::Less(bignum2, bignum1));
1088
1089 AssignHexString(&bignum1, "1234567890ABCDEF12345");
1090 AssignHexString(&bignum2, "1234567890ABCDEF12345");
1091 CHECK_EQ(0, Bignum::Compare(bignum1, bignum2));
1092
1093 AssignHexString(&bignum1, "1234567890ABCDEF12345");
1094 AssignHexString(&bignum2, "1234567890ABCDEF12346");
1095 CHECK_EQ(-1, Bignum::Compare(bignum1, bignum2));
1096 CHECK_EQ(+1, Bignum::Compare(bignum2, bignum1));
1097
1098 AssignHexString(&bignum1, "1234567890ABCDEF12345");
1099 bignum1.ShiftLeft(500);
1100 AssignHexString(&bignum2, "1234567890ABCDEF12345");
1101 bignum2.ShiftLeft(500);
1102 CHECK_EQ(0, Bignum::Compare(bignum1, bignum2));
1103
1104 AssignHexString(&bignum1, "1234567890ABCDEF12345");
1105 bignum1.ShiftLeft(500);
1106 AssignHexString(&bignum2, "1234567890ABCDEF12346");
1107 bignum2.ShiftLeft(500);
1108 CHECK_EQ(-1, Bignum::Compare(bignum1, bignum2));
1109 CHECK_EQ(+1, Bignum::Compare(bignum2, bignum1));
1110
1111 bignum1.AssignUInt16(1);
1112 bignum1.ShiftLeft(64);
1113 AssignHexString(&bignum2, "10000000000000000");
1114 CHECK_EQ(0, Bignum::Compare(bignum1, bignum2));
1115 CHECK_EQ(0, Bignum::Compare(bignum2, bignum1));
1116
1117 bignum1.AssignUInt16(1);
1118 bignum1.ShiftLeft(64);
1119 AssignHexString(&bignum2, "10000000000000001");
1120 CHECK_EQ(-1, Bignum::Compare(bignum1, bignum2));
1121 CHECK_EQ(+1, Bignum::Compare(bignum2, bignum1));
1122
1123 bignum1.AssignUInt16(1);
1124 bignum1.ShiftLeft(96);
1125 AssignHexString(&bignum2, "10000000000000001");
1126 bignum2.ShiftLeft(32);
1127 CHECK_EQ(-1, Bignum::Compare(bignum1, bignum2));
1128 CHECK_EQ(+1, Bignum::Compare(bignum2, bignum1));
1129
1130 AssignHexString(&bignum1, "FFFFFFFFFFFFFFFF");
1131 bignum2.AssignUInt16(1);
1132 bignum2.ShiftLeft(64);
1133 CHECK_EQ(-1, Bignum::Compare(bignum1, bignum2));
1134 CHECK_EQ(+1, Bignum::Compare(bignum2, bignum1));
1135
1136 AssignHexString(&bignum1, "FFFFFFFFFFFFFFFF");
1137 bignum1.ShiftLeft(32);
1138 bignum2.AssignUInt16(1);
1139 bignum2.ShiftLeft(96);
1140 CHECK_EQ(-1, Bignum::Compare(bignum1, bignum2));
1141 CHECK_EQ(+1, Bignum::Compare(bignum2, bignum1));
1142
1143 AssignHexString(&bignum1, "FFFFFFFFFFFFFFFF");
1144 bignum1.ShiftLeft(32);
1145 bignum2.AssignUInt16(1);
1146 bignum2.ShiftLeft(95);
1147 CHECK_EQ(+1, Bignum::Compare(bignum1, bignum2));
1148 CHECK_EQ(-1, Bignum::Compare(bignum2, bignum1));
1149
1150 AssignHexString(&bignum1, "FFFFFFFFFFFFFFFF");
1151 bignum1.ShiftLeft(32);
1152 bignum2.AssignUInt16(1);
1153 bignum2.ShiftLeft(100);
1154 CHECK_EQ(-1, Bignum::Compare(bignum1, bignum2));
1155 CHECK_EQ(+1, Bignum::Compare(bignum2, bignum1));
1156
1157 AssignHexString(&bignum1, "100000000000000");
1158 bignum2.AssignUInt16(1);
1159 bignum2.ShiftLeft(14*4);
1160 CHECK_EQ(0, Bignum::Compare(bignum1, bignum2));
1161 CHECK_EQ(0, Bignum::Compare(bignum2, bignum1));
1162
1163 AssignHexString(&bignum1, "100000000000001");
1164 bignum2.AssignUInt16(1);
1165 bignum2.ShiftLeft(14*4);
1166 CHECK_EQ(+1, Bignum::Compare(bignum1, bignum2));
1167 CHECK_EQ(-1, Bignum::Compare(bignum2, bignum1));
1168
1169 AssignHexString(&bignum1, "200000000000000");
1170 bignum2.AssignUInt16(3);
1171 bignum2.ShiftLeft(14*4);
1172 CHECK_EQ(-1, Bignum::Compare(bignum1, bignum2));
1173 CHECK_EQ(+1, Bignum::Compare(bignum2, bignum1));
1174 }
1175
1176
TEST(PlusCompare)1177 TEST(PlusCompare) {
1178 Bignum a;
1179 Bignum b;
1180 Bignum c;
1181 a.AssignUInt16(1);
1182 b.AssignUInt16(0);
1183 c.AssignUInt16(1);
1184 CHECK_EQ(0, Bignum::PlusCompare(a, b, c));
1185 CHECK(Bignum::PlusEqual(a, b, c));
1186 CHECK(Bignum::PlusLessEqual(a, b, c));
1187 CHECK(!Bignum::PlusLess(a, b, c));
1188
1189 a.AssignUInt16(0);
1190 b.AssignUInt16(0);
1191 c.AssignUInt16(1);
1192 CHECK_EQ(-1, Bignum::PlusCompare(a, b, c));
1193 CHECK_EQ(+1, Bignum::PlusCompare(c, b, a));
1194 CHECK(!Bignum::PlusEqual(a, b, c));
1195 CHECK(!Bignum::PlusEqual(c, b, a));
1196 CHECK(Bignum::PlusLessEqual(a, b, c));
1197 CHECK(!Bignum::PlusLessEqual(c, b, a));
1198 CHECK(Bignum::PlusLess(a, b, c));
1199 CHECK(!Bignum::PlusLess(c, b, a));
1200
1201 AssignHexString(&a, "1234567890ABCDEF12345");
1202 b.AssignUInt16(1);
1203 AssignHexString(&c, "1234567890ABCDEF12345");
1204 CHECK_EQ(+1, Bignum::PlusCompare(a, b, c));
1205
1206 AssignHexString(&a, "1234567890ABCDEF12344");
1207 b.AssignUInt16(1);
1208 AssignHexString(&c, "1234567890ABCDEF12345");
1209 CHECK_EQ(0, Bignum::PlusCompare(a, b, c));
1210
1211 AssignHexString(&a, "1234567890");
1212 a.ShiftLeft(11*4);
1213 AssignHexString(&b, "ABCDEF12345");
1214 AssignHexString(&c, "1234567890ABCDEF12345");
1215 CHECK_EQ(0, Bignum::PlusCompare(a, b, c));
1216
1217 AssignHexString(&a, "1234567890");
1218 a.ShiftLeft(11*4);
1219 AssignHexString(&b, "ABCDEF12344");
1220 AssignHexString(&c, "1234567890ABCDEF12345");
1221 CHECK_EQ(-1, Bignum::PlusCompare(a, b, c));
1222
1223 AssignHexString(&a, "1234567890");
1224 a.ShiftLeft(11*4);
1225 AssignHexString(&b, "ABCDEF12346");
1226 AssignHexString(&c, "1234567890ABCDEF12345");
1227 CHECK_EQ(1, Bignum::PlusCompare(a, b, c));
1228
1229 AssignHexString(&a, "1234567891");
1230 a.ShiftLeft(11*4);
1231 AssignHexString(&b, "ABCDEF12345");
1232 AssignHexString(&c, "1234567890ABCDEF12345");
1233 CHECK_EQ(1, Bignum::PlusCompare(a, b, c));
1234
1235 AssignHexString(&a, "1234567889");
1236 a.ShiftLeft(11*4);
1237 AssignHexString(&b, "ABCDEF12345");
1238 AssignHexString(&c, "1234567890ABCDEF12345");
1239 CHECK_EQ(-1, Bignum::PlusCompare(a, b, c));
1240
1241 AssignHexString(&a, "1234567890");
1242 a.ShiftLeft(11*4 + 32);
1243 AssignHexString(&b, "ABCDEF12345");
1244 b.ShiftLeft(32);
1245 AssignHexString(&c, "1234567890ABCDEF12345");
1246 c.ShiftLeft(32);
1247 CHECK_EQ(0, Bignum::PlusCompare(a, b, c));
1248
1249 AssignHexString(&a, "1234567890");
1250 a.ShiftLeft(11*4 + 32);
1251 AssignHexString(&b, "ABCDEF12344");
1252 b.ShiftLeft(32);
1253 AssignHexString(&c, "1234567890ABCDEF12345");
1254 c.ShiftLeft(32);
1255 CHECK_EQ(-1, Bignum::PlusCompare(a, b, c));
1256
1257 AssignHexString(&a, "1234567890");
1258 a.ShiftLeft(11*4 + 32);
1259 AssignHexString(&b, "ABCDEF12346");
1260 b.ShiftLeft(32);
1261 AssignHexString(&c, "1234567890ABCDEF12345");
1262 c.ShiftLeft(32);
1263 CHECK_EQ(1, Bignum::PlusCompare(a, b, c));
1264
1265 AssignHexString(&a, "1234567891");
1266 a.ShiftLeft(11*4 + 32);
1267 AssignHexString(&b, "ABCDEF12345");
1268 b.ShiftLeft(32);
1269 AssignHexString(&c, "1234567890ABCDEF12345");
1270 c.ShiftLeft(32);
1271 CHECK_EQ(1, Bignum::PlusCompare(a, b, c));
1272
1273 AssignHexString(&a, "1234567889");
1274 a.ShiftLeft(11*4 + 32);
1275 AssignHexString(&b, "ABCDEF12345");
1276 b.ShiftLeft(32);
1277 AssignHexString(&c, "1234567890ABCDEF12345");
1278 c.ShiftLeft(32);
1279 CHECK_EQ(-1, Bignum::PlusCompare(a, b, c));
1280
1281 AssignHexString(&a, "1234567890");
1282 a.ShiftLeft(11*4 + 32);
1283 AssignHexString(&b, "ABCDEF12345");
1284 b.ShiftLeft(32);
1285 AssignHexString(&c, "1234567890ABCDEF1234500000000");
1286 CHECK_EQ(0, Bignum::PlusCompare(a, b, c));
1287
1288 AssignHexString(&a, "1234567890");
1289 a.ShiftLeft(11*4 + 32);
1290 AssignHexString(&b, "ABCDEF12344");
1291 b.ShiftLeft(32);
1292 AssignHexString(&c, "1234567890ABCDEF1234500000000");
1293 CHECK_EQ(-1, Bignum::PlusCompare(a, b, c));
1294
1295 AssignHexString(&a, "1234567890");
1296 a.ShiftLeft(11*4 + 32);
1297 AssignHexString(&b, "ABCDEF12346");
1298 b.ShiftLeft(32);
1299 AssignHexString(&c, "1234567890ABCDEF1234500000000");
1300 CHECK_EQ(1, Bignum::PlusCompare(a, b, c));
1301
1302 AssignHexString(&a, "1234567891");
1303 a.ShiftLeft(11*4 + 32);
1304 AssignHexString(&b, "ABCDEF12345");
1305 b.ShiftLeft(32);
1306 AssignHexString(&c, "1234567890ABCDEF1234500000000");
1307 CHECK_EQ(1, Bignum::PlusCompare(a, b, c));
1308
1309 AssignHexString(&a, "1234567889");
1310 a.ShiftLeft(11*4 + 32);
1311 AssignHexString(&b, "ABCDEF12345");
1312 b.ShiftLeft(32);
1313 AssignHexString(&c, "1234567890ABCDEF1234500000000");
1314 CHECK_EQ(-1, Bignum::PlusCompare(a, b, c));
1315
1316 AssignHexString(&a, "1234567890");
1317 a.ShiftLeft(11*4 + 32);
1318 AssignHexString(&b, "ABCDEF12345");
1319 AssignHexString(&c, "123456789000000000ABCDEF12345");
1320 CHECK_EQ(0, Bignum::PlusCompare(a, b, c));
1321
1322 AssignHexString(&a, "1234567890");
1323 a.ShiftLeft(11*4 + 32);
1324 AssignHexString(&b, "ABCDEF12346");
1325 AssignHexString(&c, "123456789000000000ABCDEF12345");
1326 CHECK_EQ(1, Bignum::PlusCompare(a, b, c));
1327
1328 AssignHexString(&a, "1234567890");
1329 a.ShiftLeft(11*4 + 32);
1330 AssignHexString(&b, "ABCDEF12344");
1331 AssignHexString(&c, "123456789000000000ABCDEF12345");
1332 CHECK_EQ(-1, Bignum::PlusCompare(a, b, c));
1333
1334 AssignHexString(&a, "1234567890");
1335 a.ShiftLeft(11*4 + 32);
1336 AssignHexString(&b, "ABCDEF12345");
1337 b.ShiftLeft(16);
1338 AssignHexString(&c, "12345678900000ABCDEF123450000");
1339 CHECK_EQ(0, Bignum::PlusCompare(a, b, c));
1340
1341 AssignHexString(&a, "1234567890");
1342 a.ShiftLeft(11*4 + 32);
1343 AssignHexString(&b, "ABCDEF12344");
1344 b.ShiftLeft(16);
1345 AssignHexString(&c, "12345678900000ABCDEF123450000");
1346 CHECK_EQ(-1, Bignum::PlusCompare(a, b, c));
1347
1348 AssignHexString(&a, "1234567890");
1349 a.ShiftLeft(11*4 + 32);
1350 AssignHexString(&b, "ABCDEF12345");
1351 b.ShiftLeft(16);
1352 AssignHexString(&c, "12345678900000ABCDEF123450001");
1353 CHECK_EQ(-1, Bignum::PlusCompare(a, b, c));
1354
1355 AssignHexString(&a, "1234567890");
1356 a.ShiftLeft(11*4 + 32);
1357 AssignHexString(&b, "ABCDEF12346");
1358 b.ShiftLeft(16);
1359 AssignHexString(&c, "12345678900000ABCDEF123450000");
1360 CHECK_EQ(+1, Bignum::PlusCompare(a, b, c));
1361 }
1362
1363
TEST(Square)1364 TEST(Square) {
1365 Bignum bignum;
1366 char buffer[kBufferSize];
1367
1368 bignum.AssignUInt16(1);
1369 bignum.Square();
1370 CHECK(bignum.ToHexString(buffer, kBufferSize));
1371 CHECK_EQ("1", buffer);
1372
1373 bignum.AssignUInt16(2);
1374 bignum.Square();
1375 CHECK(bignum.ToHexString(buffer, kBufferSize));
1376 CHECK_EQ("4", buffer);
1377
1378 bignum.AssignUInt16(10);
1379 bignum.Square();
1380 CHECK(bignum.ToHexString(buffer, kBufferSize));
1381 CHECK_EQ("64", buffer);
1382
1383 AssignHexString(&bignum, "FFFFFFF");
1384 bignum.Square();
1385 CHECK(bignum.ToHexString(buffer, kBufferSize));
1386 CHECK_EQ("FFFFFFE0000001", buffer);
1387
1388 AssignHexString(&bignum, "FFFFFFFFFFFFFF");
1389 bignum.Square();
1390 CHECK(bignum.ToHexString(buffer, kBufferSize));
1391 CHECK_EQ("FFFFFFFFFFFFFE00000000000001", buffer);
1392 }
1393
1394
TEST(AssignPowerUInt16)1395 TEST(AssignPowerUInt16) {
1396 Bignum bignum;
1397 char buffer[kBufferSize];
1398
1399 bignum.AssignPowerUInt16(1, 0);
1400 CHECK(bignum.ToHexString(buffer, kBufferSize));
1401 CHECK_EQ("1", buffer);
1402
1403 bignum.AssignPowerUInt16(1, 1);
1404 CHECK(bignum.ToHexString(buffer, kBufferSize));
1405 CHECK_EQ("1", buffer);
1406
1407 bignum.AssignPowerUInt16(1, 2);
1408 CHECK(bignum.ToHexString(buffer, kBufferSize));
1409 CHECK_EQ("1", buffer);
1410
1411 bignum.AssignPowerUInt16(2, 0);
1412 CHECK(bignum.ToHexString(buffer, kBufferSize));
1413 CHECK_EQ("1", buffer);
1414
1415 bignum.AssignPowerUInt16(2, 1);
1416 CHECK(bignum.ToHexString(buffer, kBufferSize));
1417 CHECK_EQ("2", buffer);
1418
1419 bignum.AssignPowerUInt16(2, 2);
1420 CHECK(bignum.ToHexString(buffer, kBufferSize));
1421 CHECK_EQ("4", buffer);
1422
1423 bignum.AssignPowerUInt16(16, 1);
1424 CHECK(bignum.ToHexString(buffer, kBufferSize));
1425 CHECK_EQ("10", buffer);
1426
1427 bignum.AssignPowerUInt16(16, 2);
1428 CHECK(bignum.ToHexString(buffer, kBufferSize));
1429 CHECK_EQ("100", buffer);
1430
1431 bignum.AssignPowerUInt16(16, 5);
1432 CHECK(bignum.ToHexString(buffer, kBufferSize));
1433 CHECK_EQ("100000", buffer);
1434
1435 bignum.AssignPowerUInt16(16, 8);
1436 CHECK(bignum.ToHexString(buffer, kBufferSize));
1437 CHECK_EQ("100000000", buffer);
1438
1439 bignum.AssignPowerUInt16(16, 16);
1440 CHECK(bignum.ToHexString(buffer, kBufferSize));
1441 CHECK_EQ("10000000000000000", buffer);
1442
1443 bignum.AssignPowerUInt16(16, 30);
1444 CHECK(bignum.ToHexString(buffer, kBufferSize));
1445 CHECK_EQ("1000000000000000000000000000000", buffer);
1446
1447 bignum.AssignPowerUInt16(10, 0);
1448 CHECK(bignum.ToHexString(buffer, kBufferSize));
1449 CHECK_EQ("1", buffer);
1450
1451 bignum.AssignPowerUInt16(10, 1);
1452 CHECK(bignum.ToHexString(buffer, kBufferSize));
1453 CHECK_EQ("A", buffer);
1454
1455 bignum.AssignPowerUInt16(10, 2);
1456 CHECK(bignum.ToHexString(buffer, kBufferSize));
1457 CHECK_EQ("64", buffer);
1458
1459 bignum.AssignPowerUInt16(10, 5);
1460 CHECK(bignum.ToHexString(buffer, kBufferSize));
1461 CHECK_EQ("186A0", buffer);
1462
1463 bignum.AssignPowerUInt16(10, 8);
1464 CHECK(bignum.ToHexString(buffer, kBufferSize));
1465 CHECK_EQ("5F5E100", buffer);
1466
1467 bignum.AssignPowerUInt16(10, 16);
1468 CHECK(bignum.ToHexString(buffer, kBufferSize));
1469 CHECK_EQ("2386F26FC10000", buffer);
1470
1471 bignum.AssignPowerUInt16(10, 30);
1472 CHECK(bignum.ToHexString(buffer, kBufferSize));
1473 CHECK_EQ("C9F2C9CD04674EDEA40000000", buffer);
1474
1475 bignum.AssignPowerUInt16(10, 31);
1476 CHECK(bignum.ToHexString(buffer, kBufferSize));
1477 CHECK_EQ("7E37BE2022C0914B2680000000", buffer);
1478
1479 bignum.AssignPowerUInt16(2, 0);
1480 CHECK(bignum.ToHexString(buffer, kBufferSize));
1481 CHECK_EQ("1", buffer);
1482
1483 bignum.AssignPowerUInt16(2, 100);
1484 CHECK(bignum.ToHexString(buffer, kBufferSize));
1485 CHECK_EQ("10000000000000000000000000", buffer);
1486
1487 bignum.AssignPowerUInt16(17, 0);
1488 CHECK(bignum.ToHexString(buffer, kBufferSize));
1489 CHECK_EQ("1", buffer);
1490
1491 bignum.AssignPowerUInt16(17, 99);
1492 CHECK(bignum.ToHexString(buffer, kBufferSize));
1493 CHECK_EQ("1942BB9853FAD924A3D4DD92B89B940E0207BEF05DB9C26BC1B757"
1494 "80BE0C5A2C2990E02A681224F34ED68558CE4C6E33760931",
1495 buffer);
1496
1497 bignum.AssignPowerUInt16(0xFFFF, 99);
1498 CHECK(bignum.ToHexString(buffer, kBufferSize));
1499 CHECK_EQ("FF9D12F09B886C54E77E7439C7D2DED2D34F669654C0C2B6B8C288250"
1500 "5A2211D0E3DC9A61831349EAE674B11D56E3049D7BD79DAAD6C9FA2BA"
1501 "528E3A794299F2EE9146A324DAFE3E88967A0358233B543E233E575B9"
1502 "DD4E3AA7942146426C328FF55BFD5C45E0901B1629260AF9AE2F310C5"
1503 "50959FAF305C30116D537D80CF6EBDBC15C5694062AF1AC3D956D0A41"
1504 "B7E1B79FF11E21D83387A1CE1F5882B31E4B5D8DE415BDBE6854466DF"
1505 "343362267A7E8833119D31D02E18DB5B0E8F6A64B0ED0D0062FFFF",
1506 buffer);
1507 }
1508