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