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