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