1 /* GENERATED SOURCE. DO NOT MODIFY. */ 2 // 2016 and later: Unicode, Inc. and others. 3 // License & terms of use: http://www.unicode.org/copyright.html#License 4 /* 5 ******************************************************************************* 6 * Copyright (C) 2000-2015, International Business Machines Corporation and 7 * others. All Rights Reserved. 8 ******************************************************************************* 9 */ 10 /* Generated from 'DiagBigDecimal.nrx' 27 Mar 2000 22:38:44 [v1.162] */ 11 /* Options: Binary Comments Crossref Format Java Logo Trace1 Verbose3 */ 12 /* The generated code has been manually modified. */ 13 package android.icu.dev.test.bigdec; 14 15 import java.math.BigInteger; 16 17 import org.junit.Test; 18 import org.junit.runner.RunWith; 19 import org.junit.runners.JUnit4; 20 21 import android.icu.dev.test.TestFmwk; 22 import android.icu.dev.test.TestUtil; 23 import android.icu.dev.test.TestUtil.JavaVendor; 24 import android.icu.math.BigDecimal; 25 import android.icu.testsharding.MainTestShard; 26 27 /* ------------------------------------------------------------------ */ 28 /* Decimal diagnostic tests mfc */ 29 /* Copyright (c) IBM Corporation 1996-2010. All Rights Reserved. */ 30 /* ------------------------------------------------------------------ */ 31 /* DiagBigDecimal */ 32 /* */ 33 /* A class that tests the BigDecimal and MathContext classes. */ 34 /* */ 35 /* The tests here are derived from or cover the same paths as: */ 36 /* -- ANSI X3-274 testcases */ 37 /* -- Java JCK testcases */ 38 /* -- NetRexx testcases */ 39 /* -- VM/CMS S/370 REXX implementation testcases [1981+] */ 40 /* -- IBM Vienna Laboratory Rexx compiler testcases [1988+] */ 41 /* -- New testcases */ 42 /* */ 43 /* The authoritative sources for how the underlying technology */ 44 /* (arithmetic) should work are: */ 45 /* -- for digits=0 (fixed point): java.math.BigDecimal */ 46 /* -- for digits>0 (floating point): ANSI X3.274-1996 + errata */ 47 /* */ 48 /* ------------------------------------------------------------------ */ 49 /* Change list */ 50 /* 1997.09.05 Initial implementation, from DiagRexx [NetRexx tests] */ 51 /* 1998.05.02 0.07 changes (e.g., compareTo) */ 52 /* 1998.06.06 Rounding modes and format additions */ 53 /* 1998.06.25 Rename from DiagDecimal; make stand-alone [add */ 54 /* DiagException as a Minor class] */ 55 /* 1998.06.27 Start adding testcases for DIGITS=0/FORM=PLAIN cases */ 56 /* Reorganize for faster trace compilation */ 57 /* 1998.06.28 new: valueof, scale, movePointX, unscaledValue, etc. */ 58 /* 1998.07.07 Scaled divide */ 59 /* 1998.07.08 setScale */ 60 /* 1998.07.15 new scaffolding (Minor Test class) -- see diagabs */ 61 /* 1998.12.14 add toBigDecimal and BigDecimal(java.math.BigDecimal) */ 62 /* 1999.02.04 number preparation rounds instead of digits+1 trunc */ 63 /* 1999.02.09 format method now only has two signatures */ 64 /* 1999.02.27 no longer use Rexx class or RexxIO class */ 65 /* 1999.03.05 add MathContext tests */ 66 /* 1999.03.05 update for 0.96 [no null settings, etc.] */ 67 /* drop sundry constructors; no blanks; char[] gets ints */ 68 /* drop sundry converters, add Exact converters */ 69 /* 1999.05.27 additional tests for scaled arithmetic */ 70 /* 1999.06.29 additional tests for exponent overflows */ 71 /* 1999.07.03 add 'continue' option */ 72 /* 1999.07.10 additional tests for scaled arithmetic */ 73 /* 1999.07.18 randomly-generated tests added for base operators */ 74 /* 1999.10.28 weird intValueExact bad cases */ 75 /* 1999.12.21 multiplication fast path failure and edge cases */ 76 /* 2000.01.01 copyright update */ 77 /* 2000.03.26 cosmetic updates; add extra format() testcases */ 78 /* 2000.03.27 1.00 move to android.icu.math package; open source release; */ 79 /* change to javadoc comments */ 80 /* ------------------------------------------------------------------ */ 81 82 // note BINARY for conversions checking 83 84 /** 85 * The <code>DiagBigDecimal</code> class forms a standalone test suite for the 86 * <code>android.icu.math.BigDecimal</code> and 87 * <code>android.icu.math.MathContext</code> classes (or, by changing the 88 * <code>package</code> statement, other classes of the same names and 89 * definition in other packages). It may also be used as a constructed object to 90 * embed the tests in an external test harness. 91 * <p> 92 * The tests are collected into <i>groups</i>, each corresponding to a tested 93 * method or a more general grouping. By default, when run from the static 94 * {@link #main(java.lang.String[])} method, the run will end if any test fails 95 * in a group. The <code>continue</code> argument may be specified to force 96 * the tests to run to completion. 97 * 98 * @see android.icu.math.BigDecimal 99 * @see android.icu.math.MathContext 100 * @version 1.00 2000.03.27 101 * @author Mike Cowlishaw 102 */ 103 104 @MainTestShard 105 @RunWith(JUnit4.class) 106 public class DiagBigDecimalTest extends TestFmwk { 107 private static final android.icu.math.BigDecimal zero = android.icu.math.BigDecimal.ZERO; 108 private static final android.icu.math.BigDecimal one = android.icu.math.BigDecimal.ONE; 109 private static final android.icu.math.BigDecimal two = new android.icu.math.BigDecimal(2); 110 private static final android.icu.math.BigDecimal ten = android.icu.math.BigDecimal.TEN; 111 private static final android.icu.math.BigDecimal tenlong = new android.icu.math.BigDecimal((long) 1234554321); // 10-digiter 112 113 /* Some context objects -- [some of these are checked later] */ 114 private static final android.icu.math.MathContext mcdef = android.icu.math.MathContext.DEFAULT; 115 private static final android.icu.math.MathContext mc3 = new android.icu.math.MathContext(3); 116 private static final android.icu.math.MathContext mc6 = new android.icu.math.MathContext(6); 117 private static final android.icu.math.MathContext mc9 = new android.icu.math.MathContext(9); 118 private static final android.icu.math.MathContext mc50 = new android.icu.math.MathContext(50); 119 private static final android.icu.math.MathContext mcs = new android.icu.math.MathContext(9, android.icu.math.MathContext.SCIENTIFIC); 120 private static final android.icu.math.MathContext mce = new android.icu.math.MathContext(9, android.icu.math.MathContext.ENGINEERING); 121 private static final android.icu.math.MathContext mcld = new android.icu.math.MathContext(9, android.icu.math.MathContext.SCIENTIFIC, true); // lost digits 122 private static final android.icu.math.MathContext mcld0 = new android.icu.math.MathContext(0, android.icu.math.MathContext.SCIENTIFIC, true); // lost digits, digits=0 123 private static final android.icu.math.MathContext mcfd = new android.icu.math.MathContext(0, android.icu.math.MathContext.PLAIN); // fixed decimal style 124 125 /* boundary primitive values */ 126 private static final byte bmin = -128; 127 private static final byte bmax = 127; 128 private static final byte bzer = 0; 129 private static final byte bneg = -1; 130 private static final byte bpos = 1; 131 private static final int imin = -2147483648; 132 private static final int imax = 2147483647; 133 private static final int izer = 0; 134 private static final int ineg = -1; 135 private static final int ipos = 1; 136 private static final long lmin = -9223372036854775808L; 137 private static final long lmax = 9223372036854775807L; 138 private static final long lzer = 0; 139 private static final long lneg = -1; 140 private static final long lpos = 1; 141 private static final short smin = -32768; 142 private static final short smax = 32767; 143 private static final short szer = (short) 0; 144 private static final short sneg = (short) (-1); 145 private static final short spos = (short) 1; 146 147 /** 148 * Constructs a <code>DiagBigDecimal</code> test suite. 149 * <p> 150 * Invoke its {@link #diagrun} method to run the tests. 151 */ 152 153 public DiagBigDecimalTest() { 154 super(); 155 } 156 157 static final boolean isJDK15OrLater = 158 TestUtil.getJavaVendor() == JavaVendor.Android || 159 TestUtil.getJavaVersion() >= 5; 160 161 162 /*--------------------------------------------------------------------*/ 163 /* Diagnostic group methods */ 164 /*--------------------------------------------------------------------*/ 165 166 /** Test constructors (and {@link #toString()} for equalities). */ 167 @Test 168 public void diagconstructors() { 169 boolean flag = false; 170 java.lang.String num; 171 java.math.BigInteger bip; 172 java.math.BigInteger biz; 173 java.math.BigInteger bin; 174 android.icu.math.BigDecimal bda; 175 android.icu.math.BigDecimal bdb; 176 android.icu.math.BigDecimal bmc; 177 android.icu.math.BigDecimal bmd; 178 android.icu.math.BigDecimal bme; 179 java.lang.RuntimeException e = null; 180 char ca[]; 181 double dzer; 182 double dpos; 183 double dneg; 184 double dpos5; 185 double dneg5; 186 double dmin; 187 double dmax; 188 double d; 189 java.lang.String badstrings[]; 190 int i = 0; 191 192 // constants [statically-called constructors] 193 TestFmwk.assertTrue("con001", (android.icu.math.BigDecimal.ZERO.toString()).equals("0")); 194 TestFmwk.assertTrue("con002", (android.icu.math.BigDecimal.ONE.toString()).equals("1")); 195 TestFmwk.assertTrue("con003", (android.icu.math.BigDecimal.TEN.toString()).equals("10")); 196 TestFmwk.assertTrue("con004", (android.icu.math.BigDecimal.ZERO.intValueExact()) == 0); 197 TestFmwk.assertTrue("con005", (android.icu.math.BigDecimal.ONE.intValueExact()) == 1); 198 TestFmwk.assertTrue("con006", (android.icu.math.BigDecimal.TEN.intValueExact()) == 10); 199 200 // [java.math.] BigDecimal 201 TestFmwk.assertTrue("cbd001", ((new android.icu.math.BigDecimal(new java.math.BigDecimal("0"))).toString()).equals("0")); 202 TestFmwk.assertTrue("cbd002", ((new android.icu.math.BigDecimal(new java.math.BigDecimal("1"))).toString()).equals("1")); 203 TestFmwk.assertTrue("cbd003", ((new android.icu.math.BigDecimal(new java.math.BigDecimal("10"))).toString()).equals("10")); 204 TestFmwk.assertTrue("cbd004", ((new android.icu.math.BigDecimal(new java.math.BigDecimal("1000"))).toString()).equals("1000")); 205 TestFmwk.assertTrue("cbd005", ((new android.icu.math.BigDecimal(new java.math.BigDecimal("10.0"))).toString()).equals("10.0")); 206 TestFmwk.assertTrue("cbd006", ((new android.icu.math.BigDecimal(new java.math.BigDecimal("10.1"))).toString()).equals("10.1")); 207 TestFmwk.assertTrue("cbd007", ((new android.icu.math.BigDecimal(new java.math.BigDecimal("-1.1"))).toString()).equals("-1.1")); 208 TestFmwk.assertTrue("cbd008", ((new android.icu.math.BigDecimal(new java.math.BigDecimal("-9.0"))).toString()).equals("-9.0")); 209 TestFmwk.assertTrue("cbd009", ((new android.icu.math.BigDecimal(new java.math.BigDecimal("0.9"))).toString()).equals("0.9")); 210 211 num = "123456789.123456789"; 212 TestFmwk.assertTrue("cbd010", ((new android.icu.math.BigDecimal(new java.math.BigDecimal(num))).toString()).equals(num)); 213 num = "123456789.000000000"; 214 TestFmwk.assertTrue("cbd011", ((new android.icu.math.BigDecimal(new java.math.BigDecimal(num))).toString()).equals(num)); 215 num = "123456789000000000"; 216 TestFmwk.assertTrue("cbd012", ((new android.icu.math.BigDecimal(new java.math.BigDecimal(num))).toString()).equals(num)); 217 num = "0.00000123456789"; 218 TestFmwk.assertTrue("cbd013", ((new android.icu.math.BigDecimal(new java.math.BigDecimal(num))).toString()).equals(num)); 219 num = "0.000000123456789"; 220 221 // ignore format change issues with 1.5 222 if (!isJDK15OrLater) 223 TestFmwk.assertTrue("cbd014", ((new android.icu.math.BigDecimal(new java.math.BigDecimal(num))).toString()).equals(num)); 224 225 try { 226 new android.icu.math.BigDecimal((java.math.BigDecimal) null); 227 flag = false; 228 } catch (java.lang.NullPointerException $3) { 229 flag = true; 230 }/* checknull */ 231 TestFmwk.assertTrue("cbi015", flag); 232 233 // BigInteger 234 bip = new BigInteger("987654321987654321987654321"); // biggie +ve 235 biz = new BigInteger("0"); // biggie 0 236 bin = new BigInteger("-12345678998765432112345678"); // biggie -ve 237 TestFmwk.assertTrue("cbi001", ((new android.icu.math.BigDecimal(bip)).toString()).equals(bip.toString())); 238 TestFmwk.assertTrue("cbi002", ((new android.icu.math.BigDecimal(biz)).toString()).equals("0")); 239 TestFmwk.assertTrue("cbi003", ((new android.icu.math.BigDecimal(bin)).toString()).equals(bin.toString())); 240 try { 241 new android.icu.math.BigDecimal((java.math.BigInteger) null); 242 flag = false; 243 } catch (java.lang.NullPointerException $4) { 244 flag = true; 245 }/* checknull */ 246 TestFmwk.assertTrue("cbi004", flag); 247 248 // BigInteger with scale 249 bip = new BigInteger("123456789"); // bigish 250 bda = new android.icu.math.BigDecimal(bip); 251 bdb = new android.icu.math.BigDecimal(bip, 5); 252 bmc = new android.icu.math.BigDecimal(bip, 15); 253 TestFmwk.assertTrue("cbs001", (bda.toString()).equals("123456789")); 254 TestFmwk.assertTrue("cbs002", (bdb.toString()).equals("1234.56789")); 255 TestFmwk.assertTrue("cbs003", (bmc.toString()).equals("0.000000123456789")); 256 bip = new BigInteger("123456789123456789123456789"); // biggie 257 bda = new android.icu.math.BigDecimal(bip); 258 bdb = new android.icu.math.BigDecimal(bip, 7); 259 bmc = new android.icu.math.BigDecimal(bip, 13); 260 bmd = new android.icu.math.BigDecimal(bip, 19); 261 bme = new android.icu.math.BigDecimal(bip, 29); 262 TestFmwk.assertTrue("cbs011", (bda.toString()).equals("123456789123456789123456789")); 263 TestFmwk.assertTrue("cbs012", (bdb.toString()).equals("12345678912345678912.3456789")); 264 TestFmwk.assertTrue("cbs013", (bmc.toString()).equals("12345678912345.6789123456789")); 265 TestFmwk.assertTrue("cbs014", (bmd.toString()).equals("12345678.9123456789123456789")); 266 TestFmwk.assertTrue("cbs015", (bme.toString()).equals("0.00123456789123456789123456789")); 267 try { 268 new android.icu.math.BigDecimal((java.math.BigInteger) null, 1); 269 flag = false; 270 } catch (java.lang.NullPointerException $5) { 271 flag = true; 272 }/* checknull */ 273 TestFmwk.assertTrue("cbs004", flag); 274 try { 275 new android.icu.math.BigDecimal(bip, -8); 276 flag = false; 277 } catch (java.lang.RuntimeException $6) { 278 e = $6; 279 flag = (e.getMessage()).equals("Negative scale: -8"); 280 }/* checkscale */ 281 TestFmwk.assertTrue("cbs005", flag); 282 283 // char[] 284 // We just test it's there 285 // Functionality is tested by BigDecimal(String). 286 ca = ("123.45").toCharArray(); 287 TestFmwk.assertTrue("cca001", ((new android.icu.math.BigDecimal(ca)).toString()).equals("123.45")); 288 try { 289 new android.icu.math.BigDecimal((char[]) null); 290 flag = false; 291 } catch (java.lang.NullPointerException $7) { 292 flag = true; 293 }/* checknull */ 294 TestFmwk.assertTrue("cca010", flag); 295 296 // char[],int,int 297 // We just test it's there, and that offsets work. 298 // Functionality is tested by BigDecimal(String). 299 ca = ("123.45").toCharArray(); 300 TestFmwk.assertTrue("cca101", ((new android.icu.math.BigDecimal(ca, 0, 6)).toString()).equals("123.45")); 301 TestFmwk.assertTrue("cca102", ((new android.icu.math.BigDecimal(ca, 1, 5)).toString()).equals("23.45")); 302 TestFmwk.assertTrue("cca103", ((new android.icu.math.BigDecimal(ca, 2, 4)).toString()).equals("3.45")); 303 TestFmwk.assertTrue("cca104", ((new android.icu.math.BigDecimal(ca, 3, 3)).toString()).equals("0.45")); 304 TestFmwk.assertTrue("cca105", ((new android.icu.math.BigDecimal(ca, 4, 2)).toString()).equals("45")); 305 TestFmwk.assertTrue("cca106", ((new android.icu.math.BigDecimal(ca, 5, 1)).toString()).equals("5")); 306 307 TestFmwk.assertTrue("cca110", ((new android.icu.math.BigDecimal(ca, 0, 1)).toString()).equals("1")); 308 TestFmwk.assertTrue("cca111", ((new android.icu.math.BigDecimal(ca, 1, 1)).toString()).equals("2")); 309 TestFmwk.assertTrue("cca112", ((new android.icu.math.BigDecimal(ca, 2, 1)).toString()).equals("3")); 310 TestFmwk.assertTrue("cca113", ((new android.icu.math.BigDecimal(ca, 4, 1)).toString()).equals("4")); 311 312 TestFmwk.assertTrue("cca120", ((new android.icu.math.BigDecimal(ca, 0, 2)).toString()).equals("12")); 313 TestFmwk.assertTrue("cca121", ((new android.icu.math.BigDecimal(ca, 1, 2)).toString()).equals("23")); 314 TestFmwk.assertTrue("cca122", ((new android.icu.math.BigDecimal(ca, 2, 2)).toString()).equals("3")); 315 TestFmwk.assertTrue("cca123", ((new android.icu.math.BigDecimal(ca, 3, 2)).toString()).equals("0.4")); 316 317 TestFmwk.assertTrue("cca130", ((new android.icu.math.BigDecimal(ca, 0, 3)).toString()).equals("123")); 318 TestFmwk.assertTrue("cca131", ((new android.icu.math.BigDecimal(ca, 1, 3)).toString()).equals("23")); 319 TestFmwk.assertTrue("cca132", ((new android.icu.math.BigDecimal(ca, 2, 3)).toString()).equals("3.4")); 320 321 TestFmwk.assertTrue("cca140", ((new android.icu.math.BigDecimal(ca, 0, 4)).toString()).equals("123")); 322 TestFmwk.assertTrue("cca141", ((new android.icu.math.BigDecimal(ca, 1, 4)).toString()).equals("23.4")); 323 324 TestFmwk.assertTrue("cca150", ((new android.icu.math.BigDecimal(ca, 0, 5)).toString()).equals("123.4")); 325 326 // a couple of oddies 327 ca = ("x23.4x").toCharArray(); 328 TestFmwk.assertTrue("cca160", ((new android.icu.math.BigDecimal(ca, 1, 4)).toString()).equals("23.4")); 329 TestFmwk.assertTrue("cca161", ((new android.icu.math.BigDecimal(ca, 1, 1)).toString()).equals("2")); 330 TestFmwk.assertTrue("cca162", ((new android.icu.math.BigDecimal(ca, 4, 1)).toString()).equals("4")); 331 332 ca = ("0123456789.9876543210").toCharArray(); 333 TestFmwk.assertTrue("cca163", ((new android.icu.math.BigDecimal(ca, 0, 21)).toString()).equals("123456789.9876543210")); 334 TestFmwk.assertTrue("cca164", ((new android.icu.math.BigDecimal(ca, 1, 20)).toString()).equals("123456789.9876543210")); 335 TestFmwk.assertTrue("cca165", ((new android.icu.math.BigDecimal(ca, 2, 19)).toString()).equals("23456789.9876543210")); 336 TestFmwk.assertTrue("cca166", ((new android.icu.math.BigDecimal(ca, 2, 18)).toString()).equals("23456789.987654321")); 337 TestFmwk.assertTrue("cca167", ((new android.icu.math.BigDecimal(ca, 2, 17)).toString()).equals("23456789.98765432")); 338 TestFmwk.assertTrue("cca168", ((new android.icu.math.BigDecimal(ca, 2, 16)).toString()).equals("23456789.9876543")); 339 340 try { 341 new android.icu.math.BigDecimal((char[]) null, 0, 1); 342 flag = false; 343 } catch (java.lang.NullPointerException $8) { 344 flag = true; 345 }/* checknull */ 346 TestFmwk.assertTrue("cca200", flag); 347 348 try { 349 new android.icu.math.BigDecimal("123".toCharArray(), 0, 0); 350 flag = false; 351 } catch (java.lang.NumberFormatException $9) { 352 flag = true; 353 }/* checklen */ 354 TestFmwk.assertTrue("cca201", flag); 355 356 try { 357 new android.icu.math.BigDecimal("123".toCharArray(), 2, 4); 358 flag = false; 359 } catch (java.lang.RuntimeException $10) { // anything OK 360 flag = true; 361 }/* checkbound */ 362 TestFmwk.assertTrue("cca202", flag); 363 try { 364 new android.icu.math.BigDecimal("123".toCharArray(), -1, 2); 365 flag = false; 366 } catch (java.lang.RuntimeException $11) { // anything OK 367 flag = true; 368 }/* checkbound2 */ 369 TestFmwk.assertTrue("cca203", flag); 370 try { 371 new android.icu.math.BigDecimal("123".toCharArray(), 1, -2); 372 flag = false; 373 } catch (java.lang.RuntimeException $12) { // anything OK 374 flag = true; 375 }/* checkbound3 */ 376 TestFmwk.assertTrue("cca204", flag); 377 378 // double [deprecated] 379 // Note that many of these differ from the valueOf(double) results. 380 dzer = 0; 381 dpos = 1; 382 dpos = dpos / (10); 383 dneg = -dpos; 384 TestFmwk.assertTrue("cdo001", ((new android.icu.math.BigDecimal(dneg)).toString()).equals("-0.1000000000000000055511151231257827021181583404541015625")); 385 386 TestFmwk.assertTrue("cdo002", ((new android.icu.math.BigDecimal(dzer)).toString()).equals("0")); // NB, not '0.0' 387 TestFmwk.assertTrue("cdo003", ((new android.icu.math.BigDecimal(dpos)).toString()).equals("0.1000000000000000055511151231257827021181583404541015625")); 388 389 dpos5 = 0.5D; 390 dneg5 = -dpos5; 391 TestFmwk.assertTrue("cdo004", ((new android.icu.math.BigDecimal(dneg5)).toString()).equals("-0.5")); 392 TestFmwk.assertTrue("cdo005", ((new android.icu.math.BigDecimal(dpos5)).toString()).equals("0.5")); 393 dmin = java.lang.Double.MIN_VALUE; 394 dmax = java.lang.Double.MAX_VALUE; 395 if (!isJDK15OrLater) // for some reason we format using scientific 396 // notation on 1.5 after 30 decimals or so 397 TestFmwk.assertTrue("cdo006", ((new android.icu.math.BigDecimal(dmin)).toString()).equals("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004940656458412465441765687928682213723650598026143247644255856825006755072702087518652998363616359923797965646954457177309266567103559397963987747960107818781263007131903114045278458171678489821036887186360569987307230500063874091535649843873124733972731696151400317153853980741262385655911710266585566867681870395603106249319452715914924553293054565444011274801297099995419319894090804165633245247571478690147267801593552386115501348035264934720193790268107107491703332226844753335720832431936092382893458368060106011506169809753078342277318329247904982524730776375927247874656084778203734469699533647017972677717585125660551199131504891101451037862738167250955837389733598993664809941164205702637090279242767544565229087538682506419718265533447265625")); 398 399 TestFmwk.assertTrue("cdo007", ((new android.icu.math.BigDecimal(dmax)).toString()).equals("179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368")); 400 401 // nasties 402 d = 9; 403 d = d / (10); 404 TestFmwk.assertTrue("cdo010", ((new android.icu.math.BigDecimal(d)).toString()).equals("0.90000000000000002220446049250313080847263336181640625")); 405 406 d = d / (10); 407 TestFmwk.assertTrue("cdo011", ((new android.icu.math.BigDecimal(d)).toString()).equals("0.0899999999999999966693309261245303787291049957275390625")); 408 409 d = d / (10); 410 TestFmwk.assertTrue("cdo012", ((new android.icu.math.BigDecimal(d)).toString()).equals("0.00899999999999999931998839741709161899052560329437255859375")); 411 412 d = d / (10); 413 TestFmwk.assertTrue("cdo013", ((new android.icu.math.BigDecimal(d)).toString()).equals("0.00089999999999999997536692664112933925935067236423492431640625")); 414 415 d = d / (10); 416 TestFmwk.assertTrue("cdo014", ((new android.icu.math.BigDecimal(d)).toString()).equals("0.00008999999999999999211568180168541175589780323207378387451171875")); 417 418 d = d / (10); 419 TestFmwk.assertTrue("cdo015", ((new android.icu.math.BigDecimal(d)).toString()).equals("0.00000899999999999999853394182236510090433512232266366481781005859375")); 420 421 d = d / (10); 422 if (!isJDK15OrLater) 423 TestFmwk.assertTrue("cdo016", ((new android.icu.math.BigDecimal(d)).toString()).equals("0.000000899999999999999853394182236510090433512232266366481781005859375")); 424 425 d = d / (10); 426 if (!isJDK15OrLater) 427 TestFmwk.assertTrue("cdo017", ((new android.icu.math.BigDecimal(d)).toString()).equals("0.0000000899999999999999853394182236510090433512232266366481781005859375")); 428 429 d = d / (10); 430 if (!isJDK15OrLater) 431 TestFmwk.assertTrue("cdo018", ((new android.icu.math.BigDecimal(d)).toString()).equals("0.000000008999999999999997872197332322678764437995369007694534957408905029296875")); 432 433 try { 434 new android.icu.math.BigDecimal( 435 java.lang.Double.POSITIVE_INFINITY); 436 flag = false; 437 } catch (java.lang.NumberFormatException $13) { 438 flag = true; 439 }/* checkpin */ 440 TestFmwk.assertTrue("cdo101", flag); 441 try { 442 new android.icu.math.BigDecimal( 443 java.lang.Double.NEGATIVE_INFINITY); 444 flag = false; 445 } catch (java.lang.NumberFormatException $14) { 446 flag = true; 447 }/* checknin */ 448 TestFmwk.assertTrue("cdo102", flag); 449 try { 450 new android.icu.math.BigDecimal(java.lang.Double.NaN); 451 flag = false; 452 } catch (java.lang.NumberFormatException $15) { 453 flag = true; 454 }/* checknan */ 455 TestFmwk.assertTrue("cdo103", flag); 456 457 // int 458 TestFmwk.assertTrue("cin001", ((new android.icu.math.BigDecimal(imin)).toString()).equals("-2147483648")); 459 TestFmwk.assertTrue("cin002", ((new android.icu.math.BigDecimal(imax)).toString()).equals("2147483647")); 460 TestFmwk.assertTrue("cin003", ((new android.icu.math.BigDecimal(ineg)).toString()).equals("-1")); 461 TestFmwk.assertTrue("cin004", ((new android.icu.math.BigDecimal(izer)).toString()).equals("0")); 462 TestFmwk.assertTrue("cin005", ((new android.icu.math.BigDecimal(ipos)).toString()).equals("1")); 463 TestFmwk.assertTrue("cin006", ((new android.icu.math.BigDecimal(10)).toString()).equals("10")); 464 TestFmwk.assertTrue("cin007", ((new android.icu.math.BigDecimal(9)).toString()).equals("9")); 465 TestFmwk.assertTrue("cin008", ((new android.icu.math.BigDecimal(5)).toString()).equals("5")); 466 TestFmwk.assertTrue("cin009", ((new android.icu.math.BigDecimal(2)).toString()).equals("2")); 467 TestFmwk.assertTrue("cin010", ((new android.icu.math.BigDecimal(-2)).toString()).equals("-2")); 468 TestFmwk.assertTrue("cin011", ((new android.icu.math.BigDecimal(-5)).toString()).equals("-5")); 469 TestFmwk.assertTrue("cin012", ((new android.icu.math.BigDecimal(-9)).toString()).equals("-9")); 470 TestFmwk.assertTrue("cin013", ((new android.icu.math.BigDecimal(-10)).toString()).equals("-10")); 471 TestFmwk.assertTrue("cin014", ((new android.icu.math.BigDecimal(-11)).toString()).equals("-11")); 472 TestFmwk.assertTrue("cin015", ((new android.icu.math.BigDecimal(-99)).toString()).equals("-99")); 473 TestFmwk.assertTrue("cin016", ((new android.icu.math.BigDecimal(-100)).toString()).equals("-100")); 474 TestFmwk.assertTrue("cin017", ((new android.icu.math.BigDecimal(-999)).toString()).equals("-999")); 475 TestFmwk.assertTrue("cin018", ((new android.icu.math.BigDecimal(-1000)).toString()).equals("-1000")); 476 477 TestFmwk.assertTrue("cin019", ((new android.icu.math.BigDecimal(11)).toString()).equals("11")); 478 TestFmwk.assertTrue("cin020", ((new android.icu.math.BigDecimal(99)).toString()).equals("99")); 479 TestFmwk.assertTrue("cin021", ((new android.icu.math.BigDecimal(100)).toString()).equals("100")); 480 TestFmwk.assertTrue("cin022", ((new android.icu.math.BigDecimal(999)).toString()).equals("999")); 481 TestFmwk.assertTrue("cin023", ((new android.icu.math.BigDecimal(1000)).toString()).equals("1000")); 482 483 // long 484 TestFmwk.assertTrue("clo001", ((new android.icu.math.BigDecimal(lmin)).toString()).equals("-9223372036854775808")); 485 TestFmwk.assertTrue("clo002", ((new android.icu.math.BigDecimal(lmax)).toString()).equals("9223372036854775807")); 486 TestFmwk.assertTrue("clo003", ((new android.icu.math.BigDecimal(lneg)).toString()).equals("-1")); 487 TestFmwk.assertTrue("clo004", ((new android.icu.math.BigDecimal(lzer)).toString()).equals("0")); 488 TestFmwk.assertTrue("clo005", ((new android.icu.math.BigDecimal(lpos)).toString()).equals("1")); 489 490 // String [many more examples are elsewhere] 491 // strings without E cannot generate E in result 492 TestFmwk.assertTrue("cst001", ((new android.icu.math.BigDecimal("12")).toString()).equals("12")); 493 TestFmwk.assertTrue("cst002", ((new android.icu.math.BigDecimal("-76")).toString()).equals("-76")); 494 TestFmwk.assertTrue("cst003", ((new android.icu.math.BigDecimal("12.76")).toString()).equals("12.76")); 495 TestFmwk.assertTrue("cst004", ((new android.icu.math.BigDecimal("+12.76")).toString()).equals("12.76")); 496 TestFmwk.assertTrue("cst005", ((new android.icu.math.BigDecimal("012.76")).toString()).equals("12.76")); 497 TestFmwk.assertTrue("cst006", ((new android.icu.math.BigDecimal("+0.003")).toString()).equals("0.003")); 498 TestFmwk.assertTrue("cst007", ((new android.icu.math.BigDecimal("17.")).toString()).equals("17")); 499 TestFmwk.assertTrue("cst008", ((new android.icu.math.BigDecimal(".5")).toString()).equals("0.5")); 500 TestFmwk.assertTrue("cst009", ((new android.icu.math.BigDecimal("044")).toString()).equals("44")); 501 TestFmwk.assertTrue("cst010", ((new android.icu.math.BigDecimal("0044")).toString()).equals("44")); 502 TestFmwk.assertTrue("cst011", ((new android.icu.math.BigDecimal("0.0005")).toString()).equals("0.0005")); 503 TestFmwk.assertTrue("cst012", ((new android.icu.math.BigDecimal("00.00005")).toString()).equals("0.00005")); 504 TestFmwk.assertTrue("cst013", ((new android.icu.math.BigDecimal("0.000005")).toString()).equals("0.000005")); 505 TestFmwk.assertTrue("cst014", ((new android.icu.math.BigDecimal("0.0000005")).toString()).equals("0.0000005")); // \NR 506 TestFmwk.assertTrue("cst015", ((new android.icu.math.BigDecimal("0.00000005")).toString()).equals("0.00000005")); // \NR 507 TestFmwk.assertTrue("cst016", ((new android.icu.math.BigDecimal("12345678.876543210")).toString()).equals("12345678.876543210")); 508 TestFmwk.assertTrue("cst017", ((new android.icu.math.BigDecimal("2345678.876543210")).toString()).equals("2345678.876543210")); 509 TestFmwk.assertTrue("cst018", ((new android.icu.math.BigDecimal("345678.876543210")).toString()).equals("345678.876543210")); 510 TestFmwk.assertTrue("cst019", ((new android.icu.math.BigDecimal("0345678.87654321")).toString()).equals("345678.87654321")); 511 TestFmwk.assertTrue("cst020", ((new android.icu.math.BigDecimal("345678.8765432")).toString()).equals("345678.8765432")); 512 TestFmwk.assertTrue("cst021", ((new android.icu.math.BigDecimal("+345678.8765432")).toString()).equals("345678.8765432")); 513 TestFmwk.assertTrue("cst022", ((new android.icu.math.BigDecimal("+0345678.8765432")).toString()).equals("345678.8765432")); 514 TestFmwk.assertTrue("cst023", ((new android.icu.math.BigDecimal("+00345678.8765432")).toString()).equals("345678.8765432")); 515 TestFmwk.assertTrue("cst024", ((new android.icu.math.BigDecimal("-345678.8765432")).toString()).equals("-345678.8765432")); 516 TestFmwk.assertTrue("cst025", ((new android.icu.math.BigDecimal("-0345678.8765432")).toString()).equals("-345678.8765432")); 517 TestFmwk.assertTrue("cst026", ((new android.icu.math.BigDecimal("-00345678.8765432")).toString()).equals("-345678.8765432")); 518 519 // exotics -- 520 TestFmwk.assertTrue("cst035", ((new android.icu.math.BigDecimal("\u0e57.\u0e50")).toString()).equals("7.0")); 521 TestFmwk.assertTrue("cst036", ((new android.icu.math.BigDecimal("\u0b66.\u0b67")).toString()).equals("0.1")); 522 TestFmwk.assertTrue("cst037", ((new android.icu.math.BigDecimal("\u0b66\u0b66")).toString()).equals("0")); 523 TestFmwk.assertTrue("cst038", ((new android.icu.math.BigDecimal("\u0b6a\u0b66")).toString()).equals("40")); 524 525 // strings with E 526 TestFmwk.assertTrue("cst040", ((new android.icu.math.BigDecimal("1E+9")).toString()).equals("1E+9")); 527 TestFmwk.assertTrue("cst041", ((new android.icu.math.BigDecimal("1e+09")).toString()).equals("1E+9")); 528 TestFmwk.assertTrue("cst042", ((new android.icu.math.BigDecimal("1E+90")).toString()).equals("1E+90")); 529 TestFmwk.assertTrue("cst043", ((new android.icu.math.BigDecimal("+1E+009")).toString()).equals("1E+9")); 530 TestFmwk.assertTrue("cst044", ((new android.icu.math.BigDecimal("0E+9")).toString()).equals("0")); 531 TestFmwk.assertTrue("cst045", ((new android.icu.math.BigDecimal("1E+9")).toString()).equals("1E+9")); 532 TestFmwk.assertTrue("cst046", ((new android.icu.math.BigDecimal("1E+09")).toString()).equals("1E+9")); 533 TestFmwk.assertTrue("cst047", ((new android.icu.math.BigDecimal("1e+90")).toString()).equals("1E+90")); 534 TestFmwk.assertTrue("cst048", ((new android.icu.math.BigDecimal("1E+009")).toString()).equals("1E+9")); 535 TestFmwk.assertTrue("cst049", ((new android.icu.math.BigDecimal("0E+9")).toString()).equals("0")); 536 TestFmwk.assertTrue("cst050", ((new android.icu.math.BigDecimal("1E9")).toString()).equals("1E+9")); 537 TestFmwk.assertTrue("cst051", ((new android.icu.math.BigDecimal("1e09")).toString()).equals("1E+9")); 538 TestFmwk.assertTrue("cst052", ((new android.icu.math.BigDecimal("1E90")).toString()).equals("1E+90")); 539 TestFmwk.assertTrue("cst053", ((new android.icu.math.BigDecimal("1E009")).toString()).equals("1E+9")); 540 TestFmwk.assertTrue("cst054", ((new android.icu.math.BigDecimal("0E9")).toString()).equals("0")); 541 TestFmwk.assertTrue("cst055", ((new android.icu.math.BigDecimal("0.000e+0")).toString()).equals("0")); 542 TestFmwk.assertTrue("cst056", ((new android.icu.math.BigDecimal("0.000E-1")).toString()).equals("0")); 543 TestFmwk.assertTrue("cst057", ((new android.icu.math.BigDecimal("4E+9")).toString()).equals("4E+9")); 544 TestFmwk.assertTrue("cst058", ((new android.icu.math.BigDecimal("44E+9")).toString()).equals("4.4E+10")); 545 TestFmwk.assertTrue("cst059", ((new android.icu.math.BigDecimal("0.73e-7")).toString()).equals("7.3E-8")); 546 TestFmwk.assertTrue("cst060", ((new android.icu.math.BigDecimal("00E+9")).toString()).equals("0")); 547 TestFmwk.assertTrue("cst061", ((new android.icu.math.BigDecimal("00E-9")).toString()).equals("0")); 548 TestFmwk.assertTrue("cst062", ((new android.icu.math.BigDecimal("10E+9")).toString()).equals("1.0E+10")); 549 TestFmwk.assertTrue("cst063", ((new android.icu.math.BigDecimal("10E+09")).toString()).equals("1.0E+10")); 550 TestFmwk.assertTrue("cst064", ((new android.icu.math.BigDecimal("10e+90")).toString()).equals("1.0E+91")); 551 TestFmwk.assertTrue("cst065", ((new android.icu.math.BigDecimal("10E+009")).toString()).equals("1.0E+10")); 552 TestFmwk.assertTrue("cst066", ((new android.icu.math.BigDecimal("100e+9")).toString()).equals("1.00E+11")); 553 TestFmwk.assertTrue("cst067", ((new android.icu.math.BigDecimal("100e+09")).toString()).equals("1.00E+11")); 554 TestFmwk.assertTrue("cst068", ((new android.icu.math.BigDecimal("100E+90")).toString()).equals("1.00E+92")); 555 TestFmwk.assertTrue("cst069", ((new android.icu.math.BigDecimal("100e+009")).toString()).equals("1.00E+11")); 556 557 TestFmwk.assertTrue("cst070", ((new android.icu.math.BigDecimal("1.265")).toString()).equals("1.265")); 558 TestFmwk.assertTrue("cst071", ((new android.icu.math.BigDecimal("1.265E-20")).toString()).equals("1.265E-20")); 559 TestFmwk.assertTrue("cst072", ((new android.icu.math.BigDecimal("1.265E-8")).toString()).equals("1.265E-8")); 560 TestFmwk.assertTrue("cst073", ((new android.icu.math.BigDecimal("1.265E-4")).toString()).equals("1.265E-4")); 561 TestFmwk.assertTrue("cst074", ((new android.icu.math.BigDecimal("1.265E-3")).toString()).equals("1.265E-3")); 562 TestFmwk.assertTrue("cst075", ((new android.icu.math.BigDecimal("1.265E-2")).toString()).equals("1.265E-2")); 563 TestFmwk.assertTrue("cst076", ((new android.icu.math.BigDecimal("1.265E-1")).toString()).equals("1.265E-1")); 564 TestFmwk.assertTrue("cst077", ((new android.icu.math.BigDecimal("1.265E-0")).toString()).equals("1.265")); 565 TestFmwk.assertTrue("cst078", ((new android.icu.math.BigDecimal("1.265E+1")).toString()).equals("1.265E+1")); 566 TestFmwk.assertTrue("cst079", ((new android.icu.math.BigDecimal("1.265E+2")).toString()).equals("1.265E+2")); 567 TestFmwk.assertTrue("cst080", ((new android.icu.math.BigDecimal("1.265E+3")).toString()).equals("1.265E+3")); 568 TestFmwk.assertTrue("cst081", ((new android.icu.math.BigDecimal("1.265E+4")).toString()).equals("1.265E+4")); 569 TestFmwk.assertTrue("cst082", ((new android.icu.math.BigDecimal("1.265E+8")).toString()).equals("1.265E+8")); 570 TestFmwk.assertTrue("cst083", ((new android.icu.math.BigDecimal("1.265E+20")).toString()).equals("1.265E+20")); 571 572 TestFmwk.assertTrue("cst090", ((new android.icu.math.BigDecimal("12.65")).toString()).equals("12.65")); 573 TestFmwk.assertTrue("cst091", ((new android.icu.math.BigDecimal("12.65E-20")).toString()).equals("1.265E-19")); 574 TestFmwk.assertTrue("cst092", ((new android.icu.math.BigDecimal("12.65E-8")).toString()).equals("1.265E-7")); 575 TestFmwk.assertTrue("cst093", ((new android.icu.math.BigDecimal("12.65E-4")).toString()).equals("1.265E-3")); 576 TestFmwk.assertTrue("cst094", ((new android.icu.math.BigDecimal("12.65E-3")).toString()).equals("1.265E-2")); 577 TestFmwk.assertTrue("cst095", ((new android.icu.math.BigDecimal("12.65E-2")).toString()).equals("1.265E-1")); 578 TestFmwk.assertTrue("cst096", ((new android.icu.math.BigDecimal("12.65E-1")).toString()).equals("1.265")); 579 TestFmwk.assertTrue("cst097", ((new android.icu.math.BigDecimal("12.65E-0")).toString()).equals("1.265E+1")); 580 TestFmwk.assertTrue("cst098", ((new android.icu.math.BigDecimal("12.65E+1")).toString()).equals("1.265E+2")); 581 TestFmwk.assertTrue("cst099", ((new android.icu.math.BigDecimal("12.65E+2")).toString()).equals("1.265E+3")); 582 TestFmwk.assertTrue("cst100", ((new android.icu.math.BigDecimal("12.65E+3")).toString()).equals("1.265E+4")); 583 TestFmwk.assertTrue("cst101", ((new android.icu.math.BigDecimal("12.65E+4")).toString()).equals("1.265E+5")); 584 TestFmwk.assertTrue("cst102", ((new android.icu.math.BigDecimal("12.65E+8")).toString()).equals("1.265E+9")); 585 TestFmwk.assertTrue("cst103", ((new android.icu.math.BigDecimal("12.65E+20")).toString()).equals("1.265E+21")); 586 587 TestFmwk.assertTrue("cst110", ((new android.icu.math.BigDecimal("126.5")).toString()).equals("126.5")); 588 TestFmwk.assertTrue("cst111", ((new android.icu.math.BigDecimal("126.5E-20")).toString()).equals("1.265E-18")); 589 TestFmwk.assertTrue("cst112", ((new android.icu.math.BigDecimal("126.5E-8")).toString()).equals("1.265E-6")); 590 TestFmwk.assertTrue("cst113", ((new android.icu.math.BigDecimal("126.5E-4")).toString()).equals("1.265E-2")); 591 TestFmwk.assertTrue("cst114", ((new android.icu.math.BigDecimal("126.5E-3")).toString()).equals("1.265E-1")); 592 TestFmwk.assertTrue("cst115", ((new android.icu.math.BigDecimal("126.5E-2")).toString()).equals("1.265")); 593 TestFmwk.assertTrue("cst116", ((new android.icu.math.BigDecimal("126.5E-1")).toString()).equals("1.265E+1")); 594 TestFmwk.assertTrue("cst117", ((new android.icu.math.BigDecimal("126.5E-0")).toString()).equals("1.265E+2")); 595 TestFmwk.assertTrue("cst118", ((new android.icu.math.BigDecimal("126.5E+1")).toString()).equals("1.265E+3")); 596 TestFmwk.assertTrue("cst119", ((new android.icu.math.BigDecimal("126.5E+2")).toString()).equals("1.265E+4")); 597 TestFmwk.assertTrue("cst120", ((new android.icu.math.BigDecimal("126.5E+3")).toString()).equals("1.265E+5")); 598 TestFmwk.assertTrue("cst121", ((new android.icu.math.BigDecimal("126.5E+4")).toString()).equals("1.265E+6")); 599 TestFmwk.assertTrue("cst122", ((new android.icu.math.BigDecimal("126.5E+8")).toString()).equals("1.265E+10")); 600 TestFmwk.assertTrue("cst123", ((new android.icu.math.BigDecimal("126.5E+20")).toString()).equals("1.265E+22")); 601 602 TestFmwk.assertTrue("cst130", ((new android.icu.math.BigDecimal("1265")).toString()).equals("1265")); 603 TestFmwk.assertTrue("cst131", ((new android.icu.math.BigDecimal("1265E-20")).toString()).equals("1.265E-17")); 604 TestFmwk.assertTrue("cst132", ((new android.icu.math.BigDecimal("1265E-8")).toString()).equals("1.265E-5")); 605 TestFmwk.assertTrue("cst133", ((new android.icu.math.BigDecimal("1265E-4")).toString()).equals("1.265E-1")); 606 TestFmwk.assertTrue("cst134", ((new android.icu.math.BigDecimal("1265E-3")).toString()).equals("1.265")); 607 TestFmwk.assertTrue("cst135", ((new android.icu.math.BigDecimal("1265E-2")).toString()).equals("1.265E+1")); 608 TestFmwk.assertTrue("cst136", ((new android.icu.math.BigDecimal("1265E-1")).toString()).equals("1.265E+2")); 609 TestFmwk.assertTrue("cst137", ((new android.icu.math.BigDecimal("1265E-0")).toString()).equals("1.265E+3")); 610 TestFmwk.assertTrue("cst138", ((new android.icu.math.BigDecimal("1265E+1")).toString()).equals("1.265E+4")); 611 TestFmwk.assertTrue("cst139", ((new android.icu.math.BigDecimal("1265E+2")).toString()).equals("1.265E+5")); 612 TestFmwk.assertTrue("cst140", ((new android.icu.math.BigDecimal("1265E+3")).toString()).equals("1.265E+6")); 613 TestFmwk.assertTrue("cst141", ((new android.icu.math.BigDecimal("1265E+4")).toString()).equals("1.265E+7")); 614 TestFmwk.assertTrue("cst142", ((new android.icu.math.BigDecimal("1265E+8")).toString()).equals("1.265E+11")); 615 TestFmwk.assertTrue("cst143", ((new android.icu.math.BigDecimal("1265E+20")).toString()).equals("1.265E+23")); 616 617 TestFmwk.assertTrue("cst150", ((new android.icu.math.BigDecimal("0.1265")).toString()).equals("0.1265")); 618 TestFmwk.assertTrue("cst151", ((new android.icu.math.BigDecimal("0.1265E-20")).toString()).equals("1.265E-21")); 619 TestFmwk.assertTrue("cst152", ((new android.icu.math.BigDecimal("0.1265E-8")).toString()).equals("1.265E-9")); 620 TestFmwk.assertTrue("cst153", ((new android.icu.math.BigDecimal("0.1265E-4")).toString()).equals("1.265E-5")); 621 TestFmwk.assertTrue("cst154", ((new android.icu.math.BigDecimal("0.1265E-3")).toString()).equals("1.265E-4")); 622 TestFmwk.assertTrue("cst155", ((new android.icu.math.BigDecimal("0.1265E-2")).toString()).equals("1.265E-3")); 623 TestFmwk.assertTrue("cst156", ((new android.icu.math.BigDecimal("0.1265E-1")).toString()).equals("1.265E-2")); 624 TestFmwk.assertTrue("cst157", ((new android.icu.math.BigDecimal("0.1265E-0")).toString()).equals("1.265E-1")); 625 TestFmwk.assertTrue("cst158", ((new android.icu.math.BigDecimal("0.1265E+1")).toString()).equals("1.265")); 626 TestFmwk.assertTrue("cst159", ((new android.icu.math.BigDecimal("0.1265E+2")).toString()).equals("1.265E+1")); 627 TestFmwk.assertTrue("cst160", ((new android.icu.math.BigDecimal("0.1265E+3")).toString()).equals("1.265E+2")); 628 TestFmwk.assertTrue("cst161", ((new android.icu.math.BigDecimal("0.1265E+4")).toString()).equals("1.265E+3")); 629 TestFmwk.assertTrue("cst162", ((new android.icu.math.BigDecimal("0.1265E+8")).toString()).equals("1.265E+7")); 630 TestFmwk.assertTrue("cst163", ((new android.icu.math.BigDecimal("0.1265E+20")).toString()).equals("1.265E+19")); 631 632 TestFmwk.assertTrue("cst170", ((new android.icu.math.BigDecimal("0.09e999999999")).toString()).equals("9E+999999997")); 633 TestFmwk.assertTrue("cst171", ((new android.icu.math.BigDecimal("0.9e999999999")).toString()).equals("9E+999999998")); 634 TestFmwk.assertTrue("cst172", ((new android.icu.math.BigDecimal("9e999999999")).toString()).equals("9E+999999999")); 635 TestFmwk.assertTrue("cst173", ((new android.icu.math.BigDecimal("9.9e999999999")).toString()).equals("9.9E+999999999")); 636 TestFmwk.assertTrue("cst174", ((new android.icu.math.BigDecimal("9.99e999999999")).toString()).equals("9.99E+999999999")); 637 TestFmwk.assertTrue("cst175", ((new android.icu.math.BigDecimal("9.99e-999999999")).toString()).equals("9.99E-999999999")); 638 TestFmwk.assertTrue("cst176", ((new android.icu.math.BigDecimal("9.9e-999999999")).toString()).equals("9.9E-999999999")); 639 TestFmwk.assertTrue("cst177", ((new android.icu.math.BigDecimal("9e-999999999")).toString()).equals("9E-999999999")); 640 TestFmwk.assertTrue("cst179", ((new android.icu.math.BigDecimal("99e-999999999")).toString()).equals("9.9E-999999998")); 641 TestFmwk.assertTrue("cst180", ((new android.icu.math.BigDecimal("999e-999999999")).toString()).equals("9.99E-999999997")); 642 643 // baddies -- 644 badstrings = new java.lang.String[] { "1..2", ".", "..", "++1", "--1", 645 "-+1", "+-1", "12e", "12e++", "12f4", " +1", "+ 1", "12 ", 646 " + 1", " - 1 ", "x", "-1-", "12-", "3+", "", "1e-", 647 "7e1000000000", "", "e100", "\u0e5a", "\u0b65", "99e999999999", 648 "999e999999999", "0.9e-999999999", "0.09e-999999999", 649 "0.1e1000000000", "10e-1000000000", "0.9e9999999999", 650 "99e-9999999999", "111e9999999999", 651 "1111e-9999999999" + " " + "111e*123", "111e123-", "111e+12+", 652 "111e1-3-", "111e1*23", "111e1e+3", "1e1.0", "1e123e", "ten", 653 "ONE", "1e.1", "1e1.", "1ee", "e+1" }; // 200-203 654 // 204-207 655 // 208-211 656 // 211-214 657 // 215-219 658 // 220-222 659 // 223-224 660 // 225-226 661 // 227-228 662 // 229-230 663 // 231-232 664 // 233-234 665 // 235-237 666 // 238-240 667 // 241-244 668 // 245-248 669 670 // watch out for commas on continuation lines 671 672 { 673 int $16 = badstrings.length; 674 i = 0; 675 for (; $16 > 0; $16--, i++) { 676 try { 677 new android.icu.math.BigDecimal(badstrings[i]); 678 say(">>> cst"+(200+i)+":"+" "+badstrings[i]+" "+(new android.icu.math.BigDecimal(badstrings[i])).toString()); 679 flag = false; 680 } catch (java.lang.NumberFormatException $17) { 681 flag = true; 682 } 683 TestFmwk.assertTrue("cst" + (200 + i), flag); 684 } 685 }/* i */ 686 687 try { 688 new android.icu.math.BigDecimal((java.lang.String) null); 689 flag = false; 690 } catch (java.lang.NullPointerException $18) { 691 flag = true; 692 }/* checknull */ 693 TestFmwk.assertTrue("cst301", flag); 694 695 return; 696 } 697 698 /** Mutation tests (checks that contents of constant objects are unchanged). */ 699 700 @Test 701 public void diagmutation() { 702 /* ---------------------------------------------------------------- */ 703 /* Final tests -- check constants haven't mutated */ 704 /* -- also that MC objects haven't mutated */ 705 /* ---------------------------------------------------------------- */ 706 TestFmwk.assertTrue("cuc001", (android.icu.math.BigDecimal.ZERO.toString()).equals("0")); 707 TestFmwk.assertTrue("cuc002", (android.icu.math.BigDecimal.ONE.toString()).equals("1")); 708 TestFmwk.assertTrue("cuc003", (android.icu.math.BigDecimal.TEN.toString()).equals("10")); 709 710 @SuppressWarnings("unused") 711 int constantVal; // workaround for "Comparing identical expressions" warnings 712 TestFmwk.assertTrue("cuc010", android.icu.math.BigDecimal.ROUND_CEILING == (constantVal = android.icu.math.MathContext.ROUND_CEILING)); 713 TestFmwk.assertTrue("cuc011", android.icu.math.BigDecimal.ROUND_DOWN == (constantVal = android.icu.math.MathContext.ROUND_DOWN)); 714 TestFmwk.assertTrue("cuc012", android.icu.math.BigDecimal.ROUND_FLOOR == (constantVal = android.icu.math.MathContext.ROUND_FLOOR)); 715 TestFmwk.assertTrue("cuc013", android.icu.math.BigDecimal.ROUND_HALF_DOWN == (constantVal = android.icu.math.MathContext.ROUND_HALF_DOWN)); 716 TestFmwk.assertTrue("cuc014", android.icu.math.BigDecimal.ROUND_HALF_EVEN == (constantVal = android.icu.math.MathContext.ROUND_HALF_EVEN)); 717 TestFmwk.assertTrue("cuc015", android.icu.math.BigDecimal.ROUND_HALF_UP == (constantVal = android.icu.math.MathContext.ROUND_HALF_UP)); 718 TestFmwk.assertTrue("cuc016", android.icu.math.BigDecimal.ROUND_UNNECESSARY == (constantVal = android.icu.math.MathContext.ROUND_UNNECESSARY)); 719 TestFmwk.assertTrue("cuc017", android.icu.math.BigDecimal.ROUND_UP == (constantVal = android.icu.math.MathContext.ROUND_UP)); 720 721 TestFmwk.assertTrue("cuc020", (android.icu.math.MathContext.DEFAULT.getDigits()) == 9); 722 TestFmwk.assertTrue("cuc021", (android.icu.math.MathContext.DEFAULT.getForm()) == android.icu.math.MathContext.SCIENTIFIC); 723 TestFmwk.assertTrue("cuc022", (android.icu.math.MathContext.DEFAULT.getLostDigits() ? 1 : 0) == 0); 724 TestFmwk.assertTrue("cuc023", (android.icu.math.MathContext.DEFAULT.getRoundingMode()) == android.icu.math.MathContext.ROUND_HALF_UP); 725 726 // mc9 =MathContext(9) 727 // mcld =MathContext(9, SCIENTIFIC, 1) 728 // mcfd =MathContext(0, PLAIN) 729 TestFmwk.assertTrue("cuc030", (mc9.getDigits()) == 9); 730 TestFmwk.assertTrue("cuc031", (mc9.getForm()) == android.icu.math.MathContext.SCIENTIFIC); 731 TestFmwk.assertTrue("cuc032", (mc9.getLostDigits() ? 1 : 0) == 0); 732 TestFmwk.assertTrue("cuc033", (mc9.getRoundingMode()) == android.icu.math.MathContext.ROUND_HALF_UP); 733 TestFmwk.assertTrue("cuc034", (mcld.getDigits()) == 9); 734 TestFmwk.assertTrue("cuc035", (mcld.getForm()) == android.icu.math.MathContext.SCIENTIFIC); 735 TestFmwk.assertTrue("cuc036", (mcld.getLostDigits() ? 1 : 0) == 1); 736 TestFmwk.assertTrue("cuc037", (mcld.getRoundingMode()) == android.icu.math.MathContext.ROUND_HALF_UP); 737 TestFmwk.assertTrue("cuc038", (mcfd.getDigits()) == 0); 738 TestFmwk.assertTrue("cuc039", (mcfd.getForm()) == android.icu.math.MathContext.PLAIN); 739 TestFmwk.assertTrue("cuc040", (mcfd.getLostDigits() ? 1 : 0) == 0); 740 TestFmwk.assertTrue("cuc041", (mcfd.getRoundingMode()) == android.icu.math.MathContext.ROUND_HALF_UP); 741 742 } 743 744 745 /* ----------------------------------------------------------------- */ 746 /* Operator test methods */ 747 /* ----------------------------------------------------------------- */ 748 // The use of context in these tests are primarily to show that they 749 // are correctly passed to the methods, except that we check that 750 // each method checks for lostDigits. 751 752 /** Test the {@link android.icu.math.BigDecimal#abs} method. */ 753 754 @Test 755 public void diagabs() { 756 boolean flag = false; 757 java.lang.ArithmeticException ae = null; 758 759 // most of the function of this is tested by add 760 TestFmwk.assertTrue("abs001", ((new android.icu.math.BigDecimal("2")).abs().toString()).equals("2")); 761 TestFmwk.assertTrue("abs002", ((new android.icu.math.BigDecimal("-2")).abs().toString()).equals("2")); 762 TestFmwk.assertTrue("abs003", ((new android.icu.math.BigDecimal("+0.000")).abs().toString()).equals("0.000")); 763 TestFmwk.assertTrue("abs004", ((new android.icu.math.BigDecimal("00.000")).abs().toString()).equals("0.000")); 764 TestFmwk.assertTrue("abs005", ((new android.icu.math.BigDecimal("-0.000")).abs().toString()).equals("0.000")); 765 TestFmwk.assertTrue("abs006", ((new android.icu.math.BigDecimal("+0.000")).abs(mcdef).toString()).equals("0")); 766 TestFmwk.assertTrue("abs007", ((new android.icu.math.BigDecimal("00.000")).abs(mcdef).toString()).equals("0")); 767 TestFmwk.assertTrue("abs008", ((new android.icu.math.BigDecimal("-0.000")).abs(mcdef).toString()).equals("0")); 768 TestFmwk.assertTrue("abs009", ((new android.icu.math.BigDecimal("-2000000")).abs().toString()).equals("2000000")); 769 TestFmwk.assertTrue("abs010", ((new android.icu.math.BigDecimal("-2000000")).abs(mcdef).toString()).equals("2000000")); 770 TestFmwk.assertTrue("abs011", ((new android.icu.math.BigDecimal("-2000000")).abs(mc6).toString()).equals("2.00000E+6")); 771 TestFmwk.assertTrue("abs012", ((new android.icu.math.BigDecimal("2000000")).abs(mc6).toString()).equals("2.00000E+6")); 772 TestFmwk.assertTrue("abs013", ((new android.icu.math.BigDecimal("0.2")).abs().toString()).equals("0.2")); 773 TestFmwk.assertTrue("abs014", ((new android.icu.math.BigDecimal("-0.2")).abs().toString()).equals("0.2")); 774 TestFmwk.assertTrue("abs015", ((new android.icu.math.BigDecimal("0.01")).abs().toString()).equals("0.01")); 775 TestFmwk.assertTrue("abs016", ((new android.icu.math.BigDecimal("-0.01")).abs().toString()).equals("0.01")); 776 try { 777 tenlong.abs(mcld); 778 flag = false; 779 } catch (java.lang.ArithmeticException $19) { 780 ae = $19; 781 flag = (ae.getMessage()).equals("Too many digits:" + " " 782 + tenlong.toString()); 783 }/* checkdigits */ 784 TestFmwk.assertTrue("abs020", flag); 785 // check lostdigits not raised if digits=0 [monadic method] 786 try { 787 tenlong.abs(mcld0); 788 flag = true; 789 } catch (java.lang.ArithmeticException $20) { 790 ae = $20; 791 flag = false; 792 }/* checkdigits */ 793 TestFmwk.assertTrue("abs021", flag); 794 try { 795 android.icu.math.BigDecimal.TEN 796 .abs((android.icu.math.MathContext) null); 797 flag = false; 798 } catch (java.lang.NullPointerException $21) { 799 flag = true; 800 }/* checknull */ 801 TestFmwk.assertTrue("abs022", flag); 802 803 } 804 805 /* ----------------------------------------------------------------- */ 806 807 /** Test the {@link android.icu.math.BigDecimal#add} method. */ 808 809 @Test 810 public void diagadd() { 811 boolean flag = false; 812 android.icu.math.BigDecimal alhs; 813 android.icu.math.BigDecimal arhs; 814 java.lang.ArithmeticException ae = null; 815 816 // [first group are 'quick confidence check'] 817 TestFmwk.assertTrue("add001", ((new android.icu.math.BigDecimal(2)).add(new android.icu.math.BigDecimal(3),mcdef).toString()).equals("5")); 818 TestFmwk.assertTrue("add003", ((new android.icu.math.BigDecimal("5.75")).add(new android.icu.math.BigDecimal("3.3"),mcdef).toString()).equals("9.05")); 819 TestFmwk.assertTrue("add004", ((new android.icu.math.BigDecimal("5")).add(new android.icu.math.BigDecimal("-3"),mcdef).toString()).equals("2")); 820 TestFmwk.assertTrue("add005", ((new android.icu.math.BigDecimal("-5")).add(new android.icu.math.BigDecimal("-3"),mcdef).toString()).equals("-8")); 821 TestFmwk.assertTrue("add006", ((new android.icu.math.BigDecimal("-7")).add(new android.icu.math.BigDecimal("2.5"),mcdef).toString()).equals("-4.5")); 822 TestFmwk.assertTrue("add007", ((new android.icu.math.BigDecimal("0.7")).add(new android.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("1.0")); 823 TestFmwk.assertTrue("add008", ((new android.icu.math.BigDecimal("1.25")).add(new android.icu.math.BigDecimal("1.25"),mcdef).toString()).equals("2.50")); 824 TestFmwk.assertTrue("add009", ((new android.icu.math.BigDecimal("1.23456789")).add(new android.icu.math.BigDecimal("1.00000000"),mcdef).toString()).equals("2.23456789")); 825 826 TestFmwk.assertTrue("add010", ((new android.icu.math.BigDecimal("1.23456789")).add(new android.icu.math.BigDecimal("1.00000011"),mcdef).toString()).equals("2.23456800")); 827 828 829 TestFmwk.assertTrue("add011", ((new android.icu.math.BigDecimal("0.4444444444")).add(new android.icu.math.BigDecimal("0.5555555555"),mcdef).toString()).equals("1.00000000")); 830 831 TestFmwk.assertTrue("add012", ((new android.icu.math.BigDecimal("0.4444444440")).add(new android.icu.math.BigDecimal("0.5555555555"),mcdef).toString()).equals("1.00000000")); 832 833 TestFmwk.assertTrue("add013", ((new android.icu.math.BigDecimal("0.4444444444")).add(new android.icu.math.BigDecimal("0.5555555550"),mcdef).toString()).equals("0.999999999")); 834 835 TestFmwk.assertTrue("add014", ((new android.icu.math.BigDecimal("0.4444444444999")).add(new android.icu.math.BigDecimal("0"),mcdef).toString()).equals("0.444444444")); 836 837 TestFmwk.assertTrue("add015", ((new android.icu.math.BigDecimal("0.4444444445000")).add(new android.icu.math.BigDecimal("0"),mcdef).toString()).equals("0.444444445")); 838 839 840 TestFmwk.assertTrue("add016", ((new android.icu.math.BigDecimal("70")).add(new android.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("1.00000000E+13")); 841 842 TestFmwk.assertTrue("add017", ((new android.icu.math.BigDecimal("700")).add(new android.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("1.00000000E+13")); 843 844 TestFmwk.assertTrue("add018", ((new android.icu.math.BigDecimal("7000")).add(new android.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("1.00000000E+13")); 845 846 TestFmwk.assertTrue("add019", ((new android.icu.math.BigDecimal("70000")).add(new android.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("1.00000001E+13")); 847 848 TestFmwk.assertTrue("add020", ((new android.icu.math.BigDecimal("700000")).add(new android.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("1.00000007E+13")); 849 850 851 // [Now the same group with fixed arithmetic] 852 TestFmwk.assertTrue("add030", ((new android.icu.math.BigDecimal(2)).add(new android.icu.math.BigDecimal(3)).toString()).equals("5")); 853 TestFmwk.assertTrue("add031", ((new android.icu.math.BigDecimal("5.75")).add(new android.icu.math.BigDecimal("3.3")).toString()).equals("9.05")); 854 TestFmwk.assertTrue("add032", ((new android.icu.math.BigDecimal("5")).add(new android.icu.math.BigDecimal("-3")).toString()).equals("2")); 855 TestFmwk.assertTrue("add033", ((new android.icu.math.BigDecimal("-5")).add(new android.icu.math.BigDecimal("-3")).toString()).equals("-8")); 856 TestFmwk.assertTrue("add034", ((new android.icu.math.BigDecimal("-7")).add(new android.icu.math.BigDecimal("2.5")).toString()).equals("-4.5")); 857 TestFmwk.assertTrue("add035", ((new android.icu.math.BigDecimal("0.7")).add(new android.icu.math.BigDecimal("0.3")).toString()).equals("1.0")); 858 TestFmwk.assertTrue("add036", ((new android.icu.math.BigDecimal("1.25")).add(new android.icu.math.BigDecimal("1.25")).toString()).equals("2.50")); 859 TestFmwk.assertTrue("add037", ((new android.icu.math.BigDecimal("1.23456789")).add(new android.icu.math.BigDecimal("1.00000000")).toString()).equals("2.23456789")); 860 861 TestFmwk.assertTrue("add038", ((new android.icu.math.BigDecimal("1.23456789")).add(new android.icu.math.BigDecimal("1.00000011")).toString()).equals("2.23456800")); 862 863 864 TestFmwk.assertTrue("add039", ((new android.icu.math.BigDecimal("0.4444444444")).add(new android.icu.math.BigDecimal("0.5555555555")).toString()).equals("0.9999999999")); 865 866 TestFmwk.assertTrue("add040", ((new android.icu.math.BigDecimal("0.4444444440")).add(new android.icu.math.BigDecimal("0.5555555555")).toString()).equals("0.9999999995")); 867 868 TestFmwk.assertTrue("add041", ((new android.icu.math.BigDecimal("0.4444444444")).add(new android.icu.math.BigDecimal("0.5555555550")).toString()).equals("0.9999999994")); 869 870 TestFmwk.assertTrue("add042", ((new android.icu.math.BigDecimal("0.4444444444999")).add(new android.icu.math.BigDecimal("0")).toString()).equals("0.4444444444999")); 871 872 TestFmwk.assertTrue("add043", ((new android.icu.math.BigDecimal("0.4444444445000")).add(new android.icu.math.BigDecimal("0")).toString()).equals("0.4444444445000")); 873 874 875 TestFmwk.assertTrue("add044", ((new android.icu.math.BigDecimal("70")).add(new android.icu.math.BigDecimal("10000e+9")).toString()).equals("10000000000070")); 876 877 TestFmwk.assertTrue("add045", ((new android.icu.math.BigDecimal("700")).add(new android.icu.math.BigDecimal("10000e+9")).toString()).equals("10000000000700")); 878 879 TestFmwk.assertTrue("add046", ((new android.icu.math.BigDecimal("7000")).add(new android.icu.math.BigDecimal("10000e+9")).toString()).equals("10000000007000")); 880 881 TestFmwk.assertTrue("add047", ((new android.icu.math.BigDecimal("70000")).add(new android.icu.math.BigDecimal("10000e+9")).toString()).equals("10000000070000")); 882 883 TestFmwk.assertTrue("add048", ((new android.icu.math.BigDecimal("700000")).add(new android.icu.math.BigDecimal("10000e+9")).toString()).equals("10000000700000")); 884 885 886 // symmetry: 887 TestFmwk.assertTrue("add049", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("70"),mcdef).toString()).equals("1.00000000E+13")); 888 889 TestFmwk.assertTrue("add050", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("700"),mcdef).toString()).equals("1.00000000E+13")); 890 891 TestFmwk.assertTrue("add051", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("7000"),mcdef).toString()).equals("1.00000000E+13")); 892 893 TestFmwk.assertTrue("add052", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("70000"),mcdef).toString()).equals("1.00000001E+13")); 894 895 TestFmwk.assertTrue("add053", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("700000"),mcdef).toString()).equals("1.00000007E+13")); 896 897 898 TestFmwk.assertTrue("add054", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("70")).toString()).equals("10000000000070")); 899 900 TestFmwk.assertTrue("add055", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("700")).toString()).equals("10000000000700")); 901 902 TestFmwk.assertTrue("add056", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("7000")).toString()).equals("10000000007000")); 903 904 TestFmwk.assertTrue("add057", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("70000")).toString()).equals("10000000070000")); 905 906 TestFmwk.assertTrue("add058", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("700000")).toString()).equals("10000000700000")); 907 908 // some rounding effects 909 TestFmwk.assertTrue("add059", ((new android.icu.math.BigDecimal("0.9998")).add(new android.icu.math.BigDecimal("0.0000")).toString()).equals("0.9998")); 910 911 TestFmwk.assertTrue("add060", ((new android.icu.math.BigDecimal("0.9998")).add(new android.icu.math.BigDecimal("0.0001")).toString()).equals("0.9999")); 912 913 TestFmwk.assertTrue("add061", ((new android.icu.math.BigDecimal("0.9998")).add(new android.icu.math.BigDecimal("0.0002")).toString()).equals("1.0000")); 914 915 TestFmwk.assertTrue("add062", ((new android.icu.math.BigDecimal("0.9998")).add(new android.icu.math.BigDecimal("0.0003")).toString()).equals("1.0001")); 916 917 918 // MC 919 TestFmwk.assertTrue("add070", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("70000"),mcfd).toString()).equals("10000000070000")); 920 921 TestFmwk.assertTrue("add071", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("70000"),mcdef).toString()).equals("1.00000001E+13")); 922 923 TestFmwk.assertTrue("add072", ((new android.icu.math.BigDecimal("10000e+9")).add(new android.icu.math.BigDecimal("70000"),mc6).toString()).equals("1.00000E+13")); 924 925 926 // zero preservation 927 TestFmwk.assertTrue("add080", (android.icu.math.BigDecimal.ONE.add(new android.icu.math.BigDecimal("0.0001"),mc6).toString()).equals("1.0001")); 928 929 TestFmwk.assertTrue("add081", (android.icu.math.BigDecimal.ONE.add(new android.icu.math.BigDecimal("0.00001"),mc6).toString()).equals("1.00001")); 930 931 TestFmwk.assertTrue("add082", (android.icu.math.BigDecimal.ONE.add(new android.icu.math.BigDecimal("0.000001"),mc6).toString()).equals("1.00000")); 932 933 TestFmwk.assertTrue("add083", (android.icu.math.BigDecimal.ONE.add(new android.icu.math.BigDecimal("0.0000001"),mc6).toString()).equals("1.00000")); 934 935 TestFmwk.assertTrue("add084", (android.icu.math.BigDecimal.ONE.add(new android.icu.math.BigDecimal("0.00000001"),mc6).toString()).equals("1.00000")); 936 937 938 // more fixed, LHS swaps 939 TestFmwk.assertTrue("add090", ((new android.icu.math.BigDecimal("-56267E-10")).add(zero).toString()).equals("-0.0000056267")); 940 TestFmwk.assertTrue("add091", ((new android.icu.math.BigDecimal("-56267E-6")).add(zero).toString()).equals("-0.056267")); 941 TestFmwk.assertTrue("add092", ((new android.icu.math.BigDecimal("-56267E-5")).add(zero).toString()).equals("-0.56267")); 942 TestFmwk.assertTrue("add093", ((new android.icu.math.BigDecimal("-56267E-4")).add(zero).toString()).equals("-5.6267")); 943 TestFmwk.assertTrue("add094", ((new android.icu.math.BigDecimal("-56267E-3")).add(zero).toString()).equals("-56.267")); 944 TestFmwk.assertTrue("add095", ((new android.icu.math.BigDecimal("-56267E-2")).add(zero).toString()).equals("-562.67")); 945 TestFmwk.assertTrue("add096", ((new android.icu.math.BigDecimal("-56267E-1")).add(zero).toString()).equals("-5626.7")); 946 TestFmwk.assertTrue("add097", ((new android.icu.math.BigDecimal("-56267E-0")).add(zero).toString()).equals("-56267")); 947 TestFmwk.assertTrue("add098", ((new android.icu.math.BigDecimal("-5E-10")).add(zero).toString()).equals("-0.0000000005")); 948 TestFmwk.assertTrue("add099", ((new android.icu.math.BigDecimal("-5E-5")).add(zero).toString()).equals("-0.00005")); 949 TestFmwk.assertTrue("add100", ((new android.icu.math.BigDecimal("-5E-1")).add(zero).toString()).equals("-0.5")); 950 TestFmwk.assertTrue("add101", ((new android.icu.math.BigDecimal("-5E-10")).add(zero).toString()).equals("-0.0000000005")); 951 TestFmwk.assertTrue("add102", ((new android.icu.math.BigDecimal("-5E-5")).add(zero).toString()).equals("-0.00005")); 952 TestFmwk.assertTrue("add103", ((new android.icu.math.BigDecimal("-5E-1")).add(zero).toString()).equals("-0.5")); 953 TestFmwk.assertTrue("add104", ((new android.icu.math.BigDecimal("-5E10")).add(zero).toString()).equals("-50000000000")); 954 TestFmwk.assertTrue("add105", ((new android.icu.math.BigDecimal("-5E5")).add(zero).toString()).equals("-500000")); 955 TestFmwk.assertTrue("add106", ((new android.icu.math.BigDecimal("-5E1")).add(zero).toString()).equals("-50")); 956 TestFmwk.assertTrue("add107", ((new android.icu.math.BigDecimal("-5E0")).add(zero).toString()).equals("-5")); 957 958 // more fixed, RHS swaps 959 TestFmwk.assertTrue("add108", (zero.add(new android.icu.math.BigDecimal("-56267E-10")).toString()).equals("-0.0000056267")); 960 TestFmwk.assertTrue("add109", (zero.add(new android.icu.math.BigDecimal("-56267E-6")).toString()).equals("-0.056267")); 961 TestFmwk.assertTrue("add110", (zero.add(new android.icu.math.BigDecimal("-56267E-5")).toString()).equals("-0.56267")); 962 TestFmwk.assertTrue("add111", (zero.add(new android.icu.math.BigDecimal("-56267E-4")).toString()).equals("-5.6267")); 963 TestFmwk.assertTrue("add112", (zero.add(new android.icu.math.BigDecimal("-56267E-3")).toString()).equals("-56.267")); 964 TestFmwk.assertTrue("add113", (zero.add(new android.icu.math.BigDecimal("-56267E-2")).toString()).equals("-562.67")); 965 TestFmwk.assertTrue("add114", (zero.add(new android.icu.math.BigDecimal("-56267E-1")).toString()).equals("-5626.7")); 966 TestFmwk.assertTrue("add115", (zero.add(new android.icu.math.BigDecimal("-56267E-0")).toString()).equals("-56267")); 967 TestFmwk.assertTrue("add116", (zero.add(new android.icu.math.BigDecimal("-5E-10")).toString()).equals("-0.0000000005")); 968 TestFmwk.assertTrue("add117", (zero.add(new android.icu.math.BigDecimal("-5E-5")).toString()).equals("-0.00005")); 969 TestFmwk.assertTrue("add118", (zero.add(new android.icu.math.BigDecimal("-5E-1")).toString()).equals("-0.5")); 970 TestFmwk.assertTrue("add129", (zero.add(new android.icu.math.BigDecimal("-5E-10")).toString()).equals("-0.0000000005")); 971 TestFmwk.assertTrue("add130", (zero.add(new android.icu.math.BigDecimal("-5E-5")).toString()).equals("-0.00005")); 972 TestFmwk.assertTrue("add131", (zero.add(new android.icu.math.BigDecimal("-5E-1")).toString()).equals("-0.5")); 973 TestFmwk.assertTrue("add132", (zero.add(new android.icu.math.BigDecimal("-5E10")).toString()).equals("-50000000000")); 974 TestFmwk.assertTrue("add133", (zero.add(new android.icu.math.BigDecimal("-5E5")).toString()).equals("-500000")); 975 TestFmwk.assertTrue("add134", (zero.add(new android.icu.math.BigDecimal("-5E1")).toString()).equals("-50")); 976 TestFmwk.assertTrue("add135", (zero.add(new android.icu.math.BigDecimal("-5E0")).toString()).equals("-5")); 977 978 // [some of the next group are really constructor tests] 979 TestFmwk.assertTrue("add140", ((new android.icu.math.BigDecimal("00.0")).add(new android.icu.math.BigDecimal("0.00"),mcdef).toString()).equals("0")); 980 TestFmwk.assertTrue("add141", ((new android.icu.math.BigDecimal("0.00")).add(new android.icu.math.BigDecimal("00.0"),mcdef).toString()).equals("0")); 981 TestFmwk.assertTrue("add142", ((new android.icu.math.BigDecimal("3")).add(new android.icu.math.BigDecimal(".3"),mcdef).toString()).equals("3.3")); 982 TestFmwk.assertTrue("add143", ((new android.icu.math.BigDecimal("3.")).add(new android.icu.math.BigDecimal(".3"),mcdef).toString()).equals("3.3")); 983 TestFmwk.assertTrue("add144", ((new android.icu.math.BigDecimal("3.0")).add(new android.icu.math.BigDecimal(".3"),mcdef).toString()).equals("3.3")); 984 TestFmwk.assertTrue("add145", ((new android.icu.math.BigDecimal("3.00")).add(new android.icu.math.BigDecimal(".3"),mcdef).toString()).equals("3.30")); 985 TestFmwk.assertTrue("add146", ((new android.icu.math.BigDecimal("3")).add(new android.icu.math.BigDecimal("3"),mcdef).toString()).equals("6")); 986 TestFmwk.assertTrue("add147", ((new android.icu.math.BigDecimal("3")).add(new android.icu.math.BigDecimal("+3"),mcdef).toString()).equals("6")); 987 TestFmwk.assertTrue("add148", ((new android.icu.math.BigDecimal("3")).add(new android.icu.math.BigDecimal("-3"),mcdef).toString()).equals("0")); 988 TestFmwk.assertTrue("add149", ((new android.icu.math.BigDecimal("0.03")).add(new android.icu.math.BigDecimal("-0.03"),mcdef).toString()).equals("0")); 989 990 TestFmwk.assertTrue("add150", ((new android.icu.math.BigDecimal("00.0")).add(new android.icu.math.BigDecimal("0.00")).toString()).equals("0.00")); 991 TestFmwk.assertTrue("add151", ((new android.icu.math.BigDecimal("0.00")).add(new android.icu.math.BigDecimal("00.0")).toString()).equals("0.00")); 992 TestFmwk.assertTrue("add152", ((new android.icu.math.BigDecimal("3")).add(new android.icu.math.BigDecimal(".3")).toString()).equals("3.3")); 993 TestFmwk.assertTrue("add153", ((new android.icu.math.BigDecimal("3.")).add(new android.icu.math.BigDecimal(".3")).toString()).equals("3.3")); 994 TestFmwk.assertTrue("add154", ((new android.icu.math.BigDecimal("3.0")).add(new android.icu.math.BigDecimal(".3")).toString()).equals("3.3")); 995 TestFmwk.assertTrue("add155", ((new android.icu.math.BigDecimal("3.00")).add(new android.icu.math.BigDecimal(".3")).toString()).equals("3.30")); 996 TestFmwk.assertTrue("add156", ((new android.icu.math.BigDecimal("3")).add(new android.icu.math.BigDecimal("3")).toString()).equals("6")); 997 TestFmwk.assertTrue("add157", ((new android.icu.math.BigDecimal("3")).add(new android.icu.math.BigDecimal("+3")).toString()).equals("6")); 998 TestFmwk.assertTrue("add158", ((new android.icu.math.BigDecimal("3")).add(new android.icu.math.BigDecimal("-3")).toString()).equals("0")); 999 TestFmwk.assertTrue("add159", ((new android.icu.math.BigDecimal("0.3")).add(new android.icu.math.BigDecimal("-0.3")).toString()).equals("0.0")); 1000 TestFmwk.assertTrue("add160", ((new android.icu.math.BigDecimal("0.03")).add(new android.icu.math.BigDecimal("-0.03")).toString()).equals("0.00")); 1001 TestFmwk.assertTrue("add161", ((new android.icu.math.BigDecimal("7E+12")).add(new android.icu.math.BigDecimal("-1"),mcfd).toString()).equals("6999999999999")); 1002 1003 TestFmwk.assertTrue("add162", ((new android.icu.math.BigDecimal("7E+12")).add(new android.icu.math.BigDecimal("1.11"),mcfd).toString()).equals("7000000000001.11")); 1004 1005 TestFmwk.assertTrue("add163", ((new android.icu.math.BigDecimal("1.11")).add(new android.icu.math.BigDecimal("7E+12"),mcfd).toString()).equals("7000000000001.11")); 1006 1007 1008 // input preparation tests 1009 alhs=new android.icu.math.BigDecimal("12345678900000"); 1010 arhs=new android.icu.math.BigDecimal("9999999999999"); 1011 TestFmwk.assertTrue("add170", (alhs.add(arhs,mc3).toString()).equals("2.23E+13")); 1012 TestFmwk.assertTrue("add171", (arhs.add(alhs,mc3).toString()).equals("2.23E+13")); 1013 TestFmwk.assertTrue("add172", ((new android.icu.math.BigDecimal("12E+3")).add(new android.icu.math.BigDecimal("3456"),mc3).toString()).equals("1.55E+4")); 1014 // next was 1.54E+4 under old [truncate to digits+1] rules 1015 TestFmwk.assertTrue("add173", ((new android.icu.math.BigDecimal("12E+3")).add(new android.icu.math.BigDecimal("3446"),mc3).toString()).equals("1.55E+4")); 1016 TestFmwk.assertTrue("add174", ((new android.icu.math.BigDecimal("12E+3")).add(new android.icu.math.BigDecimal("3454"),mc3).toString()).equals("1.55E+4")); 1017 TestFmwk.assertTrue("add175", ((new android.icu.math.BigDecimal("12E+3")).add(new android.icu.math.BigDecimal("3444"),mc3).toString()).equals("1.54E+4")); 1018 1019 TestFmwk.assertTrue("add176", ((new android.icu.math.BigDecimal("3456")).add(new android.icu.math.BigDecimal("12E+3"),mc3).toString()).equals("1.55E+4")); 1020 // next was 1.54E+4 under old [truncate to digits+1] rules 1021 TestFmwk.assertTrue("add177", ((new android.icu.math.BigDecimal("3446")).add(new android.icu.math.BigDecimal("12E+3"),mc3).toString()).equals("1.55E+4")); 1022 TestFmwk.assertTrue("add178", ((new android.icu.math.BigDecimal("3454")).add(new android.icu.math.BigDecimal("12E+3"),mc3).toString()).equals("1.55E+4")); 1023 TestFmwk.assertTrue("add179", ((new android.icu.math.BigDecimal("3444")).add(new android.icu.math.BigDecimal("12E+3"),mc3).toString()).equals("1.54E+4")); 1024 1025 try { 1026 ten.add((android.icu.math.BigDecimal) null); 1027 flag = false; 1028 } catch (java.lang.NullPointerException $22) { 1029 flag = true; 1030 }/* checknull */ 1031 TestFmwk.assertTrue("add200", flag); 1032 try { 1033 ten.add(ten, (android.icu.math.MathContext) null); 1034 flag = false; 1035 } catch (java.lang.NullPointerException $23) { 1036 flag = true; 1037 }/* checknull2 */ 1038 TestFmwk.assertTrue("add201", flag); 1039 1040 try { 1041 tenlong.add(android.icu.math.BigDecimal.ZERO, mcld); 1042 flag = false; 1043 } catch (java.lang.ArithmeticException $24) { 1044 ae = $24; 1045 flag = (ae.getMessage()).equals("Too many digits:" + " " 1046 + tenlong.toString()); 1047 }/* checkdigits */ 1048 TestFmwk.assertTrue("add202", flag); 1049 try { 1050 android.icu.math.BigDecimal.ZERO.add(tenlong, mcld); 1051 flag = false; 1052 } catch (java.lang.ArithmeticException $25) { 1053 ae = $25; 1054 flag = (ae.getMessage()).equals("Too many digits:" + " " 1055 + tenlong.toString()); 1056 }/* checkdigits */ 1057 TestFmwk.assertTrue("add203", flag); 1058 1059 // check lostdigits not raised if digits=0 [dyadic method] 1060 try { 1061 tenlong.add(android.icu.math.BigDecimal.ZERO, mcld0); 1062 flag = true; 1063 } catch (java.lang.ArithmeticException $26) { 1064 ae = $26; 1065 flag = false; 1066 }/* checkdigits */ 1067 TestFmwk.assertTrue("add204", flag); 1068 try { 1069 android.icu.math.BigDecimal.ZERO.add(tenlong, mcld0); 1070 flag = true; 1071 } catch (java.lang.ArithmeticException $27) { 1072 ae = $27; 1073 flag = false; 1074 }/* checkdigits */ 1075 TestFmwk.assertTrue("add205", flag); 1076 1077 } 1078 1079 /* ----------------------------------------------------------------- */ 1080 /** 1081 * Test the {@link android.icu.math.BigDecimal#compareTo(BigDecimal)} 1082 * method. 1083 */ 1084 1085 @Test 1086 public void diagcompareto() { 1087 boolean flag = false; 1088 java.lang.ArithmeticException ae = null; 1089 // we assume add/subtract test function; this just 1090 // tests existence, exceptions, and possible results 1091 1092 TestFmwk.assertTrue("cpt001", ((new android.icu.math.BigDecimal("5")).compareTo(new android.icu.math.BigDecimal("2")))==1); 1093 TestFmwk.assertTrue("cpt002", ((new android.icu.math.BigDecimal("5")).compareTo(new android.icu.math.BigDecimal("5")))==0); 1094 TestFmwk.assertTrue("cpt003", ((new android.icu.math.BigDecimal("5")).compareTo(new android.icu.math.BigDecimal("5.00")))==0); 1095 TestFmwk.assertTrue("cpt004", ((new android.icu.math.BigDecimal("0.5")).compareTo(new android.icu.math.BigDecimal("0.5")))==0); 1096 TestFmwk.assertTrue("cpt005", ((new android.icu.math.BigDecimal("2")).compareTo(new android.icu.math.BigDecimal("5")))==(-1)); 1097 TestFmwk.assertTrue("cpt006", ((new android.icu.math.BigDecimal("2")).compareTo(new android.icu.math.BigDecimal("5"),mcdef))==(-1)); 1098 TestFmwk.assertTrue("cpt007", ((new android.icu.math.BigDecimal("2")).compareTo(new android.icu.math.BigDecimal("5"),mc6))==(-1)); 1099 TestFmwk.assertTrue("cpt008", ((new android.icu.math.BigDecimal("2")).compareTo(new android.icu.math.BigDecimal("5"),mcfd))==(-1)); 1100 try { 1101 ten.compareTo((android.icu.math.BigDecimal) null); 1102 flag = false; 1103 } catch (java.lang.NullPointerException $28) { 1104 flag = true; 1105 }/* checknull */ 1106 TestFmwk.assertTrue("cpt100", flag); 1107 try { 1108 ten.compareTo(ten, (android.icu.math.MathContext) null); 1109 flag = false; 1110 } catch (java.lang.NullPointerException $29) { 1111 flag = true; 1112 }/* checknull2 */ 1113 TestFmwk.assertTrue("cpt101", flag); 1114 1115 try { 1116 tenlong.compareTo(android.icu.math.BigDecimal.ONE, mcld); 1117 flag = false; 1118 } catch (java.lang.ArithmeticException $30) { 1119 ae = $30; 1120 flag = (ae.getMessage()).equals("Too many digits:" + " " 1121 + tenlong.toString()); 1122 }/* checkdigits */ 1123 TestFmwk.assertTrue("cpt102", flag); 1124 try { 1125 android.icu.math.BigDecimal.ONE.compareTo(tenlong, mcld); 1126 flag = false; 1127 } catch (java.lang.ArithmeticException $31) { 1128 ae = $31; 1129 flag = (ae.getMessage()).equals("Too many digits:" + " " 1130 + tenlong.toString()); 1131 }/* checkdigits */ 1132 TestFmwk.assertTrue("cpt103", flag); 1133 1134 } 1135 1136 /* ----------------------------------------------------------------- */ 1137 1138 /** Test the {@link android.icu.math.BigDecimal#divide} method. */ 1139 1140 @Test 1141 public void diagdivide() { 1142 boolean flag = false; 1143 android.icu.math.MathContext rmcd; 1144 int rhu; 1145 int rd; 1146 int ru; 1147 java.lang.RuntimeException e = null; 1148 java.lang.ArithmeticException ae = null; 1149 1150 TestFmwk.assertTrue("div301", ((new android.icu.math.BigDecimal("1")).divide(new android.icu.math.BigDecimal("3"),mcdef).toString()).equals("0.333333333")); 1151 TestFmwk.assertTrue("div302", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),mcdef).toString()).equals("0.666666667")); 1152 TestFmwk.assertTrue("div303", ((new android.icu.math.BigDecimal("2.4")).divide(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("2.4")); 1153 TestFmwk.assertTrue("div304", ((new android.icu.math.BigDecimal("2.4")).divide(new android.icu.math.BigDecimal("-1"),mcdef).toString()).equals("-2.4")); 1154 TestFmwk.assertTrue("div305", ((new android.icu.math.BigDecimal("-2.4")).divide(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("-2.4")); 1155 TestFmwk.assertTrue("div306", ((new android.icu.math.BigDecimal("-2.4")).divide(new android.icu.math.BigDecimal("-1"),mcdef).toString()).equals("2.4")); 1156 TestFmwk.assertTrue("div307", ((new android.icu.math.BigDecimal("2.40")).divide(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("2.4")); 1157 TestFmwk.assertTrue("div308", ((new android.icu.math.BigDecimal("2.400")).divide(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("2.4")); 1158 TestFmwk.assertTrue("div309", ((new android.icu.math.BigDecimal("2.4")).divide(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("1.2")); 1159 TestFmwk.assertTrue("div310", ((new android.icu.math.BigDecimal("2.400")).divide(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("1.2")); 1160 TestFmwk.assertTrue("div311", ((new android.icu.math.BigDecimal("2.")).divide(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("1")); 1161 TestFmwk.assertTrue("div312", ((new android.icu.math.BigDecimal("20")).divide(new android.icu.math.BigDecimal("20"),mcdef).toString()).equals("1")); 1162 TestFmwk.assertTrue("div313", ((new android.icu.math.BigDecimal("187")).divide(new android.icu.math.BigDecimal("187"),mcdef).toString()).equals("1")); 1163 TestFmwk.assertTrue("div314", ((new android.icu.math.BigDecimal("5")).divide(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("2.5")); 1164 TestFmwk.assertTrue("div315", ((new android.icu.math.BigDecimal("5")).divide(new android.icu.math.BigDecimal("2.0"),mcdef).toString()).equals("2.5")); 1165 TestFmwk.assertTrue("div316", ((new android.icu.math.BigDecimal("5")).divide(new android.icu.math.BigDecimal("2.000"),mcdef).toString()).equals("2.5")); 1166 TestFmwk.assertTrue("div317", ((new android.icu.math.BigDecimal("5")).divide(new android.icu.math.BigDecimal("0.200"),mcdef).toString()).equals("25")); 1167 TestFmwk.assertTrue("div318", ((new android.icu.math.BigDecimal("999999999")).divide(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("999999999")); 1168 TestFmwk.assertTrue("div319", ((new android.icu.math.BigDecimal("999999999.4")).divide(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("999999999")); 1169 TestFmwk.assertTrue("div320", ((new android.icu.math.BigDecimal("999999999.5")).divide(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("1E+9")); 1170 TestFmwk.assertTrue("div321", ((new android.icu.math.BigDecimal("999999999.9")).divide(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("1E+9")); 1171 TestFmwk.assertTrue("div322", ((new android.icu.math.BigDecimal("999999999.999")).divide(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("1E+9")); 1172 TestFmwk.assertTrue("div323", ((new android.icu.math.BigDecimal("0.0000E-50")).divide(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("0")); 1173 // MC 1174 TestFmwk.assertTrue("div325", ((new android.icu.math.BigDecimal("999999999")).divide(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("999999999")); 1175 TestFmwk.assertTrue("div326", ((new android.icu.math.BigDecimal("999999999")).divide(new android.icu.math.BigDecimal("1"),mc6).toString()).equals("1E+9")); 1176 TestFmwk.assertTrue("div327", ((new android.icu.math.BigDecimal("9999999")).divide(new android.icu.math.BigDecimal("1"),mc6).toString()).equals("1E+7")); 1177 TestFmwk.assertTrue("div328", ((new android.icu.math.BigDecimal("999999")).divide(new android.icu.math.BigDecimal("1"),mc6).toString()).equals("999999")); 1178 1179 // check rounding explicitly [note: digits+1 truncation] 1180 rmcd=new android.icu.math.MathContext(2,android.icu.math.MathContext.SCIENTIFIC,false,android.icu.math.MathContext.ROUND_CEILING); 1181 TestFmwk.assertTrue("div330", ((new android.icu.math.BigDecimal("1.50")).divide(one,rmcd).toString()).equals("1.5")); 1182 TestFmwk.assertTrue("div331", ((new android.icu.math.BigDecimal("1.51")).divide(one,rmcd).toString()).equals("1.6")); 1183 TestFmwk.assertTrue("div332", ((new android.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.6")); 1184 rmcd=new android.icu.math.MathContext(2,android.icu.math.MathContext.SCIENTIFIC,false,android.icu.math.MathContext.ROUND_DOWN); 1185 TestFmwk.assertTrue("div333", ((new android.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.5")); 1186 TestFmwk.assertTrue("div334", ((new android.icu.math.BigDecimal("1.59")).divide(one,rmcd).toString()).equals("1.5")); 1187 rmcd=new android.icu.math.MathContext(2,android.icu.math.MathContext.SCIENTIFIC,false,android.icu.math.MathContext.ROUND_FLOOR); 1188 TestFmwk.assertTrue("div335", ((new android.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.5")); 1189 TestFmwk.assertTrue("div336", ((new android.icu.math.BigDecimal("1.59")).divide(one,rmcd).toString()).equals("1.5")); 1190 rmcd=new android.icu.math.MathContext(2,android.icu.math.MathContext.SCIENTIFIC,false,android.icu.math.MathContext.ROUND_HALF_DOWN); 1191 TestFmwk.assertTrue("div337", ((new android.icu.math.BigDecimal("1.45")).divide(one,rmcd).toString()).equals("1.4")); 1192 TestFmwk.assertTrue("div338", ((new android.icu.math.BigDecimal("1.50")).divide(one,rmcd).toString()).equals("1.5")); 1193 TestFmwk.assertTrue("div339", ((new android.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.5")); 1194 rmcd=new android.icu.math.MathContext(2,android.icu.math.MathContext.SCIENTIFIC,false,android.icu.math.MathContext.ROUND_HALF_EVEN); 1195 TestFmwk.assertTrue("div340", ((new android.icu.math.BigDecimal("1.45")).divide(one,rmcd).toString()).equals("1.4")); 1196 TestFmwk.assertTrue("div341", ((new android.icu.math.BigDecimal("1.50")).divide(one,rmcd).toString()).equals("1.5")); 1197 TestFmwk.assertTrue("div342", ((new android.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.6")); 1198 rmcd=new android.icu.math.MathContext(2,android.icu.math.MathContext.SCIENTIFIC,false,android.icu.math.MathContext.ROUND_HALF_UP); 1199 TestFmwk.assertTrue("div343", ((new android.icu.math.BigDecimal("1.45")).divide(one,rmcd).toString()).equals("1.5")); 1200 TestFmwk.assertTrue("div344", ((new android.icu.math.BigDecimal("1.50")).divide(one,rmcd).toString()).equals("1.5")); 1201 TestFmwk.assertTrue("div345", ((new android.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.6")); 1202 rmcd=new android.icu.math.MathContext(2,android.icu.math.MathContext.SCIENTIFIC,false,android.icu.math.MathContext.ROUND_UP); 1203 TestFmwk.assertTrue("div346", ((new android.icu.math.BigDecimal("1.50")).divide(one,rmcd).toString()).equals("1.5")); 1204 TestFmwk.assertTrue("div347", ((new android.icu.math.BigDecimal("1.51")).divide(one,rmcd).toString()).equals("1.6")); 1205 TestFmwk.assertTrue("div348", ((new android.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.6")); 1206 1207 // fixed point... 1208 TestFmwk.assertTrue("div350", ((new android.icu.math.BigDecimal("1")).divide(new android.icu.math.BigDecimal("3")).toString()).equals("0")); 1209 TestFmwk.assertTrue("div351", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3")).toString()).equals("1")); 1210 TestFmwk.assertTrue("div352", ((new android.icu.math.BigDecimal("2.4")).divide(new android.icu.math.BigDecimal("1")).toString()).equals("2.4")); 1211 TestFmwk.assertTrue("div353", ((new android.icu.math.BigDecimal("2.4")).divide(new android.icu.math.BigDecimal("-1")).toString()).equals("-2.4")); 1212 TestFmwk.assertTrue("div354", ((new android.icu.math.BigDecimal("-2.4")).divide(new android.icu.math.BigDecimal("1")).toString()).equals("-2.4")); 1213 TestFmwk.assertTrue("div355", ((new android.icu.math.BigDecimal("-2.4")).divide(new android.icu.math.BigDecimal("-1")).toString()).equals("2.4")); 1214 TestFmwk.assertTrue("div356", ((new android.icu.math.BigDecimal("2.40")).divide(new android.icu.math.BigDecimal("1")).toString()).equals("2.40")); 1215 TestFmwk.assertTrue("div357", ((new android.icu.math.BigDecimal("2.400")).divide(new android.icu.math.BigDecimal("1")).toString()).equals("2.400")); 1216 TestFmwk.assertTrue("div358", ((new android.icu.math.BigDecimal("2.4")).divide(new android.icu.math.BigDecimal("2")).toString()).equals("1.2")); 1217 TestFmwk.assertTrue("div359", ((new android.icu.math.BigDecimal("2.400")).divide(new android.icu.math.BigDecimal("2")).toString()).equals("1.200")); 1218 TestFmwk.assertTrue("div360", ((new android.icu.math.BigDecimal("2.")).divide(new android.icu.math.BigDecimal("2")).toString()).equals("1")); 1219 TestFmwk.assertTrue("div361", ((new android.icu.math.BigDecimal("20")).divide(new android.icu.math.BigDecimal("20")).toString()).equals("1")); 1220 TestFmwk.assertTrue("div362", ((new android.icu.math.BigDecimal("187")).divide(new android.icu.math.BigDecimal("187")).toString()).equals("1")); 1221 TestFmwk.assertTrue("div363", ((new android.icu.math.BigDecimal("5")).divide(new android.icu.math.BigDecimal("2")).toString()).equals("3")); 1222 TestFmwk.assertTrue("div364", ((new android.icu.math.BigDecimal("5")).divide(new android.icu.math.BigDecimal("2.0")).toString()).equals("3")); 1223 TestFmwk.assertTrue("div365", ((new android.icu.math.BigDecimal("5")).divide(new android.icu.math.BigDecimal("2.000")).toString()).equals("3")); 1224 TestFmwk.assertTrue("div366", ((new android.icu.math.BigDecimal("5")).divide(new android.icu.math.BigDecimal("0.200")).toString()).equals("25")); 1225 TestFmwk.assertTrue("div367", ((new android.icu.math.BigDecimal("5.0")).divide(new android.icu.math.BigDecimal("2")).toString()).equals("2.5")); 1226 TestFmwk.assertTrue("div368", ((new android.icu.math.BigDecimal("5.0")).divide(new android.icu.math.BigDecimal("2.0")).toString()).equals("2.5")); 1227 TestFmwk.assertTrue("div369", ((new android.icu.math.BigDecimal("5.0")).divide(new android.icu.math.BigDecimal("2.000")).toString()).equals("2.5")); 1228 TestFmwk.assertTrue("div370", ((new android.icu.math.BigDecimal("5.0")).divide(new android.icu.math.BigDecimal("0.200")).toString()).equals("25.0")); 1229 TestFmwk.assertTrue("div371", ((new android.icu.math.BigDecimal("999999999")).divide(new android.icu.math.BigDecimal("1")).toString()).equals("999999999")); 1230 TestFmwk.assertTrue("div372", ((new android.icu.math.BigDecimal("999999999.4")).divide(new android.icu.math.BigDecimal("1")).toString()).equals("999999999.4")); 1231 TestFmwk.assertTrue("div373", ((new android.icu.math.BigDecimal("999999999.5")).divide(new android.icu.math.BigDecimal("1")).toString()).equals("999999999.5")); 1232 TestFmwk.assertTrue("div374", ((new android.icu.math.BigDecimal("999999999.9")).divide(new android.icu.math.BigDecimal("1")).toString()).equals("999999999.9")); 1233 TestFmwk.assertTrue("div375", ((new android.icu.math.BigDecimal("999999999.999")).divide(new android.icu.math.BigDecimal("1")).toString()).equals("999999999.999")); 1234 TestFmwk.assertTrue("div376", ((new android.icu.math.BigDecimal("0.0000E-5")).divide(new android.icu.math.BigDecimal("1")).toString()).equals("0")); 1235 TestFmwk.assertTrue("div377", ((new android.icu.math.BigDecimal("0.000000000")).divide(new android.icu.math.BigDecimal("1")).toString()).equals("0.000000000")); 1236 1237 // - Fixed point; explicit scales & rounds [old BigDecimal divides] 1238 rhu = android.icu.math.MathContext.ROUND_HALF_UP; 1239 rd = android.icu.math.MathContext.ROUND_DOWN; 1240 TestFmwk.assertTrue("div001", ((new android.icu.math.BigDecimal("0")).divide(new android.icu.math.BigDecimal("3")).toString()).equals("0")); 1241 TestFmwk.assertTrue("div002", ((new android.icu.math.BigDecimal("0")).divide(new android.icu.math.BigDecimal("3"),rhu).toString()).equals("0")); 1242 TestFmwk.assertTrue("div003", ((new android.icu.math.BigDecimal("0")).divide(new android.icu.math.BigDecimal("3"),0,rhu).toString()).equals("0")); 1243 TestFmwk.assertTrue("div004", ((new android.icu.math.BigDecimal("0")).divide(new android.icu.math.BigDecimal("3"),1,rhu).toString()).equals("0.0")); 1244 TestFmwk.assertTrue("div005", ((new android.icu.math.BigDecimal("0")).divide(new android.icu.math.BigDecimal("3"),2,rhu).toString()).equals("0.00")); 1245 TestFmwk.assertTrue("div006", ((new android.icu.math.BigDecimal("0")).divide(new android.icu.math.BigDecimal("3"),3,rhu).toString()).equals("0.000")); 1246 TestFmwk.assertTrue("div007", ((new android.icu.math.BigDecimal("0")).divide(new android.icu.math.BigDecimal("3"),4,rhu).toString()).equals("0.0000")); 1247 TestFmwk.assertTrue("div008", ((new android.icu.math.BigDecimal("1")).divide(new android.icu.math.BigDecimal("3")).toString()).equals("0")); 1248 TestFmwk.assertTrue("div009", ((new android.icu.math.BigDecimal("1")).divide(new android.icu.math.BigDecimal("3"),rhu).toString()).equals("0")); 1249 TestFmwk.assertTrue("div010", ((new android.icu.math.BigDecimal("1")).divide(new android.icu.math.BigDecimal("3"),0,rhu).toString()).equals("0")); 1250 TestFmwk.assertTrue("div011", ((new android.icu.math.BigDecimal("1")).divide(new android.icu.math.BigDecimal("3"),1,rhu).toString()).equals("0.3")); 1251 TestFmwk.assertTrue("div012", ((new android.icu.math.BigDecimal("1")).divide(new android.icu.math.BigDecimal("3"),2,rhu).toString()).equals("0.33")); 1252 TestFmwk.assertTrue("div013", ((new android.icu.math.BigDecimal("1")).divide(new android.icu.math.BigDecimal("3"),3,rhu).toString()).equals("0.333")); 1253 TestFmwk.assertTrue("div014", ((new android.icu.math.BigDecimal("1")).divide(new android.icu.math.BigDecimal("3"),4,rhu).toString()).equals("0.3333")); 1254 TestFmwk.assertTrue("div015", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3")).toString()).equals("1")); 1255 TestFmwk.assertTrue("div016", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),rhu).toString()).equals("1")); 1256 TestFmwk.assertTrue("div017", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),0,rhu).toString()).equals("1")); 1257 TestFmwk.assertTrue("div018", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),1,rhu).toString()).equals("0.7")); 1258 TestFmwk.assertTrue("div019", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),2,rhu).toString()).equals("0.67")); 1259 TestFmwk.assertTrue("div020", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),3,rhu).toString()).equals("0.667")); 1260 TestFmwk.assertTrue("div021", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),4,rhu).toString()).equals("0.6667")); 1261 1262 TestFmwk.assertTrue("div030", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("2000"),4,rhu).toString()).equals("0.5000")); 1263 TestFmwk.assertTrue("div031", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("2000"),3,rhu).toString()).equals("0.500")); 1264 TestFmwk.assertTrue("div032", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("2000"),2,rhu).toString()).equals("0.50")); 1265 TestFmwk.assertTrue("div033", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("2000"),1,rhu).toString()).equals("0.5")); 1266 TestFmwk.assertTrue("div034", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("2000"),0,rhu).toString()).equals("1")); 1267 1268 TestFmwk.assertTrue("div035", ((new android.icu.math.BigDecimal("100")).divide(new android.icu.math.BigDecimal("5000"),4,rhu).toString()).equals("0.0200")); 1269 TestFmwk.assertTrue("div036", ((new android.icu.math.BigDecimal("100")).divide(new android.icu.math.BigDecimal("5000"),3,rhu).toString()).equals("0.020")); 1270 TestFmwk.assertTrue("div037", ((new android.icu.math.BigDecimal("100")).divide(new android.icu.math.BigDecimal("5000"),2,rhu).toString()).equals("0.02")); 1271 TestFmwk.assertTrue("div038", ((new android.icu.math.BigDecimal("100")).divide(new android.icu.math.BigDecimal("5000"),1,rhu).toString()).equals("0.0")); 1272 TestFmwk.assertTrue("div039", ((new android.icu.math.BigDecimal("100")).divide(new android.icu.math.BigDecimal("5000"),0,rhu).toString()).equals("0")); 1273 1274 TestFmwk.assertTrue("div040", ((new android.icu.math.BigDecimal("9.99999999")).divide(new android.icu.math.BigDecimal("9.77777777"),4,rhu).toString()).equals("1.0227")); 1275 TestFmwk.assertTrue("div041", ((new android.icu.math.BigDecimal("9.9999999")).divide(new android.icu.math.BigDecimal("9.7777777"),4,rhu).toString()).equals("1.0227")); 1276 TestFmwk.assertTrue("div042", ((new android.icu.math.BigDecimal("9.999999")).divide(new android.icu.math.BigDecimal("9.777777"),4,rhu).toString()).equals("1.0227")); 1277 TestFmwk.assertTrue("div043", ((new android.icu.math.BigDecimal("9.77777777")).divide(new android.icu.math.BigDecimal("9.99999999"),4,rhu).toString()).equals("0.9778")); 1278 TestFmwk.assertTrue("div044", ((new android.icu.math.BigDecimal("9.7777777")).divide(new android.icu.math.BigDecimal("9.9999999"),4,rhu).toString()).equals("0.9778")); 1279 TestFmwk.assertTrue("div045", ((new android.icu.math.BigDecimal("9.777777")).divide(new android.icu.math.BigDecimal("9.999999"),4,rhu).toString()).equals("0.9778")); 1280 TestFmwk.assertTrue("div046", ((new android.icu.math.BigDecimal("9.77777")).divide(new android.icu.math.BigDecimal("9.99999"),4,rhu).toString()).equals("0.9778")); 1281 TestFmwk.assertTrue("div047", ((new android.icu.math.BigDecimal("9.7777")).divide(new android.icu.math.BigDecimal("9.9999"),4,rhu).toString()).equals("0.9778")); 1282 TestFmwk.assertTrue("div048", ((new android.icu.math.BigDecimal("9.777")).divide(new android.icu.math.BigDecimal("9.999"),4,rhu).toString()).equals("0.9778")); 1283 TestFmwk.assertTrue("div049", ((new android.icu.math.BigDecimal("9.77")).divide(new android.icu.math.BigDecimal("9.99"),4,rhu).toString()).equals("0.9780")); 1284 TestFmwk.assertTrue("div050", ((new android.icu.math.BigDecimal("9.7")).divide(new android.icu.math.BigDecimal("9.9"),4,rhu).toString()).equals("0.9798")); 1285 TestFmwk.assertTrue("div051", ((new android.icu.math.BigDecimal("9.")).divide(new android.icu.math.BigDecimal("9."),4,rhu).toString()).equals("1.0000")); 1286 1287 TestFmwk.assertTrue("div060", ((new android.icu.math.BigDecimal("9.99999999")).divide(new android.icu.math.BigDecimal("9.77777777"),rhu).toString()).equals("1.02272727")); 1288 TestFmwk.assertTrue("div061", ((new android.icu.math.BigDecimal("9.9999999")).divide(new android.icu.math.BigDecimal("9.7777777"),rhu).toString()).equals("1.0227273")); 1289 TestFmwk.assertTrue("div062", ((new android.icu.math.BigDecimal("9.999999")).divide(new android.icu.math.BigDecimal("9.777777"),rhu).toString()).equals("1.022727")); 1290 TestFmwk.assertTrue("div063", ((new android.icu.math.BigDecimal("9.77777777")).divide(new android.icu.math.BigDecimal("9.99999999"),rhu).toString()).equals("0.97777778")); 1291 TestFmwk.assertTrue("div064", ((new android.icu.math.BigDecimal("9.7777777")).divide(new android.icu.math.BigDecimal("9.9999999"),rhu).toString()).equals("0.9777778")); 1292 TestFmwk.assertTrue("div065", ((new android.icu.math.BigDecimal("9.777777")).divide(new android.icu.math.BigDecimal("9.999999"),rhu).toString()).equals("0.977778")); 1293 TestFmwk.assertTrue("div066", ((new android.icu.math.BigDecimal("9.77777")).divide(new android.icu.math.BigDecimal("9.99999"),rhu).toString()).equals("0.97778")); 1294 TestFmwk.assertTrue("div067", ((new android.icu.math.BigDecimal("9.7777")).divide(new android.icu.math.BigDecimal("9.9999"),rhu).toString()).equals("0.9778")); 1295 TestFmwk.assertTrue("div068", ((new android.icu.math.BigDecimal("9.777")).divide(new android.icu.math.BigDecimal("9.999"),rhu).toString()).equals("0.978")); 1296 TestFmwk.assertTrue("div069", ((new android.icu.math.BigDecimal("9.77")).divide(new android.icu.math.BigDecimal("9.99"),rhu).toString()).equals("0.98")); 1297 TestFmwk.assertTrue("div070", ((new android.icu.math.BigDecimal("9.7")).divide(new android.icu.math.BigDecimal("9.9"),rhu).toString()).equals("1.0")); 1298 TestFmwk.assertTrue("div071", ((new android.icu.math.BigDecimal("9.")).divide(new android.icu.math.BigDecimal("9."),rhu).toString()).equals("1")); 1299 1300 rd=android.icu.math.MathContext.ROUND_DOWN; // test this is actually being used 1301 TestFmwk.assertTrue("div080", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),0,rd).toString()).equals("0")); 1302 TestFmwk.assertTrue("div081", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),1,rd).toString()).equals("0.6")); 1303 TestFmwk.assertTrue("div082", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),2,rd).toString()).equals("0.66")); 1304 TestFmwk.assertTrue("div083", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),3,rd).toString()).equals("0.666")); 1305 TestFmwk.assertTrue("div084", ((new android.icu.math.BigDecimal("2")).divide(new android.icu.math.BigDecimal("3"),4,rd).toString()).equals("0.6666")); 1306 1307 ru=android.icu.math.MathContext.ROUND_UNNECESSARY; // check for some 0 residues 1308 TestFmwk.assertTrue("div090", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("5"),4,ru).toString()).equals("200.0000")); 1309 TestFmwk.assertTrue("div091", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("50"),4,ru).toString()).equals("20.0000")); 1310 TestFmwk.assertTrue("div092", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("500"),4,ru).toString()).equals("2.0000")); 1311 TestFmwk.assertTrue("div093", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("5000"),4,ru).toString()).equals("0.2000")); 1312 TestFmwk.assertTrue("div094", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("5000"),3,ru).toString()).equals("0.200")); 1313 TestFmwk.assertTrue("div095", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("5000"),2,ru).toString()).equals("0.20")); 1314 TestFmwk.assertTrue("div096", ((new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("5000"),1,ru).toString()).equals("0.2")); 1315 1316 // check rounding explicitly 1317 TestFmwk.assertTrue("div101", ((new android.icu.math.BigDecimal("0.055")).divide(one,2,android.icu.math.MathContext.ROUND_CEILING).toString()).equals("0.06")); 1318 TestFmwk.assertTrue("div102", ((new android.icu.math.BigDecimal("0.055")).divide(one,1,android.icu.math.MathContext.ROUND_CEILING).toString()).equals("0.1")); 1319 TestFmwk.assertTrue("div103", ((new android.icu.math.BigDecimal("0.055")).divide(one,0,android.icu.math.MathContext.ROUND_CEILING).toString()).equals("1")); 1320 TestFmwk.assertTrue("div104", ((new android.icu.math.BigDecimal("0.055")).divide(one,2,android.icu.math.MathContext.ROUND_DOWN).toString()).equals("0.05")); 1321 TestFmwk.assertTrue("div105", ((new android.icu.math.BigDecimal("0.055")).divide(one,1,android.icu.math.MathContext.ROUND_DOWN).toString()).equals("0.0")); 1322 TestFmwk.assertTrue("div106", ((new android.icu.math.BigDecimal("0.055")).divide(one,0,android.icu.math.MathContext.ROUND_DOWN).toString()).equals("0")); 1323 TestFmwk.assertTrue("div107", ((new android.icu.math.BigDecimal("0.055")).divide(one,2,android.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0.05")); 1324 TestFmwk.assertTrue("div108", ((new android.icu.math.BigDecimal("0.055")).divide(one,1,android.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0.0")); 1325 TestFmwk.assertTrue("div109", ((new android.icu.math.BigDecimal("0.055")).divide(one,0,android.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0")); 1326 1327 TestFmwk.assertTrue("div110", ((new android.icu.math.BigDecimal("0.045")).divide(one,2,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.04")); 1328 TestFmwk.assertTrue("div111", ((new android.icu.math.BigDecimal("0.045")).divide(one,1,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.0")); 1329 TestFmwk.assertTrue("div112", ((new android.icu.math.BigDecimal("0.045")).divide(one,0,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0")); 1330 TestFmwk.assertTrue("div113", ((new android.icu.math.BigDecimal("0.050")).divide(one,2,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.05")); 1331 TestFmwk.assertTrue("div114", ((new android.icu.math.BigDecimal("0.050")).divide(one,1,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.0")); 1332 TestFmwk.assertTrue("div115", ((new android.icu.math.BigDecimal("0.050")).divide(one,0,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0")); 1333 TestFmwk.assertTrue("div116", ((new android.icu.math.BigDecimal("0.055")).divide(one,2,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.05")); 1334 TestFmwk.assertTrue("div117", ((new android.icu.math.BigDecimal("0.055")).divide(one,1,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.1")); 1335 TestFmwk.assertTrue("div118", ((new android.icu.math.BigDecimal("0.055")).divide(one,0,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0")); 1336 1337 TestFmwk.assertTrue("div120", ((new android.icu.math.BigDecimal("0.045")).divide(one,2,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.04")); 1338 TestFmwk.assertTrue("div121", ((new android.icu.math.BigDecimal("0.045")).divide(one,1,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.0")); 1339 TestFmwk.assertTrue("div122", ((new android.icu.math.BigDecimal("0.045")).divide(one,0,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 1340 TestFmwk.assertTrue("div123", ((new android.icu.math.BigDecimal("0.050")).divide(one,2,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.05")); 1341 TestFmwk.assertTrue("div124", ((new android.icu.math.BigDecimal("0.050")).divide(one,1,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.0")); 1342 TestFmwk.assertTrue("div125", ((new android.icu.math.BigDecimal("0.050")).divide(one,0,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 1343 TestFmwk.assertTrue("div126", ((new android.icu.math.BigDecimal("0.150")).divide(one,2,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.15")); 1344 TestFmwk.assertTrue("div127", ((new android.icu.math.BigDecimal("0.150")).divide(one,1,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.2")); 1345 TestFmwk.assertTrue("div128", ((new android.icu.math.BigDecimal("0.150")).divide(one,0,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 1346 TestFmwk.assertTrue("div129", ((new android.icu.math.BigDecimal("0.055")).divide(one,2,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.06")); 1347 TestFmwk.assertTrue("div130", ((new android.icu.math.BigDecimal("0.055")).divide(one,1,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.1")); 1348 TestFmwk.assertTrue("div131", ((new android.icu.math.BigDecimal("0.055")).divide(one,0,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 1349 1350 TestFmwk.assertTrue("div140", ((new android.icu.math.BigDecimal("0.045")).divide(one,2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.05")); 1351 TestFmwk.assertTrue("div141", ((new android.icu.math.BigDecimal("0.045")).divide(one,1,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.0")); 1352 TestFmwk.assertTrue("div142", ((new android.icu.math.BigDecimal("0.045")).divide(one,0,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 1353 TestFmwk.assertTrue("div143", ((new android.icu.math.BigDecimal("0.050")).divide(one,2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.05")); 1354 TestFmwk.assertTrue("div144", ((new android.icu.math.BigDecimal("0.050")).divide(one,1,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.1")); 1355 TestFmwk.assertTrue("div145", ((new android.icu.math.BigDecimal("0.050")).divide(one,0,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 1356 TestFmwk.assertTrue("div146", ((new android.icu.math.BigDecimal("0.055")).divide(one,2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.06")); 1357 TestFmwk.assertTrue("div147", ((new android.icu.math.BigDecimal("0.055")).divide(one,1,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.1")); 1358 TestFmwk.assertTrue("div148", ((new android.icu.math.BigDecimal("0.055")).divide(one,0,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 1359 1360 TestFmwk.assertTrue("div150", ((new android.icu.math.BigDecimal("0.055")).divide(one,2,android.icu.math.MathContext.ROUND_UP).toString()).equals("0.06")); 1361 TestFmwk.assertTrue("div151", ((new android.icu.math.BigDecimal("0.055")).divide(one,1,android.icu.math.MathContext.ROUND_UP).toString()).equals("0.1")); 1362 TestFmwk.assertTrue("div52.", ((new android.icu.math.BigDecimal("0.055")).divide(one,0,android.icu.math.MathContext.ROUND_UP).toString()).equals("1")); 1363 1364 // - error conditions --- 1365 try { 1366 ten.divide((android.icu.math.BigDecimal) null); 1367 flag = false; 1368 } catch (java.lang.NullPointerException $32) { 1369 flag = true; 1370 }/* checknull */ 1371 TestFmwk.assertTrue("div201", flag); 1372 try { 1373 ten.divide(ten, (android.icu.math.MathContext) null); 1374 flag = false; 1375 } catch (java.lang.NullPointerException $33) { 1376 flag = true; 1377 }/* checknull2 */ 1378 TestFmwk.assertTrue("div202", flag); 1379 1380 try { 1381 (new android.icu.math.BigDecimal("1")).divide(new android.icu.math.BigDecimal("3"), -8, 0); 1382 flag = false; 1383 } catch (java.lang.RuntimeException $34) { 1384 e = $34; 1385 flag = flag & (e.getMessage()).equals("Negative scale: -8"); 1386 }/* checkscale */ 1387 TestFmwk.assertTrue("div203", flag); 1388 1389 try { 1390 (new android.icu.math.BigDecimal("1000")).divide(new android.icu.math.BigDecimal("5000"), 0, android.icu.math.MathContext.ROUND_UNNECESSARY); 1391 flag = false; 1392 } catch (java.lang.ArithmeticException $35) { 1393 ae = $35; 1394 flag = (ae.getMessage()).equals("Rounding necessary"); 1395 }/* rounn */ 1396 TestFmwk.assertTrue("div204", flag); 1397 try { 1398 (new android.icu.math.BigDecimal("1001")).divide(new android.icu.math.BigDecimal("10"), 0, android.icu.math.MathContext.ROUND_UNNECESSARY); 1399 flag = false; 1400 } catch (java.lang.ArithmeticException $36) { 1401 ae = $36; 1402 flag = (ae.getMessage()).equals("Rounding necessary"); 1403 }/* rounn */ 1404 TestFmwk.assertTrue("div205", flag); 1405 try { 1406 (new android.icu.math.BigDecimal("1001")).divide(new android.icu.math.BigDecimal("100"), 1, android.icu.math.MathContext.ROUND_UNNECESSARY); 1407 flag = false; 1408 } catch (java.lang.ArithmeticException $37) { 1409 ae = $37; 1410 flag = (ae.getMessage()).equals("Rounding necessary"); 1411 }/* rounn */ 1412 TestFmwk.assertTrue("div206", flag); 1413 try { 1414 (new android.icu.math.BigDecimal("10001")).divide( 1415 new android.icu.math.BigDecimal("10000"), 1, 1416 android.icu.math.MathContext.ROUND_UNNECESSARY); 1417 flag = false; 1418 } catch (java.lang.ArithmeticException $38) { 1419 ae = $38; 1420 flag = (ae.getMessage()).equals("Rounding necessary"); 1421 }/* rounn */ 1422 TestFmwk.assertTrue("div207", flag); 1423 try { 1424 (new android.icu.math.BigDecimal("1.0001")).divide( 1425 new android.icu.math.BigDecimal("1"), 1, 1426 android.icu.math.MathContext.ROUND_UNNECESSARY); 1427 flag = false; 1428 } catch (java.lang.ArithmeticException $39) { 1429 ae = $39; 1430 flag = (ae.getMessage()).equals("Rounding necessary"); 1431 }/* rounn */ 1432 TestFmwk.assertTrue("div208", flag); 1433 1434 try { 1435 (new android.icu.math.BigDecimal("5")) 1436 .divide(new android.icu.math.BigDecimal("0.00")); 1437 flag = false; 1438 } catch (java.lang.ArithmeticException $40) { 1439 ae = $40; 1440 flag = (ae.getMessage()).equals("Divide by 0"); 1441 }/* div0 */ 1442 TestFmwk.assertTrue("div209", flag); 1443 1444 try { 1445 tenlong.divide(android.icu.math.BigDecimal.ONE, mcld); 1446 flag = false; 1447 } catch (java.lang.ArithmeticException $41) { 1448 ae = $41; 1449 flag = (ae.getMessage()).equals("Too many digits:" + " " 1450 + tenlong.toString()); 1451 }/* checkdigits */ 1452 TestFmwk.assertTrue("div210", flag); 1453 try { 1454 android.icu.math.BigDecimal.ONE.divide(tenlong, mcld); 1455 flag = false; 1456 } catch (java.lang.ArithmeticException $42) { 1457 ae = $42; 1458 flag = (ae.getMessage()).equals("Too many digits:" + " " 1459 + tenlong.toString()); 1460 }/* checkdigits */ 1461 TestFmwk.assertTrue("div211", flag); 1462 1463 } 1464 1465 /* ----------------------------------------------------------------- */ 1466 1467 /** Test the {@link android.icu.math.BigDecimal#divideInteger} method. */ 1468 1469 @Test 1470 public void diagdivideInteger() { 1471 boolean flag = false; 1472 java.lang.ArithmeticException ae = null; 1473 1474 TestFmwk.assertTrue("dvI001", ((new android.icu.math.BigDecimal("101.3")).divideInteger(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("101")); 1475 TestFmwk.assertTrue("dvI002", ((new android.icu.math.BigDecimal("101.0")).divideInteger(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("101")); 1476 TestFmwk.assertTrue("dvI003", ((new android.icu.math.BigDecimal("101.3")).divideInteger(new android.icu.math.BigDecimal("3"),mcdef).toString()).equals("33")); 1477 TestFmwk.assertTrue("dvI004", ((new android.icu.math.BigDecimal("101.0")).divideInteger(new android.icu.math.BigDecimal("3"),mcdef).toString()).equals("33")); 1478 TestFmwk.assertTrue("dvI005", ((new android.icu.math.BigDecimal("2.4")).divideInteger(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("2")); 1479 TestFmwk.assertTrue("dvI006", ((new android.icu.math.BigDecimal("2.400")).divideInteger(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("2")); 1480 TestFmwk.assertTrue("dvI007", ((new android.icu.math.BigDecimal("18")).divideInteger(new android.icu.math.BigDecimal("18"),mcdef).toString()).equals("1")); 1481 TestFmwk.assertTrue("dvI008", ((new android.icu.math.BigDecimal("1120")).divideInteger(new android.icu.math.BigDecimal("1000"),mcdef).toString()).equals("1")); 1482 TestFmwk.assertTrue("dvI009", ((new android.icu.math.BigDecimal("2.4")).divideInteger(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("1")); 1483 TestFmwk.assertTrue("dvI010", ((new android.icu.math.BigDecimal("2.400")).divideInteger(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("1")); 1484 TestFmwk.assertTrue("dvI011", ((new android.icu.math.BigDecimal("0.5")).divideInteger(new android.icu.math.BigDecimal("2.000"),mcdef).toString()).equals("0")); 1485 TestFmwk.assertTrue("dvI012", ((new android.icu.math.BigDecimal("8.005")).divideInteger(new android.icu.math.BigDecimal("7"),mcdef).toString()).equals("1")); 1486 TestFmwk.assertTrue("dvI013", ((new android.icu.math.BigDecimal("5")).divideInteger(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("2")); 1487 TestFmwk.assertTrue("dvI014", ((new android.icu.math.BigDecimal("0")).divideInteger(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("0")); 1488 TestFmwk.assertTrue("dvI015", ((new android.icu.math.BigDecimal("0.00")).divideInteger(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("0")); 1489 // MC 1490 TestFmwk.assertTrue("dvI016", ((new android.icu.math.BigDecimal("5")).divideInteger(new android.icu.math.BigDecimal("2"), mce).toString()).equals("2")); 1491 TestFmwk.assertTrue("dvI017", ((new android.icu.math.BigDecimal("5")).divideInteger(new android.icu.math.BigDecimal("2"), mc6).toString()).equals("2")); 1492 1493 // Fixed -- 1494 TestFmwk.assertTrue("dvI021", ((new android.icu.math.BigDecimal("101.3")).divideInteger(new android.icu.math.BigDecimal("1")).toString()).equals("101")); 1495 TestFmwk.assertTrue("dvI022", ((new android.icu.math.BigDecimal("101.0")).divideInteger(new android.icu.math.BigDecimal("1")).toString()).equals("101")); 1496 TestFmwk.assertTrue("dvI023", ((new android.icu.math.BigDecimal("101.3")).divideInteger(new android.icu.math.BigDecimal("3")).toString()).equals("33")); 1497 TestFmwk.assertTrue("dvI024", ((new android.icu.math.BigDecimal("101.0")).divideInteger(new android.icu.math.BigDecimal("3")).toString()).equals("33")); 1498 TestFmwk.assertTrue("dvI025", ((new android.icu.math.BigDecimal("2.4")).divideInteger(new android.icu.math.BigDecimal("1")).toString()).equals("2")); 1499 TestFmwk.assertTrue("dvI026", ((new android.icu.math.BigDecimal("2.400")).divideInteger(new android.icu.math.BigDecimal("1")).toString()).equals("2")); 1500 TestFmwk.assertTrue("dvI027", ((new android.icu.math.BigDecimal("18")).divideInteger(new android.icu.math.BigDecimal("18")).toString()).equals("1")); 1501 TestFmwk.assertTrue("dvI028", ((new android.icu.math.BigDecimal("1120")).divideInteger(new android.icu.math.BigDecimal("1000")).toString()).equals("1")); 1502 TestFmwk.assertTrue("dvI029", ((new android.icu.math.BigDecimal("2.4")).divideInteger(new android.icu.math.BigDecimal("2")).toString()).equals("1")); 1503 TestFmwk.assertTrue("dvI030", ((new android.icu.math.BigDecimal("2.400")).divideInteger(new android.icu.math.BigDecimal("2")).toString()).equals("1")); 1504 TestFmwk.assertTrue("dvI031", ((new android.icu.math.BigDecimal("0.5")).divideInteger(new android.icu.math.BigDecimal("2.000")).toString()).equals("0")); 1505 TestFmwk.assertTrue("dvI032", ((new android.icu.math.BigDecimal("8.005")).divideInteger(new android.icu.math.BigDecimal("7")).toString()).equals("1")); 1506 TestFmwk.assertTrue("dvI033", ((new android.icu.math.BigDecimal("5")).divideInteger(new android.icu.math.BigDecimal("2")).toString()).equals("2")); 1507 TestFmwk.assertTrue("dvI034", ((new android.icu.math.BigDecimal("0")).divideInteger(new android.icu.math.BigDecimal("2")).toString()).equals("0")); 1508 TestFmwk.assertTrue("dvI035", ((new android.icu.math.BigDecimal("0.00")).divideInteger(new android.icu.math.BigDecimal("2")).toString()).equals("0")); 1509 1510 try { 1511 ten.divideInteger((android.icu.math.BigDecimal) null); 1512 flag = false; 1513 } catch (java.lang.NullPointerException $43) { 1514 flag = true; 1515 }/* checknull */ 1516 TestFmwk.assertTrue("dvI101", flag); 1517 try { 1518 ten.divideInteger(ten, (android.icu.math.MathContext) null); 1519 flag = false; 1520 } catch (java.lang.NullPointerException $44) { 1521 flag = true; 1522 }/* checknull2 */ 1523 TestFmwk.assertTrue("dvI102", flag); 1524 1525 try { 1526 android.icu.math.BigDecimal.ONE.divideInteger(tenlong, mcld); 1527 flag = false; 1528 } catch (java.lang.ArithmeticException $45) { 1529 ae = $45; 1530 flag = (ae.getMessage()).equals("Too many digits:" + " " 1531 + tenlong.toString()); 1532 }/* checkdigits */ 1533 TestFmwk.assertTrue("dvI103", flag); 1534 1535 try { 1536 tenlong.divideInteger(android.icu.math.BigDecimal.ONE, mcld); 1537 flag = false; 1538 } catch (java.lang.ArithmeticException $46) { 1539 ae = $46; 1540 flag = (ae.getMessage()).equals("Too many digits:" + " " 1541 + tenlong.toString()); 1542 }/* checkdigits */ 1543 TestFmwk.assertTrue("dvI104", flag); 1544 1545 } 1546 1547 /* ----------------------------------------------------------------- */ 1548 1549 /** Test the {@link android.icu.math.BigDecimal#max} method. */ 1550 1551 @Test 1552 public void diagmax() { 1553 boolean flag = false; 1554 java.lang.ArithmeticException ae = null; 1555 1556 // we assume add/subtract test function; this and min just 1557 // test existence and test the truth table 1558 TestFmwk.assertTrue("max001", ((new android.icu.math.BigDecimal("5")).max(new android.icu.math.BigDecimal("2")).toString()).equals("5")); 1559 TestFmwk.assertTrue("max002", ((new android.icu.math.BigDecimal("5")).max(new android.icu.math.BigDecimal("5")).toString()).equals("5")); 1560 TestFmwk.assertTrue("max003", ((new android.icu.math.BigDecimal("2")).max(new android.icu.math.BigDecimal("7")).toString()).equals("7")); 1561 TestFmwk.assertTrue("max004", ((new android.icu.math.BigDecimal("2")).max(new android.icu.math.BigDecimal("7"),mcdef).toString()).equals("7")); 1562 TestFmwk.assertTrue("max005", ((new android.icu.math.BigDecimal("2")).max(new android.icu.math.BigDecimal("7"),mc6).toString()).equals("7")); 1563 TestFmwk.assertTrue("max006", ((new android.icu.math.BigDecimal("2E+3")).max(new android.icu.math.BigDecimal("7")).toString()).equals("2000")); 1564 TestFmwk.assertTrue("max007", ((new android.icu.math.BigDecimal("2E+3")).max(new android.icu.math.BigDecimal("7"),mc3).toString()).equals("2E+3")); 1565 TestFmwk.assertTrue("max008", ((new android.icu.math.BigDecimal("7")).max(new android.icu.math.BigDecimal("2E+3")).toString()).equals("2000")); 1566 TestFmwk.assertTrue("max009", ((new android.icu.math.BigDecimal("7")).max(new android.icu.math.BigDecimal("2E+3"),mc3).toString()).equals("2E+3")); 1567 try { 1568 ten.max((android.icu.math.BigDecimal) null); 1569 flag = false; 1570 } catch (java.lang.NullPointerException $47) { 1571 flag = true; 1572 }/* checknull */ 1573 TestFmwk.assertTrue("max010", flag); 1574 try { 1575 ten.max(ten, (android.icu.math.MathContext) null); 1576 flag = false; 1577 } catch (java.lang.NullPointerException $48) { 1578 flag = true; 1579 }/* checknull2 */ 1580 TestFmwk.assertTrue("max011", flag); 1581 try { 1582 tenlong.max(android.icu.math.BigDecimal.ONE, mcld); 1583 flag = false; 1584 } catch (java.lang.ArithmeticException $49) { 1585 ae = $49; 1586 flag = (ae.getMessage()).equals("Too many digits:" + " " 1587 + tenlong.toString()); 1588 }/* checkdigits */ 1589 TestFmwk.assertTrue("max012", flag); 1590 try { 1591 android.icu.math.BigDecimal.ONE.max(tenlong, mcld); 1592 flag = false; 1593 } catch (java.lang.ArithmeticException $50) { 1594 ae = $50; 1595 flag = (ae.getMessage()).equals("Too many digits:" + " " 1596 + tenlong.toString()); 1597 }/* checkdigits */ 1598 TestFmwk.assertTrue("max013", flag); 1599 } 1600 1601 /** Test the {@link android.icu.math.BigDecimal#min} method. */ 1602 1603 @Test 1604 public void diagmin() { 1605 boolean flag = false; 1606 android.icu.math.BigDecimal minx = null; 1607 java.lang.ArithmeticException ae = null; 1608 // we assume add/subtract test function; this and max just 1609 // test existence and test the truth table 1610 1611 TestFmwk.assertTrue("min001", ((new android.icu.math.BigDecimal("5")).min(new android.icu.math.BigDecimal("2")).toString()).equals("2")); 1612 TestFmwk.assertTrue("min002", ((new android.icu.math.BigDecimal("5")).min(new android.icu.math.BigDecimal("5")).toString()).equals("5")); 1613 TestFmwk.assertTrue("min003", ((new android.icu.math.BigDecimal("2")).min(new android.icu.math.BigDecimal("7")).toString()).equals("2")); 1614 TestFmwk.assertTrue("min004", ((new android.icu.math.BigDecimal("2")).min(new android.icu.math.BigDecimal("7"),mcdef).toString()).equals("2")); 1615 TestFmwk.assertTrue("min005", ((new android.icu.math.BigDecimal("1")).min(new android.icu.math.BigDecimal("7"),mc6).toString()).equals("1")); 1616 TestFmwk.assertTrue("min006", ((new android.icu.math.BigDecimal("-2E+3")).min(new android.icu.math.BigDecimal("7")).toString()).equals("-2000")); 1617 TestFmwk.assertTrue("min007", ((new android.icu.math.BigDecimal("-2E+3")).min(new android.icu.math.BigDecimal("7"),mc3).toString()).equals("-2E+3")); 1618 TestFmwk.assertTrue("min008", ((new android.icu.math.BigDecimal("7")).min(new android.icu.math.BigDecimal("-2E+3")).toString()).equals("-2000")); 1619 TestFmwk.assertTrue("min009", ((new android.icu.math.BigDecimal("7")).min(new android.icu.math.BigDecimal("-2E+3"),mc3).toString()).equals("-2E+3")); 1620 try { 1621 minx = ten; 1622 minx.min((android.icu.math.BigDecimal) null); 1623 flag = false; 1624 } catch (java.lang.NullPointerException $51) { 1625 flag = true; 1626 }/* checknull */ 1627 TestFmwk.assertTrue("min010", flag); 1628 try { 1629 minx = ten; 1630 minx.min(ten, (android.icu.math.MathContext) null); 1631 flag = false; 1632 } catch (java.lang.NullPointerException $52) { 1633 flag = true; 1634 }/* checknull2 */ 1635 TestFmwk.assertTrue("min011", flag); 1636 1637 try { 1638 tenlong.min(android.icu.math.BigDecimal.ONE, mcld); 1639 flag = false; 1640 } catch (java.lang.ArithmeticException $53) { 1641 ae = $53; 1642 flag = (ae.getMessage()).equals("Too many digits:" + " " 1643 + tenlong.toString()); 1644 }/* checkdigits */ 1645 TestFmwk.assertTrue("min012", flag); 1646 try { 1647 (new android.icu.math.BigDecimal(9)).min(tenlong, mcld); 1648 flag = false; 1649 } catch (java.lang.ArithmeticException $54) { 1650 ae = $54; 1651 flag = (ae.getMessage()).equals("Too many digits:" + " " 1652 + tenlong.toString()); 1653 }/* checkdigits */ 1654 TestFmwk.assertTrue("min013", flag); 1655 } 1656 1657 /* ----------------------------------------------------------------- */ 1658 1659 /** Test the {@link android.icu.math.BigDecimal#multiply} method. */ 1660 1661 @Test 1662 public void diagmultiply() { 1663 boolean flag = false; 1664 android.icu.math.BigDecimal l9; 1665 android.icu.math.BigDecimal l77e; 1666 android.icu.math.BigDecimal l12345; 1667 android.icu.math.BigDecimal edge; 1668 android.icu.math.BigDecimal tenedge; 1669 android.icu.math.BigDecimal hunedge; 1670 android.icu.math.BigDecimal opo; 1671 android.icu.math.BigDecimal d1 = null; 1672 android.icu.math.BigDecimal d2 = null; 1673 java.lang.ArithmeticException oe = null; 1674 java.lang.ArithmeticException ae = null; 1675 1676 TestFmwk.assertTrue("mul001", ((new android.icu.math.BigDecimal("2")).multiply(new android.icu.math.BigDecimal("3"),mcdef).toString()).equals("6")); 1677 TestFmwk.assertTrue("mul002", ((new android.icu.math.BigDecimal("5")).multiply(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("5")); 1678 TestFmwk.assertTrue("mul003", ((new android.icu.math.BigDecimal("5")).multiply(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("10")); 1679 TestFmwk.assertTrue("mul004", ((new android.icu.math.BigDecimal("1.20")).multiply(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("2.40")); 1680 TestFmwk.assertTrue("mul005", ((new android.icu.math.BigDecimal("1.20")).multiply(new android.icu.math.BigDecimal("0"),mcdef).toString()).equals("0")); 1681 TestFmwk.assertTrue("mul006", ((new android.icu.math.BigDecimal("1.20")).multiply(new android.icu.math.BigDecimal("-2"),mcdef).toString()).equals("-2.40")); 1682 TestFmwk.assertTrue("mul007", ((new android.icu.math.BigDecimal("-1.20")).multiply(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("-2.40")); 1683 TestFmwk.assertTrue("mul008", ((new android.icu.math.BigDecimal("-1.20")).multiply(new android.icu.math.BigDecimal("0"),mcdef).toString()).equals("0")); 1684 TestFmwk.assertTrue("mul009", ((new android.icu.math.BigDecimal("-1.20")).multiply(new android.icu.math.BigDecimal("-2"),mcdef).toString()).equals("2.40")); 1685 TestFmwk.assertTrue("mul010", ((new android.icu.math.BigDecimal("5.09")).multiply(new android.icu.math.BigDecimal("7.1"),mcdef).toString()).equals("36.139")); 1686 TestFmwk.assertTrue("mul011", ((new android.icu.math.BigDecimal("2.5")).multiply(new android.icu.math.BigDecimal("4"),mcdef).toString()).equals("10.0")); 1687 TestFmwk.assertTrue("mul012", ((new android.icu.math.BigDecimal("2.50")).multiply(new android.icu.math.BigDecimal("4"),mcdef).toString()).equals("10.00")); 1688 TestFmwk.assertTrue("mul013", ((new android.icu.math.BigDecimal("1.23456789")).multiply(new android.icu.math.BigDecimal("1.00000000"),mcdef).toString()).equals("1.23456789")); 1689 1690 TestFmwk.assertTrue("mul014", ((new android.icu.math.BigDecimal("9.999999999")).multiply(new android.icu.math.BigDecimal("9.999999999"),mcdef).toString()).equals("100.000000")); 1691 1692 TestFmwk.assertTrue("mul015", ((new android.icu.math.BigDecimal("2.50")).multiply(new android.icu.math.BigDecimal("4"),mcdef).toString()).equals("10.00")); 1693 TestFmwk.assertTrue("mul016", ((new android.icu.math.BigDecimal("2.50")).multiply(new android.icu.math.BigDecimal("4"),mc6).toString()).equals("10.00")); 1694 TestFmwk.assertTrue("mul017", ((new android.icu.math.BigDecimal("9.999999999")).multiply(new android.icu.math.BigDecimal("9.999999999"),mc6).toString()).equals("100.000")); 1695 1696 1697 TestFmwk.assertTrue("mul020", ((new android.icu.math.BigDecimal("2")).multiply(new android.icu.math.BigDecimal("3")).toString()).equals("6")); 1698 TestFmwk.assertTrue("mul021", ((new android.icu.math.BigDecimal("5")).multiply(new android.icu.math.BigDecimal("1")).toString()).equals("5")); 1699 TestFmwk.assertTrue("mul022", ((new android.icu.math.BigDecimal("5")).multiply(new android.icu.math.BigDecimal("2")).toString()).equals("10")); 1700 TestFmwk.assertTrue("mul023", ((new android.icu.math.BigDecimal("1.20")).multiply(new android.icu.math.BigDecimal("2")).toString()).equals("2.40")); 1701 TestFmwk.assertTrue("mul024", ((new android.icu.math.BigDecimal("1.20")).multiply(new android.icu.math.BigDecimal("0")).toString()).equals("0.00")); 1702 TestFmwk.assertTrue("mul025", ((new android.icu.math.BigDecimal("1.20")).multiply(new android.icu.math.BigDecimal("-2")).toString()).equals("-2.40")); 1703 TestFmwk.assertTrue("mul026", ((new android.icu.math.BigDecimal("-1.20")).multiply(new android.icu.math.BigDecimal("2")).toString()).equals("-2.40")); 1704 TestFmwk.assertTrue("mul027", ((new android.icu.math.BigDecimal("-1.20")).multiply(new android.icu.math.BigDecimal("0")).toString()).equals("0.00")); 1705 TestFmwk.assertTrue("mul028", ((new android.icu.math.BigDecimal("-1.20")).multiply(new android.icu.math.BigDecimal("-2")).toString()).equals("2.40")); 1706 TestFmwk.assertTrue("mul029", ((new android.icu.math.BigDecimal("5.09")).multiply(new android.icu.math.BigDecimal("7.1")).toString()).equals("36.139")); 1707 TestFmwk.assertTrue("mul030", ((new android.icu.math.BigDecimal("2.5")).multiply(new android.icu.math.BigDecimal("4")).toString()).equals("10.0")); 1708 TestFmwk.assertTrue("mul031", ((new android.icu.math.BigDecimal("2.50")).multiply(new android.icu.math.BigDecimal("4")).toString()).equals("10.00")); 1709 TestFmwk.assertTrue("mul032", ((new android.icu.math.BigDecimal("1.23456789")).multiply(new android.icu.math.BigDecimal("1.00000000")).toString()).equals("1.2345678900000000")); 1710 1711 TestFmwk.assertTrue("mul033", ((new android.icu.math.BigDecimal("1234.56789")).multiply(new android.icu.math.BigDecimal("-1000.00000")).toString()).equals("-1234567.8900000000")); 1712 1713 TestFmwk.assertTrue("mul034", ((new android.icu.math.BigDecimal("-1234.56789")).multiply(new android.icu.math.BigDecimal("1000.00000")).toString()).equals("-1234567.8900000000")); 1714 1715 TestFmwk.assertTrue("mul035", ((new android.icu.math.BigDecimal("9.999999999")).multiply(new android.icu.math.BigDecimal("9.999999999")).toString()).equals("99.999999980000000001")); 1716 1717 TestFmwk.assertTrue("mul036", ((new android.icu.math.BigDecimal("5.00")).multiply(new android.icu.math.BigDecimal("1E-3")).toString()).equals("0.00500")); 1718 TestFmwk.assertTrue("mul037", ((new android.icu.math.BigDecimal("00.00")).multiply(new android.icu.math.BigDecimal("0.000")).toString()).equals("0.00000")); 1719 TestFmwk.assertTrue("mul038", ((new android.icu.math.BigDecimal("00.00")).multiply(new android.icu.math.BigDecimal("0E-3")).toString()).equals("0.00")); // rhs is '0' 1720 // 1999.12.21: next one is a edge case if intermediate longs are used 1721 TestFmwk.assertTrue("mul039", ((new android.icu.math.BigDecimal("999999999999")).multiply(new android.icu.math.BigDecimal("9765625")).toString()).equals("9765624999990234375")); 1722 1723 l9 = new android.icu.math.BigDecimal("123456789E+10"); 1724 l77e = new android.icu.math.BigDecimal("77E-20"); 1725 TestFmwk.assertTrue("mul040", (l9.multiply(new android.icu.math.BigDecimal("3456757")).toString()).equals("4267601195732730000000000")); 1726 TestFmwk.assertTrue("mul041", (l9.multiply(new android.icu.math.BigDecimal("3456757"), mc3).toString()).equals("4.26E+24")); 1727 TestFmwk.assertTrue("mul042", (l9.multiply(l77e).toString()).equals("0.95061727530000000000")); 1728 TestFmwk.assertTrue("mul043", (l9.multiply(l77e, mc3).toString()).equals("0.947")); 1729 TestFmwk.assertTrue("mul044", (l77e.multiply(l9, mc3).toString()).equals("0.947")); 1730 1731 l12345 = new android.icu.math.BigDecimal("123.45"); 1732 TestFmwk.assertTrue("mul050", (l12345.multiply(new android.icu.math.BigDecimal("1e11"),mcdef).toString()).equals("1.2345E+13")); 1733 TestFmwk.assertTrue("mul051", (l12345.multiply(new android.icu.math.BigDecimal("1e11"),mcs).toString()).equals("1.2345E+13")); 1734 TestFmwk.assertTrue("mul052", (l12345.multiply(new android.icu.math.BigDecimal("1e+9"),mce).toString()).equals("123.45E+9")); 1735 TestFmwk.assertTrue("mul053", (l12345.multiply(new android.icu.math.BigDecimal("1e10"),mce).toString()).equals("1.2345E+12")); 1736 TestFmwk.assertTrue("mul054", (l12345.multiply(new android.icu.math.BigDecimal("1e11"),mce).toString()).equals("12.345E+12")); 1737 TestFmwk.assertTrue("mul055", (l12345.multiply(new android.icu.math.BigDecimal("1e12"),mce).toString()).equals("123.45E+12")); 1738 TestFmwk.assertTrue("mul056", (l12345.multiply(new android.icu.math.BigDecimal("1e13"),mce).toString()).equals("1.2345E+15")); 1739 1740 // test some cases that are close to exponent overflow 1741 TestFmwk.assertTrue("mul060", (one.multiply(new android.icu.math.BigDecimal("9e999999999"),mcs).toString()).equals("9E+999999999")); 1742 TestFmwk.assertTrue("mul061", (one.multiply(new android.icu.math.BigDecimal("9.9e999999999"),mcs).toString()).equals("9.9E+999999999")); 1743 TestFmwk.assertTrue("mul062", (one.multiply(new android.icu.math.BigDecimal("9.99e999999999"),mcs).toString()).equals("9.99E+999999999")); 1744 TestFmwk.assertTrue("mul063", (ten.multiply(new android.icu.math.BigDecimal("9e999999999"),mce).toString()).equals("90E+999999999")); 1745 TestFmwk.assertTrue("mul064", (ten.multiply(new android.icu.math.BigDecimal("9.9e999999999"),mce).toString()).equals("99.0E+999999999")); 1746 edge = new android.icu.math.BigDecimal("9.999e999999999"); 1747 tenedge = ten.multiply(edge, mce); 1748 TestFmwk.assertTrue("mul065", (tenedge.toString()).equals("99.990E+999999999")); 1749 hunedge = ten.multiply(tenedge, mce); 1750 TestFmwk.assertTrue("mul066", (hunedge.toString()).equals("999.900E+999999999")); 1751 opo = new android.icu.math.BigDecimal("0.1"); // one tenth 1752 TestFmwk.assertTrue("mul067", (opo.multiply(new android.icu.math.BigDecimal("9e-999999998"),mcs).toString()).equals("9E-999999999")); 1753 TestFmwk.assertTrue("mul068", (opo.multiply(new android.icu.math.BigDecimal("99e-999999998"),mcs).toString()).equals("9.9E-999999998")); 1754 TestFmwk.assertTrue("mul069", (opo.multiply(new android.icu.math.BigDecimal("999e-999999998"),mcs).toString()).equals("9.99E-999999997")); 1755 1756 TestFmwk.assertTrue("mul070", (opo.multiply(new android.icu.math.BigDecimal("9e-999999998"),mce).toString()).equals("9E-999999999")); 1757 TestFmwk.assertTrue("mul071", (opo.multiply(new android.icu.math.BigDecimal("99e-999999998"),mce).toString()).equals("99E-999999999")); 1758 TestFmwk.assertTrue("mul072", (opo.multiply(new android.icu.math.BigDecimal("999e-999999998"),mce).toString()).equals("999E-999999999")); 1759 TestFmwk.assertTrue("mul073", (opo.multiply(new android.icu.math.BigDecimal("999e-999999997"),mce).toString()).equals("9.99E-999999996")); 1760 TestFmwk.assertTrue("mul074", (opo.multiply(new android.icu.math.BigDecimal("9999e-999999997"),mce).toString()).equals("99.99E-999999996")); 1761 TestFmwk.assertTrue("mul074", (opo.multiply(new android.icu.math.BigDecimal("99999e-999999997"),mce).toString()).equals("999.99E-999999996")); 1762 1763 // test some intermediate lengths 1764 TestFmwk.assertTrue("mul080", (opo.multiply(new android.icu.math.BigDecimal("123456789"),mcs).toString()).equals("12345678.9")); 1765 TestFmwk.assertTrue("mul081", (opo.multiply(new android.icu.math.BigDecimal("12345678901234"),mcs).toString()).equals("1.23456789E+12")); 1766 TestFmwk.assertTrue("mul082", (opo.multiply(new android.icu.math.BigDecimal("123456789123456789"),mcs).toString()).equals("1.23456789E+16")); 1767 TestFmwk.assertTrue("mul083", (opo.multiply(new android.icu.math.BigDecimal("123456789"),mcfd).toString()).equals("12345678.9")); 1768 TestFmwk.assertTrue("mul084", (opo.multiply(new android.icu.math.BigDecimal("12345678901234"),mcfd).toString()).equals("1234567890123.4")); 1769 TestFmwk.assertTrue("mul085", (opo.multiply(new android.icu.math.BigDecimal("123456789123456789"),mcfd).toString()).equals("12345678912345678.9")); 1770 1771 TestFmwk.assertTrue("mul090", ((new android.icu.math.BigDecimal("123456789")).multiply(opo,mcs).toString()).equals("12345678.9")); 1772 TestFmwk.assertTrue("mul091", ((new android.icu.math.BigDecimal("12345678901234")).multiply(opo,mcs).toString()).equals("1.23456789E+12")); 1773 TestFmwk.assertTrue("mul092", ((new android.icu.math.BigDecimal("123456789123456789")).multiply(opo,mcs).toString()).equals("1.23456789E+16")); 1774 TestFmwk.assertTrue("mul093", ((new android.icu.math.BigDecimal("123456789")).multiply(opo,mcfd).toString()).equals("12345678.9")); 1775 TestFmwk.assertTrue("mul094", ((new android.icu.math.BigDecimal("12345678901234")).multiply(opo,mcfd).toString()).equals("1234567890123.4")); 1776 TestFmwk.assertTrue("mul095", ((new android.icu.math.BigDecimal("123456789123456789")).multiply(opo,mcfd).toString()).equals("12345678912345678.9")); 1777 1778 // test some more edge cases and carries 1779 TestFmwk.assertTrue("mul101", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("9")).toString()).equals("81")); 1780 TestFmwk.assertTrue("mul102", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("90")).toString()).equals("810")); 1781 TestFmwk.assertTrue("mul103", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("900")).toString()).equals("8100")); 1782 TestFmwk.assertTrue("mul104", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("9000")).toString()).equals("81000")); 1783 TestFmwk.assertTrue("mul105", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("90000")).toString()).equals("810000")); 1784 TestFmwk.assertTrue("mul106", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("900000")).toString()).equals("8100000")); 1785 TestFmwk.assertTrue("mul107", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("9000000")).toString()).equals("81000000")); 1786 TestFmwk.assertTrue("mul108", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("90000000")).toString()).equals("810000000")); 1787 TestFmwk.assertTrue("mul109", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("900000000")).toString()).equals("8100000000")); 1788 TestFmwk.assertTrue("mul110", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("9000000000")).toString()).equals("81000000000")); 1789 TestFmwk.assertTrue("mul111", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("90000000000")).toString()).equals("810000000000")); 1790 TestFmwk.assertTrue("mul112", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("900000000000")).toString()).equals("8100000000000")); 1791 TestFmwk.assertTrue("mul113", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("9000000000000")).toString()).equals("81000000000000")); 1792 TestFmwk.assertTrue("mul114", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("90000000000000")).toString()).equals("810000000000000")); 1793 TestFmwk.assertTrue("mul115", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("900000000000000")).toString()).equals("8100000000000000")); 1794 TestFmwk.assertTrue("mul116", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("9000000000000000")).toString()).equals("81000000000000000")); 1795 TestFmwk.assertTrue("mul117", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("90000000000000000")).toString()).equals("810000000000000000")); 1796 TestFmwk.assertTrue("mul118", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("900000000000000000")).toString()).equals("8100000000000000000")); 1797 TestFmwk.assertTrue("mul119", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("9000000000000000000")).toString()).equals("81000000000000000000")); 1798 TestFmwk.assertTrue("mul120", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("90000000000000000000")).toString()).equals("810000000000000000000")); 1799 TestFmwk.assertTrue("mul121", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("900000000000000000000")).toString()).equals("8100000000000000000000")); 1800 TestFmwk.assertTrue("mul122", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("9000000000000000000000")).toString()).equals("81000000000000000000000")); 1801 TestFmwk.assertTrue("mul123", ((new android.icu.math.BigDecimal("9")).multiply(new android.icu.math.BigDecimal("90000000000000000000000")).toString()).equals("810000000000000000000000")); 1802 // test some more edge cases without carries 1803 TestFmwk.assertTrue("mul131", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("3")).toString()).equals("9")); 1804 TestFmwk.assertTrue("mul132", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("30")).toString()).equals("90")); 1805 TestFmwk.assertTrue("mul133", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("300")).toString()).equals("900")); 1806 TestFmwk.assertTrue("mul134", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("3000")).toString()).equals("9000")); 1807 TestFmwk.assertTrue("mul135", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("30000")).toString()).equals("90000")); 1808 TestFmwk.assertTrue("mul136", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("300000")).toString()).equals("900000")); 1809 TestFmwk.assertTrue("mul137", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("3000000")).toString()).equals("9000000")); 1810 TestFmwk.assertTrue("mul138", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("30000000")).toString()).equals("90000000")); 1811 TestFmwk.assertTrue("mul139", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("300000000")).toString()).equals("900000000")); 1812 TestFmwk.assertTrue("mul140", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("3000000000")).toString()).equals("9000000000")); 1813 TestFmwk.assertTrue("mul141", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("30000000000")).toString()).equals("90000000000")); 1814 TestFmwk.assertTrue("mul142", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("300000000000")).toString()).equals("900000000000")); 1815 TestFmwk.assertTrue("mul143", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("3000000000000")).toString()).equals("9000000000000")); 1816 TestFmwk.assertTrue("mul144", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("30000000000000")).toString()).equals("90000000000000")); 1817 TestFmwk.assertTrue("mul145", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("300000000000000")).toString()).equals("900000000000000")); 1818 TestFmwk.assertTrue("mul146", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("3000000000000000")).toString()).equals("9000000000000000")); 1819 TestFmwk.assertTrue("mul147", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("30000000000000000")).toString()).equals("90000000000000000")); 1820 TestFmwk.assertTrue("mul148", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("300000000000000000")).toString()).equals("900000000000000000")); 1821 TestFmwk.assertTrue("mul149", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("3000000000000000000")).toString()).equals("9000000000000000000")); 1822 TestFmwk.assertTrue("mul150", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("30000000000000000000")).toString()).equals("90000000000000000000")); 1823 TestFmwk.assertTrue("mul151", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("300000000000000000000")).toString()).equals("900000000000000000000")); 1824 TestFmwk.assertTrue("mul152", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("3000000000000000000000")).toString()).equals("9000000000000000000000")); 1825 TestFmwk.assertTrue("mul153", ((new android.icu.math.BigDecimal("3")).multiply(new android.icu.math.BigDecimal("30000000000000000000000")).toString()).equals("90000000000000000000000")); 1826 1827 try { 1828 ten.multiply((android.icu.math.BigDecimal) null); 1829 flag = false; 1830 } catch (java.lang.NullPointerException $55) { 1831 flag = true; 1832 }/* checknull */ 1833 TestFmwk.assertTrue("mul200", flag); 1834 try { 1835 ten.multiply(ten, (android.icu.math.MathContext) null); 1836 flag = false; 1837 } catch (java.lang.NullPointerException $56) { 1838 flag = true; 1839 }/* checknull2 */ 1840 TestFmwk.assertTrue("mul201", flag); 1841 1842 try { 1843 d1 = new android.icu.math.BigDecimal("-1.23456789012345E-0"); 1844 d2 = new android.icu.math.BigDecimal("9E+999999999"); 1845 d1.multiply(d2, mcdef); // marginal overflow 1846 flag = false; 1847 } catch (java.lang.ArithmeticException $57) { 1848 oe = $57; 1849 flag = (oe.getMessage()).equals("Exponent Overflow: 1000000000"); 1850 }/* checkover */ 1851 TestFmwk.assertTrue("mul202", flag); 1852 try { 1853 d1 = new android.icu.math.BigDecimal("112"); 1854 d2 = new android.icu.math.BigDecimal("9E+999999999"); 1855 d1.multiply(d2, mce); // marginal overflow, engineering 1856 flag = false; 1857 } catch (java.lang.ArithmeticException $58) { 1858 oe = $58; 1859 flag = (oe.getMessage()).equals("Exponent Overflow: 1000000002"); 1860 }/* checkover */ 1861 TestFmwk.assertTrue("mul203", flag); 1862 1863 try { 1864 d1 = new android.icu.math.BigDecimal("0.9"); 1865 d2 = new android.icu.math.BigDecimal("1E-999999999"); 1866 d1.multiply(d2, mcdef); // marginal negative overflow 1867 flag = false; 1868 } catch (java.lang.ArithmeticException $59) { 1869 oe = $59; 1870 flag = (oe.getMessage()).equals("Exponent Overflow: -1000000000"); 1871 }/* checkover */ 1872 TestFmwk.assertTrue("mul204", flag); 1873 try { 1874 d1 = new android.icu.math.BigDecimal("0.9"); 1875 d2 = new android.icu.math.BigDecimal("1E-999999999"); 1876 d1.multiply(d2, mce); // marginal negative overflow, 1877 // engineering 1878 flag = false; 1879 } catch (java.lang.ArithmeticException $60) { 1880 oe = $60; 1881 flag = (oe.getMessage()).equals("Exponent Overflow: -1000000002"); 1882 }/* checkover */ 1883 TestFmwk.assertTrue("mul205", flag); 1884 1885 try { 1886 tenlong.multiply(android.icu.math.BigDecimal.ONE, mcld); 1887 flag = false; 1888 } catch (java.lang.ArithmeticException $61) { 1889 ae = $61; 1890 flag = (ae.getMessage()).equals("Too many digits:" + " " 1891 + tenlong.toString()); 1892 }/* checkdigits */ 1893 TestFmwk.assertTrue("mul206", flag); 1894 try { 1895 android.icu.math.BigDecimal.TEN.multiply(tenlong, mcld); 1896 flag = false; 1897 } catch (java.lang.ArithmeticException $62) { 1898 ae = $62; 1899 flag = (ae.getMessage()).equals("Too many digits:" + " " 1900 + tenlong.toString()); 1901 }/* checkdigits */ 1902 TestFmwk.assertTrue("mul207", flag); 1903 1904 } 1905 1906 /* ----------------------------------------------------------------- */ 1907 1908 /** Test the {@link android.icu.math.BigDecimal#negate} method. */ 1909 1910 @Test 1911 public void diagnegate() { 1912 boolean flag = false; 1913 java.lang.ArithmeticException ae = null; 1914 1915 TestFmwk.assertTrue("neg001", ((new android.icu.math.BigDecimal("2")).negate().toString()).equals("-2")); 1916 TestFmwk.assertTrue("neg002", ((new android.icu.math.BigDecimal("-2")).negate().toString()).equals("2")); 1917 TestFmwk.assertTrue("neg003", ((new android.icu.math.BigDecimal("2.00")).negate(mcdef).toString()).equals("-2.00")); 1918 TestFmwk.assertTrue("neg004", ((new android.icu.math.BigDecimal("-2.00")).negate(mcdef).toString()).equals("2.00")); 1919 TestFmwk.assertTrue("neg005", ((new android.icu.math.BigDecimal("0")).negate(mcdef).toString()).equals("0")); 1920 TestFmwk.assertTrue("neg006", ((new android.icu.math.BigDecimal("0.00")).negate(mcdef).toString()).equals("0")); 1921 TestFmwk.assertTrue("neg007", ((new android.icu.math.BigDecimal("00.0")).negate(mcdef).toString()).equals("0")); 1922 TestFmwk.assertTrue("neg008", ((new android.icu.math.BigDecimal("00")).negate(mcdef).toString()).equals("0")); 1923 1924 TestFmwk.assertTrue("neg010", ((new android.icu.math.BigDecimal("2.00")).negate().toString()).equals("-2.00")); 1925 TestFmwk.assertTrue("neg011", ((new android.icu.math.BigDecimal("-2.00")).negate().toString()).equals("2.00")); 1926 TestFmwk.assertTrue("neg012", ((new android.icu.math.BigDecimal("0")).negate().toString()).equals("0")); 1927 TestFmwk.assertTrue("neg013", ((new android.icu.math.BigDecimal("0.00")).negate().toString()).equals("0.00")); 1928 TestFmwk.assertTrue("neg014", ((new android.icu.math.BigDecimal("00.0")).negate().toString()).equals("0.0")); 1929 TestFmwk.assertTrue("neg015", ((new android.icu.math.BigDecimal("00.00")).negate().toString()).equals("0.00")); 1930 TestFmwk.assertTrue("neg016", ((new android.icu.math.BigDecimal("00")).negate().toString()).equals("0")); 1931 1932 TestFmwk.assertTrue("neg020", ((new android.icu.math.BigDecimal("-2000000")).negate().toString()).equals("2000000")); 1933 TestFmwk.assertTrue("neg021", ((new android.icu.math.BigDecimal("-2000000")).negate(mcdef).toString()).equals("2000000")); 1934 TestFmwk.assertTrue("neg022", ((new android.icu.math.BigDecimal("-2000000")).negate(mc6).toString()).equals("2.00000E+6")); 1935 TestFmwk.assertTrue("neg023", ((new android.icu.math.BigDecimal("2000000")).negate(mc6).toString()).equals("-2.00000E+6")); 1936 1937 try { 1938 ten.negate((android.icu.math.MathContext) null); 1939 flag = false; 1940 } catch (java.lang.NullPointerException $63) { 1941 flag = true; 1942 }/* checknull */ 1943 TestFmwk.assertTrue("neg100", flag); 1944 1945 try { 1946 tenlong.negate(mcld); 1947 flag = false; 1948 } catch (java.lang.ArithmeticException $64) { 1949 ae = $64; 1950 flag = (ae.getMessage()).equals("Too many digits:" + " " 1951 + tenlong.toString()); 1952 }/* checkdigits */ 1953 TestFmwk.assertTrue("neg101", flag); 1954 } 1955 1956 /* ----------------------------------------------------------------- */ 1957 1958 /** Test the {@link android.icu.math.BigDecimal#plus} method. */ 1959 1960 @Test 1961 public void diagplus() { 1962 boolean flag = false; 1963 android.icu.math.MathContext mche1; 1964 java.lang.ArithmeticException ae = null; 1965 1966 TestFmwk.assertTrue("plu001", ((new android.icu.math.BigDecimal("2")).plus(mcdef).toString()).equals("2")); 1967 TestFmwk.assertTrue("plu002", ((new android.icu.math.BigDecimal("-2")).plus(mcdef).toString()).equals("-2")); 1968 TestFmwk.assertTrue("plu003", ((new android.icu.math.BigDecimal("2.00")).plus(mcdef).toString()).equals("2.00")); 1969 TestFmwk.assertTrue("plu004", ((new android.icu.math.BigDecimal("-2.00")).plus(mcdef).toString()).equals("-2.00")); 1970 TestFmwk.assertTrue("plu005", ((new android.icu.math.BigDecimal("0")).plus(mcdef).toString()).equals("0")); 1971 TestFmwk.assertTrue("plu006", ((new android.icu.math.BigDecimal("0.00")).plus(mcdef).toString()).equals("0")); 1972 TestFmwk.assertTrue("plu007", ((new android.icu.math.BigDecimal("00.0")).plus(mcdef).toString()).equals("0")); 1973 TestFmwk.assertTrue("plu008", ((new android.icu.math.BigDecimal("00")).plus(mcdef).toString()).equals("0")); 1974 1975 TestFmwk.assertTrue("plu010", ((new android.icu.math.BigDecimal("2")).plus().toString()).equals("2")); 1976 TestFmwk.assertTrue("plu011", ((new android.icu.math.BigDecimal("-2")).plus().toString()).equals("-2")); 1977 TestFmwk.assertTrue("plu012", ((new android.icu.math.BigDecimal("2.00")).plus().toString()).equals("2.00")); 1978 TestFmwk.assertTrue("plu013", ((new android.icu.math.BigDecimal("-2.00")).plus().toString()).equals("-2.00")); 1979 TestFmwk.assertTrue("plu014", ((new android.icu.math.BigDecimal("0")).plus().toString()).equals("0")); 1980 TestFmwk.assertTrue("plu015", ((new android.icu.math.BigDecimal("0.00")).plus().toString()).equals("0.00")); 1981 TestFmwk.assertTrue("plu016", ((new android.icu.math.BigDecimal("00.0")).plus().toString()).equals("0.0")); 1982 TestFmwk.assertTrue("plu017", ((new android.icu.math.BigDecimal("00.00")).plus().toString()).equals("0.00")); 1983 TestFmwk.assertTrue("plu018", ((new android.icu.math.BigDecimal("00")).plus().toString()).equals("0")); 1984 1985 TestFmwk.assertTrue("plu020", ((new android.icu.math.BigDecimal("-2000000")).plus().toString()).equals("-2000000")); 1986 TestFmwk.assertTrue("plu021", ((new android.icu.math.BigDecimal("-2000000")).plus(mcdef).toString()).equals("-2000000")); 1987 TestFmwk.assertTrue("plu022", ((new android.icu.math.BigDecimal("-2000000")).plus(mc6).toString()).equals("-2.00000E+6")); 1988 TestFmwk.assertTrue("plu023", ((new android.icu.math.BigDecimal("2000000")).plus(mc6).toString()).equals("2.00000E+6")); 1989 1990 // try some exotic but silly rounding [format checks more varieties] 1991 // [this mostly ensures we can set up and pass the setting] 1992 mche1=new android.icu.math.MathContext(1,android.icu.math.MathContext.SCIENTIFIC,false,android.icu.math.MathContext.ROUND_HALF_EVEN); 1993 TestFmwk.assertTrue("plu030", ((new android.icu.math.BigDecimal("0.24")).plus(mche1).toString()).equals("0.2")); 1994 TestFmwk.assertTrue("plu031", ((new android.icu.math.BigDecimal("0.25")).plus(mche1).toString()).equals("0.2")); 1995 TestFmwk.assertTrue("plu032", ((new android.icu.math.BigDecimal("0.26")).plus(mche1).toString()).equals("0.3")); 1996 TestFmwk.assertTrue("plu033", ((new android.icu.math.BigDecimal("0.14")).plus(mche1).toString()).equals("0.1")); 1997 TestFmwk.assertTrue("plu034", ((new android.icu.math.BigDecimal("0.15")).plus(mche1).toString()).equals("0.2")); 1998 TestFmwk.assertTrue("plu035", ((new android.icu.math.BigDecimal("0.16")).plus(mche1).toString()).equals("0.2")); 1999 2000 TestFmwk.assertTrue("plu040", ((new android.icu.math.BigDecimal("0.251")).plus(mche1).toString()).equals("0.3")); 2001 TestFmwk.assertTrue("plu041", ((new android.icu.math.BigDecimal("0.151")).plus(mche1).toString()).equals("0.2")); 2002 2003 TestFmwk.assertTrue("plu050", ((new android.icu.math.BigDecimal("-0.24")).plus(mche1).toString()).equals("-0.2")); 2004 TestFmwk.assertTrue("plu051", ((new android.icu.math.BigDecimal("-0.25")).plus(mche1).toString()).equals("-0.2")); 2005 TestFmwk.assertTrue("plu052", ((new android.icu.math.BigDecimal("-0.26")).plus(mche1).toString()).equals("-0.3")); 2006 TestFmwk.assertTrue("plu053", ((new android.icu.math.BigDecimal("-0.14")).plus(mche1).toString()).equals("-0.1")); 2007 TestFmwk.assertTrue("plu054", ((new android.icu.math.BigDecimal("-0.15")).plus(mche1).toString()).equals("-0.2")); 2008 TestFmwk.assertTrue("plu055", ((new android.icu.math.BigDecimal("-0.16")).plus(mche1).toString()).equals("-0.2")); 2009 2010 // more fixed, potential LHS swaps if done by add 0 2011 TestFmwk.assertTrue("plu060", ((new android.icu.math.BigDecimal("-56267E-10")).plus().toString()).equals("-0.0000056267")); 2012 TestFmwk.assertTrue("plu061", ((new android.icu.math.BigDecimal("-56267E-5")).plus().toString()).equals("-0.56267")); 2013 TestFmwk.assertTrue("plu062", ((new android.icu.math.BigDecimal("-56267E-2")).plus().toString()).equals("-562.67")); 2014 TestFmwk.assertTrue("plu063", ((new android.icu.math.BigDecimal("-56267E-1")).plus().toString()).equals("-5626.7")); 2015 TestFmwk.assertTrue("plu065", ((new android.icu.math.BigDecimal("-56267E-0")).plus().toString()).equals("-56267")); 2016 2017 try { 2018 ten.plus((android.icu.math.MathContext) null); 2019 flag = false; 2020 } catch (java.lang.NullPointerException $65) { 2021 flag = true; 2022 }/* checknull */ 2023 TestFmwk.assertTrue("plu100", flag); 2024 2025 try { 2026 tenlong.plus(mcld); 2027 flag = false; 2028 } catch (java.lang.ArithmeticException $66) { 2029 ae = $66; 2030 flag = (ae.getMessage()).equals("Too many digits:" + " " 2031 + tenlong.toString()); 2032 }/* checkdigits */ 2033 TestFmwk.assertTrue("plu101", flag); 2034 } 2035 2036 /* ----------------------------------------------------------------- */ 2037 2038 /** Test the {@link android.icu.math.BigDecimal#pow} method. */ 2039 2040 @Test 2041 public void diagpow() { 2042 boolean flag; 2043 android.icu.math.BigDecimal x; 2044 android.icu.math.BigDecimal temp; 2045 int n = 0; 2046 android.icu.math.BigDecimal vx; 2047 android.icu.math.BigDecimal vn; 2048 java.lang.ArithmeticException ae = null; 2049 flag = true; 2050 TestFmwk.assertTrue("pow001", "1".equals((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("0"),mcdef).toString())); 2051 TestFmwk.assertTrue("pow002", "0.3".equals((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("1"),mcdef).toString())); 2052 TestFmwk.assertTrue("pow003", "0.3".equals((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("1.00"),mcdef).toString())); 2053 TestFmwk.assertTrue("pow004", "0.09".equals((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("2.00"),mcdef).toString())); 2054 TestFmwk.assertTrue("pow005", "0.09".equals((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("2.000000000"),mcdef).toString())); 2055 TestFmwk.assertTrue("pow006", ("1E-8").equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-8"),mcdef).toString())); 2056 TestFmwk.assertTrue("pow007", ("1E-7").equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-7"),mcdef).toString())); 2057 TestFmwk.assertTrue("pow008", "0.000001".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-6"),mcdef).toString())); 2058 TestFmwk.assertTrue("pow009", "0.00001".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-5"),mcdef).toString())); 2059 TestFmwk.assertTrue("pow010", "0.0001".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-4"),mcdef).toString())); 2060 TestFmwk.assertTrue("pow011", "0.001".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-3"),mcdef).toString())); 2061 TestFmwk.assertTrue("pow012", "0.01".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-2"),mcdef).toString())); 2062 TestFmwk.assertTrue("pow013", "0.1".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-1"),mcdef).toString())); 2063 TestFmwk.assertTrue("pow014", "1".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("0"),mcdef).toString())); 2064 TestFmwk.assertTrue("pow015", "10".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("1"),mcdef).toString())); 2065 TestFmwk.assertTrue("pow016", "100000000".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("8"),mcdef).toString())); 2066 TestFmwk.assertTrue("pow017", ("1E+9").equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("9"),mcdef).toString())); 2067 TestFmwk.assertTrue("pow018", ("1E+99").equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("99"),mcdef).toString())); 2068 TestFmwk.assertTrue("pow019", ("1E+999999999").equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("999999999"),mcdef).toString())); 2069 TestFmwk.assertTrue("pow020", ("1E+999999998").equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("999999998"),mcdef).toString())); 2070 TestFmwk.assertTrue("pow021", ("1E+999999997").equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("999999997"),mcdef).toString())); 2071 TestFmwk.assertTrue("pow022", ("1E+333333333").equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("333333333"),mcdef).toString())); 2072 TestFmwk.assertTrue("pow023", ("1E-333333333").equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-333333333"),mcdef).toString())); 2073 TestFmwk.assertTrue("pow024", ("1E-999999998").equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-999999998"),mcdef).toString())); 2074 TestFmwk.assertTrue("pow025", ("1E-999999999").equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-999999999"),mcdef).toString())); 2075 TestFmwk.assertTrue("pow026", "0.5".equals((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("-1"),mcdef).toString())); 2076 TestFmwk.assertTrue("pow027", "0.25".equals((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("-2"),mcdef).toString())); 2077 TestFmwk.assertTrue("pow028", "0.0625".equals((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("-4"),mcdef).toString())); 2078 2079 TestFmwk.assertTrue("pow050", ((new android.icu.math.BigDecimal("0")).pow(new android.icu.math.BigDecimal("0"),mcdef).toString()).equals("1")); 2080 TestFmwk.assertTrue("pow051", ((new android.icu.math.BigDecimal("0")).pow(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("0")); 2081 TestFmwk.assertTrue("pow052", ((new android.icu.math.BigDecimal("0")).pow(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("0")); 2082 TestFmwk.assertTrue("pow053", ((new android.icu.math.BigDecimal("1")).pow(new android.icu.math.BigDecimal("0"),mcdef).toString()).equals("1")); 2083 TestFmwk.assertTrue("pow054", ((new android.icu.math.BigDecimal("1")).pow(new android.icu.math.BigDecimal("1"),mcdef).toString()).equals("1")); 2084 TestFmwk.assertTrue("pow055", ((new android.icu.math.BigDecimal("1")).pow(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("1")); 2085 TestFmwk.assertTrue("pow056", ((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("0"),mcdef).toString()).equals("1")); 2086 TestFmwk.assertTrue("pow057", ((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("999999999"),mcdef).toString()).equals("1E+999999999")); 2087 TestFmwk.assertTrue("pow058", ((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("999999998"),mcdef).toString()).equals("1E+999999998")); 2088 TestFmwk.assertTrue("pow059", ((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("999999997"),mcdef).toString()).equals("1E+999999997")); 2089 TestFmwk.assertTrue("pow060", ((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("333333333"),mcdef).toString()).equals("1E+333333333")); 2090 TestFmwk.assertTrue("pow061", ((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("77"),mcdef).toString()).equals("1E+77")); 2091 TestFmwk.assertTrue("pow062", ((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("22"),mcdef).toString()).equals("1E+22")); 2092 TestFmwk.assertTrue("pow063", ((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-77"),mcdef).toString()).equals("1E-77")); 2093 TestFmwk.assertTrue("pow064", ((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("-22"),mcdef).toString()).equals("1E-22")); 2094 TestFmwk.assertTrue("pow065", ((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("-1"),mcdef).toString()).equals("0.5")); 2095 TestFmwk.assertTrue("pow066", ((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("-2"),mcdef).toString()).equals("0.25")); 2096 TestFmwk.assertTrue("pow067", ((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("-4"),mcdef).toString()).equals("0.0625")); 2097 TestFmwk.assertTrue("pow068", ((new android.icu.math.BigDecimal("6.0")).pow(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("36")); 2098 TestFmwk.assertTrue("pow069", ((new android.icu.math.BigDecimal("-3")).pow(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("9"));/* from book */ 2099 TestFmwk.assertTrue("pow070", ((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("2"),mcdef).pow(new android.icu.math.BigDecimal("3"),mcdef).toString()).equals("64"));/* from book */ 2100 2101 // 1998.12.14 Next test removed as pow() no longer rounds RHS [as per ANSI] 2102 // Test('pow071').ok=BigDecimal('2').pow(BigDecimal('2.000000001'),mcdef).toString == '4'/* check input rounding */ 2103 2104 /* General tests from original Rexx diagnostics */ 2105 x = new android.icu.math.BigDecimal("0.5"); 2106 temp = android.icu.math.BigDecimal.ONE; 2107 flag = true; 2108 { 2109 n = 1; 2110 for (; n <= 10; n++) { 2111 temp = temp.multiply(x).divide(android.icu.math.BigDecimal.ONE); 2112 flag = flag 2113 & (x.pow(new android.icu.math.BigDecimal(n), mcdef) 2114 .toString()).equals(temp.toString()); 2115 } 2116 }/* n */ 2117 TestFmwk.assertTrue("pow080", flag); 2118 2119 x = new android.icu.math.BigDecimal("2"); 2120 temp = android.icu.math.BigDecimal.ONE; 2121 flag = true; 2122 { 2123 n = 1; 2124 for (; n <= 29; n++) { 2125 temp = temp.multiply(x).divide(android.icu.math.BigDecimal.ONE); 2126 flag=flag&(x.pow(new android.icu.math.BigDecimal(n),mcdef).toString()).equals(temp.toString()); 2127 flag=flag&(x.pow(new android.icu.math.BigDecimal(-n),mcdef).toString()).equals(android.icu.math.BigDecimal.ONE.divide(temp,mcdef).toString()); 2128 /* Note that rounding errors are possible for larger "n" */ 2129 /* due to the information content of the exponent */ 2130 } 2131 }/* n */ 2132 TestFmwk.assertTrue("pow081", flag); 2133 2134 /* The Vienna case. Checks both setup and 1/acc working precision */ 2135 // Modified 1998.12.14 as RHS no longer rounded before use (must fit) 2136 // Modified 1990.02.04 as LHS is now rounded (instead of truncated to guard) 2137 vx=new android.icu.math.BigDecimal("123456789E+10"); // lhs .. rounded to 1.23E+18 2138 vn=new android.icu.math.BigDecimal("-1.23000e+2"); // rhs .. [was: -1.23455e+2, rounds to -123] 2139 TestFmwk.assertTrue("pow090", (vx.pow(vn,mc3).toString()).equals("8.74E-2226")); 2140 2141 // - fixed point versions --- 2142 TestFmwk.assertTrue("pow101", "1".equals((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("0")).toString())); 2143 TestFmwk.assertTrue("pow102", "0.3".equals((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("1")).toString())); 2144 TestFmwk.assertTrue("pow103", "0.3".equals((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("1.00")).toString())); 2145 TestFmwk.assertTrue("pow104", "0.09".equals((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("2")).toString())); 2146 TestFmwk.assertTrue("pow105", "0.09".equals((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("2.00")).toString())); 2147 TestFmwk.assertTrue("pow106", "10".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("1")).toString())); 2148 TestFmwk.assertTrue("pow107", "100000000".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("8")).toString())); 2149 TestFmwk.assertTrue("pow108", "1000000000".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("9")).toString())); 2150 TestFmwk.assertTrue("pow109", "10000000000".equals((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("10")).toString())); 2151 TestFmwk.assertTrue("pow110", "1".equals((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("0")).toString())); 2152 TestFmwk.assertTrue("pow111", "16".equals((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("4")).toString())); 2153 TestFmwk.assertTrue("pow112", "256".equals((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("8")).toString())); 2154 TestFmwk.assertTrue("pow113", "1024".equals((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("10")).toString())); 2155 TestFmwk.assertTrue("pow114", "1.0510100501".equals((new android.icu.math.BigDecimal("1.01")).pow(new android.icu.math.BigDecimal("5")).toString())); 2156 2157 TestFmwk.assertTrue("pow120", ((new android.icu.math.BigDecimal("0")).pow(new android.icu.math.BigDecimal("0")).toString()).equals("1")); 2158 TestFmwk.assertTrue("pow121", ((new android.icu.math.BigDecimal("0")).pow(new android.icu.math.BigDecimal("1")).toString()).equals("0")); 2159 TestFmwk.assertTrue("pow122", ((new android.icu.math.BigDecimal("0")).pow(new android.icu.math.BigDecimal("2")).toString()).equals("0")); 2160 TestFmwk.assertTrue("pow123", ((new android.icu.math.BigDecimal("1")).pow(new android.icu.math.BigDecimal("0")).toString()).equals("1")); 2161 TestFmwk.assertTrue("pow144", ((new android.icu.math.BigDecimal("1")).pow(new android.icu.math.BigDecimal("1")).toString()).equals("1")); 2162 TestFmwk.assertTrue("pow125", ((new android.icu.math.BigDecimal("1")).pow(new android.icu.math.BigDecimal("2")).toString()).equals("1")); 2163 TestFmwk.assertTrue("pow126", ((new android.icu.math.BigDecimal("0.3")).pow(new android.icu.math.BigDecimal("0")).toString()).equals("1")); 2164 TestFmwk.assertTrue("pow127", ((new android.icu.math.BigDecimal("10")).pow(new android.icu.math.BigDecimal("7")).toString()).equals("10000000")); 2165 TestFmwk.assertTrue("pow128", ((new android.icu.math.BigDecimal("6.0")).pow(new android.icu.math.BigDecimal("2")).toString()).equals("36.00")); 2166 TestFmwk.assertTrue("pow129", ((new android.icu.math.BigDecimal("6.00")).pow(new android.icu.math.BigDecimal("2")).toString()).equals("36.0000")); 2167 TestFmwk.assertTrue("pow130", ((new android.icu.math.BigDecimal("6.000")).pow(new android.icu.math.BigDecimal("2")).toString()).equals("36.000000")); 2168 TestFmwk.assertTrue("pow131", ((new android.icu.math.BigDecimal("-3")).pow(new android.icu.math.BigDecimal("2")).toString()).equals("9")); 2169 TestFmwk.assertTrue("pow132", ((new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("2")).pow(new android.icu.math.BigDecimal("3")).toString()).equals("64")); 2170 2171 /* errors */ 2172 try { 2173 ten.pow((android.icu.math.BigDecimal) null); 2174 flag = false; 2175 } catch (java.lang.NullPointerException $67) { 2176 flag = true; 2177 }/* checknull */ 2178 TestFmwk.assertTrue("pow150", flag); 2179 try { 2180 ten.pow(ten, (android.icu.math.MathContext) null); 2181 flag = false; 2182 } catch (java.lang.NullPointerException $68) { 2183 flag = true; 2184 }/* checknull2 */ 2185 TestFmwk.assertTrue("pow151", flag); 2186 2187 flag = true; 2188 try { 2189 tenlong.pow(android.icu.math.BigDecimal.ONE, mcld); 2190 flag = false; 2191 } catch (java.lang.ArithmeticException $69) { 2192 ae = $69; 2193 flag = (ae.getMessage()).equals("Too many digits:" + " " 2194 + tenlong.toString()); 2195 }/* checkdigits */ 2196 TestFmwk.assertTrue("pow152", flag); 2197 2198 try { 2199 android.icu.math.BigDecimal.ONE.pow(tenlong, mcld); 2200 flag = false; 2201 } catch (java.lang.ArithmeticException $70) { 2202 ae = $70; 2203 flag = (ae.getMessage()).equals("Too many digits:" + " " 2204 + tenlong.toString()); 2205 }/* checkdigits */ 2206 TestFmwk.assertTrue("pow153", flag); 2207 2208 try { 2209 android.icu.math.BigDecimal.ONE 2210 .pow(new android.icu.math.BigDecimal("-71")); 2211 flag = false; 2212 } catch (java.lang.ArithmeticException $71) { 2213 ae = $71; 2214 flag = (ae.getMessage()).equals("Negative power: -71"); 2215 }/* checkpos */ 2216 TestFmwk.assertTrue("pow154", flag); 2217 2218 try { 2219 android.icu.math.BigDecimal.ONE.pow( 2220 new android.icu.math.BigDecimal("1234"), mc3); 2221 flag = false; 2222 } catch (java.lang.ArithmeticException $72) { 2223 ae = $72; 2224 flag = (ae.getMessage()).equals("Too many digits: 1234"); 2225 }/* checkwhole */ 2226 TestFmwk.assertTrue("pow155", flag); 2227 2228 try { 2229 android.icu.math.BigDecimal.ONE.pow( 2230 new android.icu.math.BigDecimal("12.34e+2"), mc3); 2231 flag = false; 2232 } catch (java.lang.ArithmeticException $73) { 2233 ae = $73; 2234 flag = (ae.getMessage()).equals("Too many digits: 1.234E+3"); 2235 }/* checkwhole1 */ 2236 TestFmwk.assertTrue("pow156", flag); 2237 2238 try { 2239 android.icu.math.BigDecimal.ONE.pow( 2240 new android.icu.math.BigDecimal("12.4"), mcdef); 2241 flag = false; 2242 } catch (java.lang.ArithmeticException $74) { 2243 ae = $74; 2244 flag = (ae.getMessage()).equals("Decimal part non-zero: 12.4"); 2245 }/* checkwhole2 */ 2246 TestFmwk.assertTrue("pow157", flag); 2247 2248 try { 2249 android.icu.math.BigDecimal.ONE.pow( 2250 new android.icu.math.BigDecimal("1.01"), mcdef); 2251 flag = false; 2252 } catch (java.lang.ArithmeticException $75) { 2253 ae = $75; 2254 flag = (ae.getMessage()).equals("Decimal part non-zero: 1.01"); 2255 }/* checkwhole3 */ 2256 TestFmwk.assertTrue("pow158", flag); 2257 2258 try { 2259 android.icu.math.BigDecimal.ONE.pow( 2260 new android.icu.math.BigDecimal("1.000000001"), mcdef); 2261 flag = false; 2262 } catch (java.lang.ArithmeticException $76) { 2263 ae = $76; 2264 flag = (ae.getMessage()) 2265 .equals("Decimal part non-zero: 1.000000001"); 2266 }/* checkwhole4 */ 2267 TestFmwk.assertTrue("pow159", flag); 2268 2269 try { 2270 android.icu.math.BigDecimal.ONE.pow( 2271 new android.icu.math.BigDecimal("1.000000001"), mc3); 2272 flag = false; 2273 } catch (java.lang.ArithmeticException $77) { 2274 ae = $77; 2275 flag = (ae.getMessage()) 2276 .equals("Decimal part non-zero: 1.000000001"); 2277 }/* checkwhole5 */ 2278 TestFmwk.assertTrue("pow160", flag); 2279 2280 try { 2281 android.icu.math.BigDecimal.ONE 2282 .pow( 2283 new android.icu.math.BigDecimal( 2284 "5.67E-987654321"), mc3); 2285 flag = false; 2286 } catch (java.lang.ArithmeticException $78) { 2287 ae = $78; 2288 flag = (ae.getMessage()) 2289 .equals("Decimal part non-zero: 5.67E-987654321"); 2290 }/* checkwhole6 */ 2291 TestFmwk.assertTrue("pow161", flag); 2292 } 2293 2294 /*--------------------------------------------------------------------*/ 2295 2296 /** Test the {@link android.icu.math.BigDecimal#remainder} method. */ 2297 2298 @Test 2299 public void diagremainder() { 2300 boolean flag = false; 2301 java.lang.ArithmeticException ae = null; 2302 2303 TestFmwk.assertTrue("rem001", ((new android.icu.math.BigDecimal("1")).remainder(new android.icu.math.BigDecimal("3"),mcdef).toString()).equals("1")); 2304 TestFmwk.assertTrue("rem002", ((new android.icu.math.BigDecimal("5")).remainder(new android.icu.math.BigDecimal("5"),mcdef).toString()).equals("0")); 2305 TestFmwk.assertTrue("rem003", ((new android.icu.math.BigDecimal("13")).remainder(new android.icu.math.BigDecimal("10"),mcdef).toString()).equals("3")); 2306 TestFmwk.assertTrue("rem004", ((new android.icu.math.BigDecimal("13")).remainder(new android.icu.math.BigDecimal("50"),mcdef).toString()).equals("13")); 2307 TestFmwk.assertTrue("rem005", ((new android.icu.math.BigDecimal("13")).remainder(new android.icu.math.BigDecimal("100"),mcdef).toString()).equals("13")); 2308 TestFmwk.assertTrue("rem006", ((new android.icu.math.BigDecimal("13")).remainder(new android.icu.math.BigDecimal("1000"),mcdef).toString()).equals("13")); 2309 TestFmwk.assertTrue("rem007", ((new android.icu.math.BigDecimal(".13")).remainder(one).toString()).equals("0.13")); 2310 TestFmwk.assertTrue("rem008", ((new android.icu.math.BigDecimal("0.133")).remainder(one).toString()).equals("0.133")); 2311 TestFmwk.assertTrue("rem009", ((new android.icu.math.BigDecimal("0.1033")).remainder(one).toString()).equals("0.1033")); 2312 TestFmwk.assertTrue("rem010", ((new android.icu.math.BigDecimal("1.033")).remainder(one).toString()).equals("0.033")); 2313 TestFmwk.assertTrue("rem011", ((new android.icu.math.BigDecimal("10.33")).remainder(one).toString()).equals("0.33")); 2314 TestFmwk.assertTrue("rem012", ((new android.icu.math.BigDecimal("10.33")).remainder(android.icu.math.BigDecimal.TEN).toString()).equals("0.33")); 2315 TestFmwk.assertTrue("rem013", ((new android.icu.math.BigDecimal("103.3")).remainder(android.icu.math.BigDecimal.ONE).toString()).equals("0.3")); 2316 TestFmwk.assertTrue("rem014", ((new android.icu.math.BigDecimal("133")).remainder(android.icu.math.BigDecimal.TEN).toString()).equals("3")); 2317 TestFmwk.assertTrue("rem015", ((new android.icu.math.BigDecimal("1033")).remainder(android.icu.math.BigDecimal.TEN).toString()).equals("3")); 2318 TestFmwk.assertTrue("rem016", ((new android.icu.math.BigDecimal("1033")).remainder(new android.icu.math.BigDecimal(50),mcdef).toString()).equals("33")); 2319 TestFmwk.assertTrue("rem017", ((new android.icu.math.BigDecimal("101.0")).remainder(new android.icu.math.BigDecimal(3),mcdef).toString()).equals("2.0")); 2320 TestFmwk.assertTrue("rem018", ((new android.icu.math.BigDecimal("102.0")).remainder(new android.icu.math.BigDecimal(3),mcdef).toString()).equals("0")); 2321 TestFmwk.assertTrue("rem019", ((new android.icu.math.BigDecimal("103.0")).remainder(new android.icu.math.BigDecimal(3),mcdef).toString()).equals("1.0")); 2322 TestFmwk.assertTrue("rem020", ((new android.icu.math.BigDecimal("2.40")).remainder(one).toString()).equals("0.40")); 2323 TestFmwk.assertTrue("rem021", ((new android.icu.math.BigDecimal("2.400")).remainder(one).toString()).equals("0.400")); 2324 TestFmwk.assertTrue("rem022", ((new android.icu.math.BigDecimal("2.4")).remainder(one).toString()).equals("0.4")); 2325 TestFmwk.assertTrue("rem023", ((new android.icu.math.BigDecimal("2.4")).remainder(new android.icu.math.BigDecimal(2),mcdef).toString()).equals("0.4")); 2326 TestFmwk.assertTrue("rem024", ((new android.icu.math.BigDecimal("2.400")).remainder(new android.icu.math.BigDecimal(2),mcdef).toString()).equals("0.400")); 2327 TestFmwk.assertTrue("rem025", ((new android.icu.math.BigDecimal("1")).remainder(new android.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.1")); 2328 TestFmwk.assertTrue("rem026", ((new android.icu.math.BigDecimal("1")).remainder(new android.icu.math.BigDecimal("0.30"),mcdef).toString()).equals("0.10")); 2329 TestFmwk.assertTrue("rem027", ((new android.icu.math.BigDecimal("1")).remainder(new android.icu.math.BigDecimal("0.300"),mcdef).toString()).equals("0.100")); 2330 TestFmwk.assertTrue("rem028", ((new android.icu.math.BigDecimal("1")).remainder(new android.icu.math.BigDecimal("0.3000"),mcdef).toString()).equals("0.1000")); 2331 TestFmwk.assertTrue("rem029", ((new android.icu.math.BigDecimal("1.0")).remainder(new android.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.1")); 2332 TestFmwk.assertTrue("rem030", ((new android.icu.math.BigDecimal("1.00")).remainder(new android.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.10")); 2333 TestFmwk.assertTrue("rem031", ((new android.icu.math.BigDecimal("1.000")).remainder(new android.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.100")); 2334 TestFmwk.assertTrue("rem032", ((new android.icu.math.BigDecimal("1.0000")).remainder(new android.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.1000")); 2335 TestFmwk.assertTrue("rem033", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("2.001"),mcdef).toString()).equals("0.5")); 2336 2337 TestFmwk.assertTrue("rem040", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.5000001"),mcdef).toString()).equals("0.5")); 2338 TestFmwk.assertTrue("rem041", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.50000001"),mcdef).toString()).equals("0.5")); 2339 TestFmwk.assertTrue("rem042", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.500000001"),mcdef).toString()).equals("0.5")); 2340 TestFmwk.assertTrue("rem043", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.5000000001"),mcdef).toString()).equals("0")); 2341 TestFmwk.assertTrue("rem044", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.50000000001"),mcdef).toString()).equals("0")); 2342 TestFmwk.assertTrue("rem045", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.4999999"),mcdef).toString()).equals("1E-7")); 2343 TestFmwk.assertTrue("rem046", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.49999999"),mcdef).toString()).equals("1E-8")); 2344 TestFmwk.assertTrue("rem047", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.499999999"),mcdef).toString()).equals("1E-9")); 2345 TestFmwk.assertTrue("rem048", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.4999999999"),mcdef).toString()).equals("0")); 2346 TestFmwk.assertTrue("rem049", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.49999999999"),mcdef).toString()).equals("0")); 2347 2348 TestFmwk.assertTrue("rem050", ((new android.icu.math.BigDecimal("0.03")).remainder(new android.icu.math.BigDecimal("7"),mcdef).toString()).equals("0.03")); 2349 TestFmwk.assertTrue("rem051", ((new android.icu.math.BigDecimal("5")).remainder(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("1")); 2350 TestFmwk.assertTrue("rem052", ((new android.icu.math.BigDecimal("4.1")).remainder(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.1")); 2351 TestFmwk.assertTrue("rem053", ((new android.icu.math.BigDecimal("4.01")).remainder(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.01")); 2352 TestFmwk.assertTrue("rem054", ((new android.icu.math.BigDecimal("4.001")).remainder(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.001")); 2353 TestFmwk.assertTrue("rem055", ((new android.icu.math.BigDecimal("4.0001")).remainder(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.0001")); 2354 TestFmwk.assertTrue("rem056", ((new android.icu.math.BigDecimal("4.00001")).remainder(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.00001")); 2355 TestFmwk.assertTrue("rem057", ((new android.icu.math.BigDecimal("4.000001")).remainder(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.000001")); 2356 TestFmwk.assertTrue("rem058", ((new android.icu.math.BigDecimal("4.0000001")).remainder(new android.icu.math.BigDecimal("2"),mcdef).toString()).equals("1E-7")); 2357 2358 TestFmwk.assertTrue("rem060", ((new android.icu.math.BigDecimal("1.2")).remainder(new android.icu.math.BigDecimal("0.7345"),mcdef).toString()).equals("0.4655")); 2359 TestFmwk.assertTrue("rem061", ((new android.icu.math.BigDecimal("0.8")).remainder(new android.icu.math.BigDecimal("12"),mcdef).toString()).equals("0.8")); 2360 TestFmwk.assertTrue("rem062", ((new android.icu.math.BigDecimal("0.8")).remainder(new android.icu.math.BigDecimal("0.2"),mcdef).toString()).equals("0")); 2361 TestFmwk.assertTrue("rem063", ((new android.icu.math.BigDecimal("0.8")).remainder(new android.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.2")); 2362 TestFmwk.assertTrue("rem064", ((new android.icu.math.BigDecimal("0.800")).remainder(new android.icu.math.BigDecimal("12"),mcdef).toString()).equals("0.800")); 2363 TestFmwk.assertTrue("rem065", ((new android.icu.math.BigDecimal("0.800")).remainder(new android.icu.math.BigDecimal("1.7"),mcdef).toString()).equals("0.800")); 2364 TestFmwk.assertTrue("rem066", ((new android.icu.math.BigDecimal("2.400")).remainder(new android.icu.math.BigDecimal(2),mcdef).toString()).equals("0.400")); 2365 2366 // MC -- 2367 TestFmwk.assertTrue("rem071", ((new android.icu.math.BigDecimal("2.400")).remainder(new android.icu.math.BigDecimal(2),mc6).toString()).equals("0.400")); 2368 TestFmwk.assertTrue("rem072", ((new android.icu.math.BigDecimal("12345678900000")).remainder(new android.icu.math.BigDecimal("12e+12"),mc3).toString()).equals("3E+11")); 2369 2370 // Fixed -- 2371 TestFmwk.assertTrue("rem101", ((new android.icu.math.BigDecimal("1")).remainder(new android.icu.math.BigDecimal("3")).toString()).equals("1")); 2372 TestFmwk.assertTrue("rem102", ((new android.icu.math.BigDecimal("5")).remainder(new android.icu.math.BigDecimal("5")).toString()).equals("0")); 2373 TestFmwk.assertTrue("rem103", ((new android.icu.math.BigDecimal("13")).remainder(new android.icu.math.BigDecimal("10")).toString()).equals("3")); 2374 TestFmwk.assertTrue("rem104", ((new android.icu.math.BigDecimal("13")).remainder(new android.icu.math.BigDecimal("50")).toString()).equals("13")); 2375 TestFmwk.assertTrue("rem105", ((new android.icu.math.BigDecimal("13")).remainder(new android.icu.math.BigDecimal("100")).toString()).equals("13")); 2376 TestFmwk.assertTrue("rem106", ((new android.icu.math.BigDecimal("13")).remainder(new android.icu.math.BigDecimal("1000")).toString()).equals("13")); 2377 TestFmwk.assertTrue("rem107", ((new android.icu.math.BigDecimal(".13")).remainder(one).toString()).equals("0.13")); 2378 TestFmwk.assertTrue("rem108", ((new android.icu.math.BigDecimal("0.133")).remainder(one).toString()).equals("0.133")); 2379 TestFmwk.assertTrue("rem109", ((new android.icu.math.BigDecimal("0.1033")).remainder(one).toString()).equals("0.1033")); 2380 TestFmwk.assertTrue("rem110", ((new android.icu.math.BigDecimal("1.033")).remainder(one).toString()).equals("0.033")); 2381 TestFmwk.assertTrue("rem111", ((new android.icu.math.BigDecimal("10.33")).remainder(one).toString()).equals("0.33")); 2382 TestFmwk.assertTrue("rem112", ((new android.icu.math.BigDecimal("10.33")).remainder(android.icu.math.BigDecimal.TEN).toString()).equals("0.33")); 2383 TestFmwk.assertTrue("rem113", ((new android.icu.math.BigDecimal("103.3")).remainder(android.icu.math.BigDecimal.ONE).toString()).equals("0.3")); 2384 TestFmwk.assertTrue("rem114", ((new android.icu.math.BigDecimal("133")).remainder(android.icu.math.BigDecimal.TEN).toString()).equals("3")); 2385 TestFmwk.assertTrue("rem115", ((new android.icu.math.BigDecimal("1033")).remainder(android.icu.math.BigDecimal.TEN).toString()).equals("3")); 2386 TestFmwk.assertTrue("rem116", ((new android.icu.math.BigDecimal("1033")).remainder(new android.icu.math.BigDecimal(50)).toString()).equals("33")); 2387 TestFmwk.assertTrue("rem117", ((new android.icu.math.BigDecimal("101.0")).remainder(new android.icu.math.BigDecimal(3)).toString()).equals("2.0")); 2388 TestFmwk.assertTrue("rem118", ((new android.icu.math.BigDecimal("102.0")).remainder(new android.icu.math.BigDecimal(3)).toString()).equals("0")); 2389 TestFmwk.assertTrue("rem119", ((new android.icu.math.BigDecimal("103.0")).remainder(new android.icu.math.BigDecimal(3)).toString()).equals("1.0")); 2390 TestFmwk.assertTrue("rem120", ((new android.icu.math.BigDecimal("2.40")).remainder(one).toString()).equals("0.40")); 2391 TestFmwk.assertTrue("rem121", ((new android.icu.math.BigDecimal("2.400")).remainder(one).toString()).equals("0.400")); 2392 TestFmwk.assertTrue("rem122", ((new android.icu.math.BigDecimal("2.4")).remainder(one).toString()).equals("0.4")); 2393 TestFmwk.assertTrue("rem123", ((new android.icu.math.BigDecimal("2.4")).remainder(new android.icu.math.BigDecimal(2)).toString()).equals("0.4")); 2394 TestFmwk.assertTrue("rem124", ((new android.icu.math.BigDecimal("2.400")).remainder(new android.icu.math.BigDecimal(2)).toString()).equals("0.400")); 2395 TestFmwk.assertTrue("rem125", ((new android.icu.math.BigDecimal("1")).remainder(new android.icu.math.BigDecimal("0.3")).toString()).equals("0.1")); 2396 TestFmwk.assertTrue("rem126", ((new android.icu.math.BigDecimal("1")).remainder(new android.icu.math.BigDecimal("0.30")).toString()).equals("0.10")); 2397 TestFmwk.assertTrue("rem127", ((new android.icu.math.BigDecimal("1")).remainder(new android.icu.math.BigDecimal("0.300")).toString()).equals("0.100")); 2398 TestFmwk.assertTrue("rem128", ((new android.icu.math.BigDecimal("1")).remainder(new android.icu.math.BigDecimal("0.3000")).toString()).equals("0.1000")); 2399 TestFmwk.assertTrue("rem129", ((new android.icu.math.BigDecimal("1.0")).remainder(new android.icu.math.BigDecimal("0.3")).toString()).equals("0.1")); 2400 TestFmwk.assertTrue("rem130", ((new android.icu.math.BigDecimal("1.00")).remainder(new android.icu.math.BigDecimal("0.3")).toString()).equals("0.10")); 2401 TestFmwk.assertTrue("rem131", ((new android.icu.math.BigDecimal("1.000")).remainder(new android.icu.math.BigDecimal("0.3")).toString()).equals("0.100")); 2402 TestFmwk.assertTrue("rem132", ((new android.icu.math.BigDecimal("1.0000")).remainder(new android.icu.math.BigDecimal("0.3")).toString()).equals("0.1000")); 2403 TestFmwk.assertTrue("rem133", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("2.001")).toString()).equals("0.5")); 2404 TestFmwk.assertTrue("rem134", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.500000001")).toString()).equals("0.5")); 2405 TestFmwk.assertTrue("rem135", ((new android.icu.math.BigDecimal("0.5")).remainder(new android.icu.math.BigDecimal("0.5000000001")).toString()).equals("0.5")); 2406 TestFmwk.assertTrue("rem136", ((new android.icu.math.BigDecimal("0.03")).remainder(new android.icu.math.BigDecimal("7")).toString()).equals("0.03")); 2407 TestFmwk.assertTrue("rem137", ((new android.icu.math.BigDecimal("5")).remainder(new android.icu.math.BigDecimal("2")).toString()).equals("1")); 2408 TestFmwk.assertTrue("rem138", ((new android.icu.math.BigDecimal("4.1")).remainder(new android.icu.math.BigDecimal("2")).toString()).equals("0.1")); 2409 TestFmwk.assertTrue("rem139", ((new android.icu.math.BigDecimal("4.01")).remainder(new android.icu.math.BigDecimal("2")).toString()).equals("0.01")); 2410 TestFmwk.assertTrue("rem140", ((new android.icu.math.BigDecimal("4.001")).remainder(new android.icu.math.BigDecimal("2")).toString()).equals("0.001")); 2411 TestFmwk.assertTrue("rem141", ((new android.icu.math.BigDecimal("4.0001")).remainder(new android.icu.math.BigDecimal("2")).toString()).equals("0.0001")); 2412 TestFmwk.assertTrue("rem142", ((new android.icu.math.BigDecimal("4.00001")).remainder(new android.icu.math.BigDecimal("2")).toString()).equals("0.00001")); 2413 TestFmwk.assertTrue("rem143", ((new android.icu.math.BigDecimal("4.000001")).remainder(new android.icu.math.BigDecimal("2")).toString()).equals("0.000001")); 2414 TestFmwk.assertTrue("rem144", ((new android.icu.math.BigDecimal("4.0000001")).remainder(new android.icu.math.BigDecimal("2")).toString()).equals("0.0000001")); // 1E-7, plain 2415 TestFmwk.assertTrue("rem145", ((new android.icu.math.BigDecimal("1.2")).remainder(new android.icu.math.BigDecimal("0.7345")).toString()).equals("0.4655")); 2416 TestFmwk.assertTrue("rem146", ((new android.icu.math.BigDecimal("0.8")).remainder(new android.icu.math.BigDecimal("12")).toString()).equals("0.8")); 2417 TestFmwk.assertTrue("rem147", ((new android.icu.math.BigDecimal("0.8")).remainder(new android.icu.math.BigDecimal("0.2")).toString()).equals("0")); 2418 TestFmwk.assertTrue("rem148", ((new android.icu.math.BigDecimal("0.8")).remainder(new android.icu.math.BigDecimal("0.3")).toString()).equals("0.2")); 2419 TestFmwk.assertTrue("rem149", ((new android.icu.math.BigDecimal("0.800")).remainder(new android.icu.math.BigDecimal("12")).toString()).equals("0.800")); 2420 TestFmwk.assertTrue("rem150", ((new android.icu.math.BigDecimal("0.800")).remainder(new android.icu.math.BigDecimal("1.7")).toString()).equals("0.800")); 2421 TestFmwk.assertTrue("rem151", ((new android.icu.math.BigDecimal("2.400")).remainder(new android.icu.math.BigDecimal(2),mcdef).toString()).equals("0.400")); 2422 2423 2424 try { 2425 ten.remainder((android.icu.math.BigDecimal) null); 2426 flag = false; 2427 } catch (java.lang.NullPointerException $79) { 2428 flag = true; 2429 }/* checknull */ 2430 TestFmwk.assertTrue("rem200", flag); 2431 try { 2432 ten.remainder(ten, (android.icu.math.MathContext) null); 2433 flag = false; 2434 } catch (java.lang.NullPointerException $80) { 2435 flag = true; 2436 }/* checknull2 */ 2437 TestFmwk.assertTrue("rem201", flag); 2438 2439 try { 2440 android.icu.math.BigDecimal.ONE.remainder(tenlong, mcld); 2441 flag = false; 2442 } catch (java.lang.ArithmeticException $81) { 2443 ae = $81; 2444 flag = (ae.getMessage()).equals("Too many digits:" + " " 2445 + tenlong.toString()); 2446 }/* checkdigits */ 2447 TestFmwk.assertTrue("rem202", flag); 2448 2449 try { 2450 tenlong.remainder(one, mcld); 2451 flag = false; 2452 } catch (java.lang.ArithmeticException $82) { 2453 ae = $82; 2454 flag = (ae.getMessage()).equals("Too many digits:" + " " 2455 + tenlong.toString()); 2456 }/* checkdigits */ 2457 TestFmwk.assertTrue("rem203", flag); 2458 } 2459 2460 /*--------------------------------------------------------------------*/ 2461 2462 /** Test the {@link android.icu.math.BigDecimal#subtract} method. */ 2463 2464 @Test 2465 public void diagsubtract() { 2466 boolean flag = false; 2467 android.icu.math.BigDecimal alhs; 2468 android.icu.math.BigDecimal arhs; 2469 java.lang.ArithmeticException ae = null; 2470 2471 // [first group are 'quick confidence check'] 2472 TestFmwk.assertTrue("sub301", ((new android.icu.math.BigDecimal(2)).subtract(new android.icu.math.BigDecimal(3),mcdef).toString()).equals("-1")); 2473 TestFmwk.assertTrue("sub302", ((new android.icu.math.BigDecimal("5.75")).subtract(new android.icu.math.BigDecimal("3.3"),mcdef).toString()).equals("2.45")); 2474 TestFmwk.assertTrue("sub303", ((new android.icu.math.BigDecimal("5")).subtract(new android.icu.math.BigDecimal("-3"),mcdef).toString()).equals("8")); 2475 TestFmwk.assertTrue("sub304", ((new android.icu.math.BigDecimal("-5")).subtract(new android.icu.math.BigDecimal("-3"),mcdef).toString()).equals("-2")); 2476 TestFmwk.assertTrue("sub305", ((new android.icu.math.BigDecimal("-7")).subtract(new android.icu.math.BigDecimal("2.5"),mcdef).toString()).equals("-9.5")); 2477 TestFmwk.assertTrue("sub306", ((new android.icu.math.BigDecimal("0.7")).subtract(new android.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.4")); 2478 TestFmwk.assertTrue("sub307", ((new android.icu.math.BigDecimal("1.3")).subtract(new android.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("1.0")); 2479 TestFmwk.assertTrue("sub308", ((new android.icu.math.BigDecimal("1.25")).subtract(new android.icu.math.BigDecimal("1.25"),mcdef).toString()).equals("0")); 2480 TestFmwk.assertTrue("sub309", ((new android.icu.math.BigDecimal("1.23456789")).subtract(new android.icu.math.BigDecimal("1.00000000"),mcdef).toString()).equals("0.23456789")); 2481 2482 TestFmwk.assertTrue("sub310", ((new android.icu.math.BigDecimal("1.23456789")).subtract(new android.icu.math.BigDecimal("1.00000089"),mcdef).toString()).equals("0.23456700")); 2483 2484 TestFmwk.assertTrue("sub311", ((new android.icu.math.BigDecimal("0.5555555559")).subtract(new android.icu.math.BigDecimal("0.0000000001"),mcdef).toString()).equals("0.555555556")); 2485 2486 TestFmwk.assertTrue("sub312", ((new android.icu.math.BigDecimal("0.5555555559")).subtract(new android.icu.math.BigDecimal("0.0000000005"),mcdef).toString()).equals("0.555555556")); 2487 2488 TestFmwk.assertTrue("sub313", ((new android.icu.math.BigDecimal("0.4444444444")).subtract(new android.icu.math.BigDecimal("0.1111111111"),mcdef).toString()).equals("0.333333333")); 2489 2490 TestFmwk.assertTrue("sub314", ((new android.icu.math.BigDecimal("1.0000000000")).subtract(new android.icu.math.BigDecimal("0.00000001"),mcdef).toString()).equals("0.99999999")); 2491 2492 TestFmwk.assertTrue("sub315", ((new android.icu.math.BigDecimal("0.4444444444999")).subtract(new android.icu.math.BigDecimal("0"),mcdef).toString()).equals("0.444444444")); 2493 2494 TestFmwk.assertTrue("sub316", ((new android.icu.math.BigDecimal("0.4444444445000")).subtract(new android.icu.math.BigDecimal("0"),mcdef).toString()).equals("0.444444445")); 2495 2496 2497 TestFmwk.assertTrue("sub317", ((new android.icu.math.BigDecimal("70")).subtract(new android.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("-1.00000000E+13")); 2498 2499 TestFmwk.assertTrue("sub318", ((new android.icu.math.BigDecimal("700")).subtract(new android.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("-1.00000000E+13")); 2500 2501 TestFmwk.assertTrue("sub319", ((new android.icu.math.BigDecimal("7000")).subtract(new android.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("-1.00000000E+13")); 2502 2503 TestFmwk.assertTrue("sub320", ((new android.icu.math.BigDecimal("70000")).subtract(new android.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("-9.9999999E+12")); 2504 2505 TestFmwk.assertTrue("sub321", ((new android.icu.math.BigDecimal("700000")).subtract(new android.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("-9.9999993E+12")); 2506 2507 // symmetry: 2508 TestFmwk.assertTrue("sub322", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("70"),mcdef).toString()).equals("1.00000000E+13")); 2509 2510 TestFmwk.assertTrue("sub323", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("700"),mcdef).toString()).equals("1.00000000E+13")); 2511 2512 TestFmwk.assertTrue("sub324", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("7000"),mcdef).toString()).equals("1.00000000E+13")); 2513 2514 TestFmwk.assertTrue("sub325", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("70000"),mcdef).toString()).equals("9.9999999E+12")); 2515 2516 TestFmwk.assertTrue("sub326", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("700000"),mcdef).toString()).equals("9.9999993E+12")); 2517 2518 2519 // [same with fixed point arithmetic] 2520 TestFmwk.assertTrue("sub001", ((new android.icu.math.BigDecimal(2)).subtract(new android.icu.math.BigDecimal(3)).toString()).equals("-1")); 2521 TestFmwk.assertTrue("sub002", ((new android.icu.math.BigDecimal("5.75")).subtract(new android.icu.math.BigDecimal("3.3")).toString()).equals("2.45")); 2522 TestFmwk.assertTrue("sub003", ((new android.icu.math.BigDecimal("5")).subtract(new android.icu.math.BigDecimal("-3")).toString()).equals("8")); 2523 TestFmwk.assertTrue("sub004", ((new android.icu.math.BigDecimal("-5")).subtract(new android.icu.math.BigDecimal("-3")).toString()).equals("-2")); 2524 TestFmwk.assertTrue("sub005", ((new android.icu.math.BigDecimal("-7")).subtract(new android.icu.math.BigDecimal("2.5")).toString()).equals("-9.5")); 2525 TestFmwk.assertTrue("sub006", ((new android.icu.math.BigDecimal("0.7")).subtract(new android.icu.math.BigDecimal("0.3")).toString()).equals("0.4")); 2526 TestFmwk.assertTrue("sub007", ((new android.icu.math.BigDecimal("1.3")).subtract(new android.icu.math.BigDecimal("0.3")).toString()).equals("1.0")); 2527 TestFmwk.assertTrue("sub008", ((new android.icu.math.BigDecimal("1.25")).subtract(new android.icu.math.BigDecimal("1.25")).toString()).equals("0.00")); 2528 TestFmwk.assertTrue("sub009", ((new android.icu.math.BigDecimal("0.02")).subtract(new android.icu.math.BigDecimal("0.02")).toString()).equals("0.00")); 2529 2530 TestFmwk.assertTrue("sub010", ((new android.icu.math.BigDecimal("1.23456789")).subtract(new android.icu.math.BigDecimal("1.00000000")).toString()).equals("0.23456789")); 2531 2532 TestFmwk.assertTrue("sub011", ((new android.icu.math.BigDecimal("1.23456789")).subtract(new android.icu.math.BigDecimal("1.00000089")).toString()).equals("0.23456700")); 2533 2534 TestFmwk.assertTrue("sub012", ((new android.icu.math.BigDecimal("0.5555555559")).subtract(new android.icu.math.BigDecimal("0.0000000001")).toString()).equals("0.5555555558")); 2535 2536 TestFmwk.assertTrue("sub013", ((new android.icu.math.BigDecimal("0.5555555559")).subtract(new android.icu.math.BigDecimal("0.0000000005")).toString()).equals("0.5555555554")); 2537 2538 TestFmwk.assertTrue("sub014", ((new android.icu.math.BigDecimal("0.4444444444")).subtract(new android.icu.math.BigDecimal("0.1111111111")).toString()).equals("0.3333333333")); 2539 2540 TestFmwk.assertTrue("sub015", ((new android.icu.math.BigDecimal("1.0000000000")).subtract(new android.icu.math.BigDecimal("0.00000001")).toString()).equals("0.9999999900")); 2541 2542 TestFmwk.assertTrue("sub016", ((new android.icu.math.BigDecimal("0.4444444444999")).subtract(new android.icu.math.BigDecimal("0")).toString()).equals("0.4444444444999")); 2543 2544 TestFmwk.assertTrue("sub017", ((new android.icu.math.BigDecimal("0.4444444445000")).subtract(new android.icu.math.BigDecimal("0")).toString()).equals("0.4444444445000")); 2545 2546 2547 TestFmwk.assertTrue("sub018", ((new android.icu.math.BigDecimal("70")).subtract(new android.icu.math.BigDecimal("10000e+9")).toString()).equals("-9999999999930")); 2548 2549 TestFmwk.assertTrue("sub019", ((new android.icu.math.BigDecimal("700")).subtract(new android.icu.math.BigDecimal("10000e+9")).toString()).equals("-9999999999300")); 2550 2551 TestFmwk.assertTrue("sub020", ((new android.icu.math.BigDecimal("7000")).subtract(new android.icu.math.BigDecimal("10000e+9")).toString()).equals("-9999999993000")); 2552 2553 TestFmwk.assertTrue("sub021", ((new android.icu.math.BigDecimal("70000")).subtract(new android.icu.math.BigDecimal("10000e+9")).toString()).equals("-9999999930000")); 2554 2555 TestFmwk.assertTrue("sub022", ((new android.icu.math.BigDecimal("700000")).subtract(new android.icu.math.BigDecimal("10000e+9")).toString()).equals("-9999999300000")); 2556 2557 // symmetry: 2558 TestFmwk.assertTrue("sub023", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("70")).toString()).equals("9999999999930")); 2559 2560 TestFmwk.assertTrue("sub024", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("700")).toString()).equals("9999999999300")); 2561 2562 TestFmwk.assertTrue("sub025", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("7000")).toString()).equals("9999999993000")); 2563 2564 TestFmwk.assertTrue("sub026", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("70000")).toString()).equals("9999999930000")); 2565 2566 TestFmwk.assertTrue("sub027", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("700000")).toString()).equals("9999999300000")); 2567 2568 // MC 2569 TestFmwk.assertTrue("sub030", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("70000"),mcdef).toString()).equals("9.9999999E+12")); 2570 2571 TestFmwk.assertTrue("sub031", ((new android.icu.math.BigDecimal("10000e+9")).subtract(new android.icu.math.BigDecimal("70000"),mc6).toString()).equals("1.00000E+13")); 2572 2573 2574 // some of the next group are really constructor tests 2575 TestFmwk.assertTrue("sub040", ((new android.icu.math.BigDecimal("00.0")).subtract(new android.icu.math.BigDecimal("0.0")).toString()).equals("0.0")); 2576 TestFmwk.assertTrue("sub041", ((new android.icu.math.BigDecimal("00.0")).subtract(new android.icu.math.BigDecimal("0.00")).toString()).equals("0.00")); 2577 TestFmwk.assertTrue("sub042", ((new android.icu.math.BigDecimal("0.00")).subtract(new android.icu.math.BigDecimal("00.0")).toString()).equals("0.00")); 2578 TestFmwk.assertTrue("sub043", ((new android.icu.math.BigDecimal("00.0")).subtract(new android.icu.math.BigDecimal("0.00"),mcdef).toString()).equals("0")); 2579 TestFmwk.assertTrue("sub044", ((new android.icu.math.BigDecimal("0.00")).subtract(new android.icu.math.BigDecimal("00.0"),mcdef).toString()).equals("0")); 2580 TestFmwk.assertTrue("sub045", ((new android.icu.math.BigDecimal("3")).subtract(new android.icu.math.BigDecimal(".3"),mcdef).toString()).equals("2.7")); 2581 TestFmwk.assertTrue("sub046", ((new android.icu.math.BigDecimal("3.")).subtract(new android.icu.math.BigDecimal(".3"),mcdef).toString()).equals("2.7")); 2582 TestFmwk.assertTrue("sub047", ((new android.icu.math.BigDecimal("3.0")).subtract(new android.icu.math.BigDecimal(".3"),mcdef).toString()).equals("2.7")); 2583 TestFmwk.assertTrue("sub048", ((new android.icu.math.BigDecimal("3.00")).subtract(new android.icu.math.BigDecimal(".3"),mcdef).toString()).equals("2.70")); 2584 TestFmwk.assertTrue("sub049", ((new android.icu.math.BigDecimal("3")).subtract(new android.icu.math.BigDecimal("3"),mcdef).toString()).equals("0")); 2585 TestFmwk.assertTrue("sub050", ((new android.icu.math.BigDecimal("3")).subtract(new android.icu.math.BigDecimal("+3"),mcdef).toString()).equals("0")); 2586 TestFmwk.assertTrue("sub051", ((new android.icu.math.BigDecimal("3")).subtract(new android.icu.math.BigDecimal("-3"),mcdef).toString()).equals("6")); 2587 TestFmwk.assertTrue("sub052", ((new android.icu.math.BigDecimal("3")).subtract(new android.icu.math.BigDecimal(".3")).toString()).equals("2.7")); 2588 TestFmwk.assertTrue("sub053", ((new android.icu.math.BigDecimal("3.")).subtract(new android.icu.math.BigDecimal(".3")).toString()).equals("2.7")); 2589 TestFmwk.assertTrue("sub054", ((new android.icu.math.BigDecimal("3.0")).subtract(new android.icu.math.BigDecimal(".3")).toString()).equals("2.7")); 2590 TestFmwk.assertTrue("sub055", ((new android.icu.math.BigDecimal("3.00")).subtract(new android.icu.math.BigDecimal(".3")).toString()).equals("2.70")); 2591 TestFmwk.assertTrue("sub056", ((new android.icu.math.BigDecimal("3")).subtract(new android.icu.math.BigDecimal("3")).toString()).equals("0")); 2592 TestFmwk.assertTrue("sub057", ((new android.icu.math.BigDecimal("3")).subtract(new android.icu.math.BigDecimal("+3")).toString()).equals("0")); 2593 TestFmwk.assertTrue("sub058", ((new android.icu.math.BigDecimal("3")).subtract(new android.icu.math.BigDecimal("-3")).toString()).equals("6")); 2594 2595 // the above all from add; massaged and extended. Now some new ones... 2596 // [particularly important for comparisons] 2597 // NB: -1E-7 below were non-exponents pre-ANSI 2598 TestFmwk.assertTrue("sub080", ("-1E-7").equals((new android.icu.math.BigDecimal("10.23456784")).subtract(new android.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2599 TestFmwk.assertTrue("sub081", "0".equals((new android.icu.math.BigDecimal("10.23456785")).subtract(new android.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2600 TestFmwk.assertTrue("sub082", "0".equals((new android.icu.math.BigDecimal("10.23456786")).subtract(new android.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2601 TestFmwk.assertTrue("sub083", "0".equals((new android.icu.math.BigDecimal("10.23456787")).subtract(new android.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2602 TestFmwk.assertTrue("sub084", "0".equals((new android.icu.math.BigDecimal("10.23456788")).subtract(new android.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2603 TestFmwk.assertTrue("sub085", "0".equals((new android.icu.math.BigDecimal("10.23456789")).subtract(new android.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2604 TestFmwk.assertTrue("sub086", "0".equals((new android.icu.math.BigDecimal("10.23456790")).subtract(new android.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2605 TestFmwk.assertTrue("sub087", "0".equals((new android.icu.math.BigDecimal("10.23456791")).subtract(new android.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2606 TestFmwk.assertTrue("sub088", "0".equals((new android.icu.math.BigDecimal("10.23456792")).subtract(new android.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2607 TestFmwk.assertTrue("sub089", "0".equals((new android.icu.math.BigDecimal("10.23456793")).subtract(new android.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2608 TestFmwk.assertTrue("sub090", "0".equals((new android.icu.math.BigDecimal("10.23456794")).subtract(new android.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2609 TestFmwk.assertTrue("sub091", ("-1E-7").equals((new android.icu.math.BigDecimal("10.23456781")).subtract(new android.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2610 TestFmwk.assertTrue("sub092", ("-1E-7").equals((new android.icu.math.BigDecimal("10.23456782")).subtract(new android.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2611 TestFmwk.assertTrue("sub093", ("-1E-7").equals((new android.icu.math.BigDecimal("10.23456783")).subtract(new android.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2612 TestFmwk.assertTrue("sub094", ("-1E-7").equals((new android.icu.math.BigDecimal("10.23456784")).subtract(new android.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2613 TestFmwk.assertTrue("sub095", "0".equals((new android.icu.math.BigDecimal("10.23456785")).subtract(new android.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2614 TestFmwk.assertTrue("sub096", "0".equals((new android.icu.math.BigDecimal("10.23456786")).subtract(new android.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2615 TestFmwk.assertTrue("sub097", "0".equals((new android.icu.math.BigDecimal("10.23456787")).subtract(new android.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2616 TestFmwk.assertTrue("sub098", "0".equals((new android.icu.math.BigDecimal("10.23456788")).subtract(new android.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2617 TestFmwk.assertTrue("sub099", "0".equals((new android.icu.math.BigDecimal("10.23456789")).subtract(new android.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2618 TestFmwk.assertTrue("sub100", "0".equals((new android.icu.math.BigDecimal("10.23456790")).subtract(new android.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2619 TestFmwk.assertTrue("sub101", "0".equals((new android.icu.math.BigDecimal("10.23456791")).subtract(new android.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2620 TestFmwk.assertTrue("sub102", "0".equals(android.icu.math.BigDecimal.ONE.subtract(new android.icu.math.BigDecimal("0.999999999"),mcdef).toString())); 2621 TestFmwk.assertTrue("sub103", "0".equals((new android.icu.math.BigDecimal("0.999999999")).subtract(android.icu.math.BigDecimal.ONE,mcdef).toString())); 2622 2623 alhs = new android.icu.math.BigDecimal("12345678900000"); 2624 arhs = new android.icu.math.BigDecimal("9999999999999"); 2625 TestFmwk.assertTrue("sub110", (alhs.subtract(arhs, mc3).toString()).equals("2.3E+12")); 2626 TestFmwk.assertTrue("sub111", (arhs.subtract(alhs, mc3).toString()).equals("-2.3E+12")); 2627 TestFmwk.assertTrue("sub112", (alhs.subtract(arhs).toString()).equals("2345678900001")); 2628 TestFmwk.assertTrue("sub113", (arhs.subtract(alhs).toString()).equals("-2345678900001")); 2629 2630 // additional scaled arithmetic tests [0.97 problem] 2631 TestFmwk.assertTrue("sub120", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal(".1")).toString()).equals("-0.1")); 2632 TestFmwk.assertTrue("sub121", ((new android.icu.math.BigDecimal("00")).subtract(new android.icu.math.BigDecimal(".97983")).toString()).equals("-0.97983")); 2633 TestFmwk.assertTrue("sub122", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal(".9")).toString()).equals("-0.9")); 2634 TestFmwk.assertTrue("sub123", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("0.102")).toString()).equals("-0.102")); 2635 TestFmwk.assertTrue("sub124", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal(".4")).toString()).equals("-0.4")); 2636 TestFmwk.assertTrue("sub125", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal(".307")).toString()).equals("-0.307")); 2637 TestFmwk.assertTrue("sub126", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal(".43822")).toString()).equals("-0.43822")); 2638 TestFmwk.assertTrue("sub127", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal(".911")).toString()).equals("-0.911")); 2639 TestFmwk.assertTrue("sub128", ((new android.icu.math.BigDecimal(".0")).subtract(new android.icu.math.BigDecimal(".02")).toString()).equals("-0.02")); 2640 TestFmwk.assertTrue("sub129", ((new android.icu.math.BigDecimal("00")).subtract(new android.icu.math.BigDecimal(".392")).toString()).equals("-0.392")); 2641 TestFmwk.assertTrue("sub130", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal(".26")).toString()).equals("-0.26")); 2642 TestFmwk.assertTrue("sub131", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("0.51")).toString()).equals("-0.51")); 2643 TestFmwk.assertTrue("sub132", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal(".2234")).toString()).equals("-0.2234")); 2644 TestFmwk.assertTrue("sub133", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal(".2")).toString()).equals("-0.2")); 2645 TestFmwk.assertTrue("sub134", ((new android.icu.math.BigDecimal(".0")).subtract(new android.icu.math.BigDecimal(".0008")).toString()).equals("-0.0008")); 2646 // 0. on left 2647 TestFmwk.assertTrue("sub140", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-.1")).toString()).equals("0.1")); 2648 TestFmwk.assertTrue("sub141", ((new android.icu.math.BigDecimal("0.00")).subtract(new android.icu.math.BigDecimal("-.97983")).toString()).equals("0.97983")); 2649 TestFmwk.assertTrue("sub142", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-.9")).toString()).equals("0.9")); 2650 TestFmwk.assertTrue("sub143", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-0.102")).toString()).equals("0.102")); 2651 TestFmwk.assertTrue("sub144", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-.4")).toString()).equals("0.4")); 2652 TestFmwk.assertTrue("sub145", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-.307")).toString()).equals("0.307")); 2653 TestFmwk.assertTrue("sub146", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-.43822")).toString()).equals("0.43822")); 2654 TestFmwk.assertTrue("sub147", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-.911")).toString()).equals("0.911")); 2655 TestFmwk.assertTrue("sub148", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-.02")).toString()).equals("0.02")); 2656 TestFmwk.assertTrue("sub149", ((new android.icu.math.BigDecimal("0.00")).subtract(new android.icu.math.BigDecimal("-.392")).toString()).equals("0.392")); 2657 TestFmwk.assertTrue("sub150", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-.26")).toString()).equals("0.26")); 2658 TestFmwk.assertTrue("sub151", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-0.51")).toString()).equals("0.51")); 2659 TestFmwk.assertTrue("sub152", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-.2234")).toString()).equals("0.2234")); 2660 TestFmwk.assertTrue("sub153", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-.2")).toString()).equals("0.2")); 2661 TestFmwk.assertTrue("sub154", ((new android.icu.math.BigDecimal("0.0")).subtract(new android.icu.math.BigDecimal("-.0008")).toString()).equals("0.0008")); 2662 // negatives of same 2663 TestFmwk.assertTrue("sub160", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("-.1")).toString()).equals("0.1")); 2664 TestFmwk.assertTrue("sub161", ((new android.icu.math.BigDecimal("00")).subtract(new android.icu.math.BigDecimal("-.97983")).toString()).equals("0.97983")); 2665 TestFmwk.assertTrue("sub162", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("-.9")).toString()).equals("0.9")); 2666 TestFmwk.assertTrue("sub163", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("-0.102")).toString()).equals("0.102")); 2667 TestFmwk.assertTrue("sub164", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("-.4")).toString()).equals("0.4")); 2668 TestFmwk.assertTrue("sub165", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("-.307")).toString()).equals("0.307")); 2669 TestFmwk.assertTrue("sub166", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("-.43822")).toString()).equals("0.43822")); 2670 TestFmwk.assertTrue("sub167", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("-.911")).toString()).equals("0.911")); 2671 TestFmwk.assertTrue("sub168", ((new android.icu.math.BigDecimal(".0")).subtract(new android.icu.math.BigDecimal("-.02")).toString()).equals("0.02")); 2672 TestFmwk.assertTrue("sub169", ((new android.icu.math.BigDecimal("00")).subtract(new android.icu.math.BigDecimal("-.392")).toString()).equals("0.392")); 2673 TestFmwk.assertTrue("sub170", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("-.26")).toString()).equals("0.26")); 2674 TestFmwk.assertTrue("sub171", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("-0.51")).toString()).equals("0.51")); 2675 TestFmwk.assertTrue("sub172", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("-.2234")).toString()).equals("0.2234")); 2676 TestFmwk.assertTrue("sub173", ((new android.icu.math.BigDecimal("0")).subtract(new android.icu.math.BigDecimal("-.2")).toString()).equals("0.2")); 2677 TestFmwk.assertTrue("sub174", ((new android.icu.math.BigDecimal(".0")).subtract(new android.icu.math.BigDecimal("-.0008")).toString()).equals("0.0008")); 2678 2679 // more fixed, LHS swaps [really same as testcases under add] 2680 TestFmwk.assertTrue("sub180", ((new android.icu.math.BigDecimal("-56267E-10")).subtract(zero).toString()).equals("-0.0000056267")); 2681 TestFmwk.assertTrue("sub181", ((new android.icu.math.BigDecimal("-56267E-5")).subtract(zero).toString()).equals("-0.56267")); 2682 TestFmwk.assertTrue("sub182", ((new android.icu.math.BigDecimal("-56267E-2")).subtract(zero).toString()).equals("-562.67")); 2683 TestFmwk.assertTrue("sub183", ((new android.icu.math.BigDecimal("-56267E-1")).subtract(zero).toString()).equals("-5626.7")); 2684 TestFmwk.assertTrue("sub185", ((new android.icu.math.BigDecimal("-56267E-0")).subtract(zero).toString()).equals("-56267")); 2685 2686 try { 2687 ten.subtract((android.icu.math.BigDecimal) null); 2688 flag = false; 2689 } catch (java.lang.NullPointerException $83) { 2690 flag = true; 2691 }/* checknull */ 2692 TestFmwk.assertTrue("sub200", flag); 2693 try { 2694 ten.subtract(ten, (android.icu.math.MathContext) null); 2695 flag = false; 2696 } catch (java.lang.NullPointerException $84) { 2697 flag = true; 2698 }/* checknull2 */ 2699 TestFmwk.assertTrue("sub201", flag); 2700 2701 try { 2702 android.icu.math.BigDecimal.ONE.subtract(tenlong, mcld); 2703 flag = false; 2704 } catch (java.lang.ArithmeticException $85) { 2705 ae = $85; 2706 flag = (ae.getMessage()).equals("Too many digits:" + " " 2707 + tenlong.toString()); 2708 }/* checkdigits */ 2709 TestFmwk.assertTrue("sub202", flag); 2710 try { 2711 tenlong.subtract(android.icu.math.BigDecimal.ONE, mcld); 2712 flag = false; 2713 } catch (java.lang.ArithmeticException $86) { 2714 ae = $86; 2715 flag = (ae.getMessage()).equals("Too many digits:" + " " 2716 + tenlong.toString()); 2717 }/* checkdigits */ 2718 TestFmwk.assertTrue("sub203", flag); 2719 } 2720 2721 /* ----------------------------------------------------------------- */ 2722 2723 /* ----------------------------------------------------------------- */ 2724 /* Other methods */ 2725 /* ----------------------------------------------------------------- */ 2726 2727 /** Test the <code>BigDecimal.byteValue()</code> method. */ 2728 2729 @Test 2730 public void diagbyteValue() { 2731 boolean flag = false; 2732 java.lang.String v = null; 2733 java.lang.ArithmeticException ae = null; 2734 java.lang.String badstrings[]; 2735 int i = 0; 2736 java.lang.String norm = null; 2737 2738 TestFmwk.assertTrue("byv001", ((((byte)-128)))==((new android.icu.math.BigDecimal("-128")).byteValue())); 2739 TestFmwk.assertTrue("byv002", ((0))==((new android.icu.math.BigDecimal("0")).byteValue())); 2740 TestFmwk.assertTrue("byv003", ((1))==((new android.icu.math.BigDecimal("1")).byteValue())); 2741 TestFmwk.assertTrue("byv004", ((99))==((new android.icu.math.BigDecimal("99")).byteValue())); 2742 TestFmwk.assertTrue("byv005", ((127))==((new android.icu.math.BigDecimal("127")).byteValue())); 2743 TestFmwk.assertTrue("byv006", ((-128))==((new android.icu.math.BigDecimal("128")).byteValue())); 2744 TestFmwk.assertTrue("byv007", ((-127))==((new android.icu.math.BigDecimal("129")).byteValue())); 2745 TestFmwk.assertTrue("byv008", ((127))==((new android.icu.math.BigDecimal("-129")).byteValue())); 2746 TestFmwk.assertTrue("byv009", ((126))==((new android.icu.math.BigDecimal("-130")).byteValue())); 2747 TestFmwk.assertTrue("byv010", ((bmax))==((new android.icu.math.BigDecimal(bmax)).byteValue())); 2748 TestFmwk.assertTrue("byv011", ((bmin))==((new android.icu.math.BigDecimal(bmin)).byteValue())); 2749 TestFmwk.assertTrue("byv012", ((bneg))==((new android.icu.math.BigDecimal(bneg)).byteValue())); 2750 TestFmwk.assertTrue("byv013", ((bzer))==((new android.icu.math.BigDecimal(bzer)).byteValue())); 2751 TestFmwk.assertTrue("byv014", ((bpos))==((new android.icu.math.BigDecimal(bpos)).byteValue())); 2752 TestFmwk.assertTrue("byv015", ((bmin))==((new android.icu.math.BigDecimal(bmax+1)).byteValue())); 2753 TestFmwk.assertTrue("byv016", ((bmax))==((new android.icu.math.BigDecimal(bmin-1)).byteValue())); 2754 2755 TestFmwk.assertTrue("byv021", ((((byte)-128)))==((new android.icu.math.BigDecimal("-128")).byteValueExact())); 2756 TestFmwk.assertTrue("byv022", ((0))==((new android.icu.math.BigDecimal("0")).byteValueExact())); 2757 TestFmwk.assertTrue("byv023", ((1))==((new android.icu.math.BigDecimal("1")).byteValueExact())); 2758 TestFmwk.assertTrue("byv024", ((99))==((new android.icu.math.BigDecimal("99")).byteValueExact())); 2759 TestFmwk.assertTrue("byv025", ((127))==((new android.icu.math.BigDecimal("127")).byteValueExact())); 2760 TestFmwk.assertTrue("byv026", ((bmax))==((new android.icu.math.BigDecimal(bmax)).byteValueExact())); 2761 TestFmwk.assertTrue("byv027", ((bmin))==((new android.icu.math.BigDecimal(bmin)).byteValueExact())); 2762 TestFmwk.assertTrue("byv028", ((bneg))==((new android.icu.math.BigDecimal(bneg)).byteValueExact())); 2763 TestFmwk.assertTrue("byv029", ((bzer))==((new android.icu.math.BigDecimal(bzer)).byteValueExact())); 2764 TestFmwk.assertTrue("byv030", ((bpos))==((new android.icu.math.BigDecimal(bpos)).byteValueExact())); 2765 try { 2766 v = "-129"; 2767 (new android.icu.math.BigDecimal(v)).byteValueExact(); 2768 flag = false; 2769 } catch (java.lang.ArithmeticException $87) { 2770 ae = $87; 2771 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 2772 } 2773 TestFmwk.assertTrue("byv100", flag); 2774 try { 2775 v = "128"; 2776 (new android.icu.math.BigDecimal(v)).byteValueExact(); 2777 flag = false; 2778 } catch (java.lang.ArithmeticException $88) { 2779 ae = $88; 2780 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 2781 } 2782 TestFmwk.assertTrue("byv101", flag); 2783 try { 2784 v = "1.5"; 2785 (new android.icu.math.BigDecimal(v)).byteValueExact(); 2786 flag = false; 2787 } catch (java.lang.ArithmeticException $89) { 2788 ae = $89; 2789 flag = (ae.getMessage()).equals("Decimal part non-zero:" + " " + v); 2790 } 2791 TestFmwk.assertTrue("byv102", flag); 2792 2793 badstrings = new java.lang.String[] { 2794 "1234", 2795 (new android.icu.math.BigDecimal(bmax)).add(one).toString(), 2796 (new android.icu.math.BigDecimal(bmin)).subtract(one) 2797 .toString(), 2798 "170", 2799 "270", 2800 "370", 2801 "470", 2802 "570", 2803 "670", 2804 "770", 2805 "870", 2806 "970", 2807 "-170", 2808 "-270", 2809 "-370", 2810 "-470", 2811 "-570", 2812 "-670", 2813 "-770", 2814 "-870", 2815 "-970", 2816 (new android.icu.math.BigDecimal(bmin)).multiply(two) 2817 .toString(), 2818 (new android.icu.math.BigDecimal(bmax)).multiply(two) 2819 .toString(), 2820 (new android.icu.math.BigDecimal(bmin)).multiply(ten) 2821 .toString(), 2822 (new android.icu.math.BigDecimal(bmax)).multiply(ten) 2823 .toString(), "-1234" }; // 220 2824 // 221 2825 // 222 2826 // 223 2827 // 224 2828 // 225 2829 // 226 2830 // 227 2831 // 228 2832 // 229 2833 // 230 2834 // 231 2835 // 232 2836 // 233 2837 // 234 2838 // 235 2839 // 236 2840 // 237 2841 // 238 2842 // 239 2843 // 240 2844 // 241 2845 // 242 2846 // 243 2847 // 244 2848 // 245 2849 { 2850 int $90 = badstrings.length; 2851 i = 0; 2852 for (; $90 > 0; $90--, i++) { 2853 try { 2854 v = badstrings[i]; 2855 (new android.icu.math.BigDecimal(v)).byteValueExact(); 2856 flag = false; 2857 } catch (java.lang.ArithmeticException $91) { 2858 ae = $91; 2859 norm = (new android.icu.math.BigDecimal(v)).toString(); 2860 flag = (ae.getMessage()).equals("Conversion overflow:" 2861 + " " + norm); 2862 } 2863 TestFmwk.assertTrue("byv" + (220 + i), flag); 2864 } 2865 }/* i */ 2866 } 2867 2868 /* ----------------------------------------------------------------- */ 2869 2870 /** 2871 * Test the {@link android.icu.math.BigDecimal#compareTo(java.lang.Object)} 2872 * method. 2873 */ 2874 2875 @Test 2876 public void diagcomparetoObj() { 2877 // boolean flag = false; 2878 // android.icu.math.BigDecimal d; 2879 // android.icu.math.BigDecimal long1; 2880 // android.icu.math.BigDecimal long2; 2881 // 2882 // d = new android.icu.math.BigDecimal(17); 2883 // (new Test("cto001")).ok = (d 2884 // .compareTo((java.lang.Object) (new android.icu.math.BigDecimal( 2885 // 66)))) == (-1); 2886 // (new Test("cto002")).ok = (d 2887 // .compareTo((java.lang.Object) ((new android.icu.math.BigDecimal( 2888 // 10)).add(new android.icu.math.BigDecimal(7))))) == 0; 2889 // (new Test("cto003")).ok = (d 2890 // .compareTo((java.lang.Object) (new android.icu.math.BigDecimal( 2891 // 10)))) == 1; 2892 // long1 = new android.icu.math.BigDecimal("12345678903"); 2893 // long2 = new android.icu.math.BigDecimal("12345678900"); 2894 // TestFmwk.assertTrue("cto004", (long1.compareTo((java.lang.Object) long2)) == 1); 2895 // TestFmwk.assertTrue("cto005", (long2.compareTo((java.lang.Object) long1)) == (-1)); 2896 // TestFmwk.assertTrue("cto006", (long2.compareTo((java.lang.Object) long2)) == 0); 2897 // try { 2898 // d.compareTo((java.lang.Object) null); 2899 // flag = false; 2900 // } catch (java.lang.NullPointerException $92) { 2901 // flag = true; // should get here 2902 // } 2903 // TestFmwk.assertTrue("cto101", flag); 2904 // try { 2905 // d.compareTo((java.lang.Object) "foo"); 2906 // flag = false; 2907 // } catch (java.lang.ClassCastException $93) { 2908 // flag = true; // should get here 2909 // } 2910 // TestFmwk.assertTrue("cto102", flag); 2911 // summary("compareTo(Obj)"); 2912 } 2913 2914 /* ----------------------------------------------------------------- */ 2915 2916 /** Test the {@link android.icu.math.BigDecimal#doubleValue} method. */ 2917 2918 @Test 2919 public void diagdoublevalue() { 2920 java.lang.String val; 2921 // 1999.03.07 Infinities no longer errors 2922 val = "-1"; 2923 TestFmwk.assertTrue("dov001", ((new android.icu.math.BigDecimal(val)).doubleValue()) == ((new java.lang.Double(val)).doubleValue())); 2924 val = "-0.1"; 2925 TestFmwk.assertTrue("dov002", ((new android.icu.math.BigDecimal(val)).doubleValue()) == ((new java.lang.Double(val)).doubleValue())); 2926 val = "0"; 2927 TestFmwk.assertTrue("dov003", ((new android.icu.math.BigDecimal(val)).doubleValue()) == ((new java.lang.Double(val)).doubleValue())); 2928 val = "0.1"; 2929 TestFmwk.assertTrue("dov004", ((new android.icu.math.BigDecimal(val)).doubleValue()) == ((new java.lang.Double(val)).doubleValue())); 2930 val = "1"; 2931 TestFmwk.assertTrue("dov005", ((new android.icu.math.BigDecimal(val)).doubleValue()) == ((new java.lang.Double(val)).doubleValue())); 2932 val = "1e1000"; 2933 TestFmwk.assertTrue("dov006", ((new android.icu.math.BigDecimal(val)).doubleValue()) == java.lang.Double.POSITIVE_INFINITY); 2934 val = "-1e1000"; 2935 TestFmwk.assertTrue("dov007", ((new android.icu.math.BigDecimal(val)).doubleValue()) == java.lang.Double.NEGATIVE_INFINITY); 2936 } 2937 2938 /* ----------------------------------------------------------------- */ 2939 2940 /** Test the {@link android.icu.math.BigDecimal#equals} method. */ 2941 2942 @Test 2943 public void diagequals() { 2944 android.icu.math.BigDecimal d; 2945 d = new android.icu.math.BigDecimal(17); 2946 TestFmwk.assertTrue("equ001", (!(d.equals((java.lang.Object) null)))); 2947 TestFmwk.assertTrue("equ002", (!(d.equals("foo")))); 2948 TestFmwk.assertTrue("equ003", (!(d.equals((new android.icu.math.BigDecimal(66)))))); 2949 TestFmwk.assertTrue("equ004", d.equals(d)); 2950 TestFmwk.assertTrue("equ005", d.equals(((new android.icu.math.BigDecimal(10)).add(new android.icu.math.BigDecimal(7))))); 2951 } 2952 2953 /* ----------------------------------------------------------------- */ 2954 2955 /** Test the {@link android.icu.math.BigDecimal#floatValue} method. */ 2956 2957 @Test 2958 public void diagfloatvalue() { 2959 java.lang.String val; 2960 // 1999.03.07 Infinities no longer errors 2961 val = "-1"; 2962 TestFmwk.assertTrue("flv001", ((new android.icu.math.BigDecimal(val)).floatValue()) == ((new java.lang.Float(val)).floatValue())); 2963 val = "-0.1"; 2964 TestFmwk.assertTrue("flv002", ((new android.icu.math.BigDecimal(val)).floatValue()) == ((new java.lang.Float(val)).floatValue())); 2965 val = "0"; 2966 TestFmwk.assertTrue("flv003", ((new android.icu.math.BigDecimal(val)).floatValue()) == ((new java.lang.Float(val)).floatValue())); 2967 val = "0.1"; 2968 TestFmwk.assertTrue("flv004", ((new android.icu.math.BigDecimal(val)).floatValue()) == ((new java.lang.Float(val)).floatValue())); 2969 val = "1"; 2970 TestFmwk.assertTrue("flv005", ((new android.icu.math.BigDecimal(val)).floatValue()) == ((new java.lang.Float(val)).floatValue())); 2971 val = "1e200"; 2972 TestFmwk.assertTrue("flv006", ((new android.icu.math.BigDecimal(val)).floatValue()) == java.lang.Float.POSITIVE_INFINITY); 2973 val = "-1e200"; 2974 TestFmwk.assertTrue("flv007", ((new android.icu.math.BigDecimal(val)).floatValue()) == java.lang.Float.NEGATIVE_INFINITY); 2975 val = "1e1000"; 2976 TestFmwk.assertTrue("flv008", ((new android.icu.math.BigDecimal(val)).floatValue()) == java.lang.Float.POSITIVE_INFINITY); 2977 val = "-1e1000"; 2978 TestFmwk.assertTrue("flv009", ((new android.icu.math.BigDecimal(val)).floatValue()) == java.lang.Float.NEGATIVE_INFINITY); 2979 } 2980 2981 /* ----------------------------------------------------------------- */ 2982 2983 /** Test the {@link android.icu.math.BigDecimal#format} method. */ 2984 2985 @Test 2986 public void diagformat() { 2987 boolean flag = false; 2988 int eng; 2989 int sci; 2990 android.icu.math.BigDecimal d04; 2991 android.icu.math.BigDecimal d05; 2992 android.icu.math.BigDecimal d06; 2993 android.icu.math.BigDecimal d15; 2994 java.lang.IllegalArgumentException iae = null; 2995 android.icu.math.BigDecimal d050; 2996 android.icu.math.BigDecimal d150; 2997 android.icu.math.BigDecimal m050; 2998 android.icu.math.BigDecimal m150; 2999 android.icu.math.BigDecimal d051; 3000 android.icu.math.BigDecimal d151; 3001 android.icu.math.BigDecimal d000; 3002 android.icu.math.BigDecimal d500; 3003 java.lang.ArithmeticException ae = null; 3004 // 1999.02.09 now only two signatures for format(), so some tests below 3005 // may now be redundant 3006 3007 TestFmwk.assertTrue("for001", ((new android.icu.math.BigDecimal("12.3")).format(-1,-1)).equals("12.3")); 3008 TestFmwk.assertTrue("for002", ((new android.icu.math.BigDecimal("-12.73")).format(-1,-1)).equals("-12.73")); 3009 TestFmwk.assertTrue("for003", ((new android.icu.math.BigDecimal("0.000")).format(-1,-1)).equals("0.000")); 3010 TestFmwk.assertTrue("for004", ((new android.icu.math.BigDecimal("3E+3")).format(-1,-1)).equals("3000")); 3011 TestFmwk.assertTrue("for005", ((new android.icu.math.BigDecimal("3")).format(4,-1)).equals(" 3")); 3012 TestFmwk.assertTrue("for006", ((new android.icu.math.BigDecimal("1.73")).format(4,0)).equals(" 2")); 3013 TestFmwk.assertTrue("for007", ((new android.icu.math.BigDecimal("1.73")).format(4,1)).equals(" 1.7")); 3014 TestFmwk.assertTrue("for008", ((new android.icu.math.BigDecimal("1.75")).format(4,1)).equals(" 1.8")); 3015 TestFmwk.assertTrue("for009", ((new android.icu.math.BigDecimal("0.5")).format(4,1)).equals(" 0.5")); 3016 TestFmwk.assertTrue("for010", ((new android.icu.math.BigDecimal("0.05")).format(4,1)).equals(" 0.1")); 3017 TestFmwk.assertTrue("for011", ((new android.icu.math.BigDecimal("0.04")).format(4,1)).equals(" 0.0")); 3018 TestFmwk.assertTrue("for012", ((new android.icu.math.BigDecimal("0")).format(4,0)).equals(" 0")); 3019 TestFmwk.assertTrue("for013", ((new android.icu.math.BigDecimal("0")).format(4,1)).equals(" 0.0")); 3020 TestFmwk.assertTrue("for014", ((new android.icu.math.BigDecimal("0")).format(4,2)).equals(" 0.00")); 3021 TestFmwk.assertTrue("for015", ((new android.icu.math.BigDecimal("0")).format(4,3)).equals(" 0.000")); 3022 TestFmwk.assertTrue("for016", ((new android.icu.math.BigDecimal("0")).format(4,4)).equals(" 0.0000")); 3023 TestFmwk.assertTrue("for017", ((new android.icu.math.BigDecimal("0.005")).format(4,0)).equals(" 0")); 3024 TestFmwk.assertTrue("for018", ((new android.icu.math.BigDecimal("0.005")).format(4,1)).equals(" 0.0")); 3025 TestFmwk.assertTrue("for019", ((new android.icu.math.BigDecimal("0.005")).format(4,2)).equals(" 0.01")); 3026 TestFmwk.assertTrue("for020", ((new android.icu.math.BigDecimal("0.004")).format(4,2)).equals(" 0.00")); 3027 TestFmwk.assertTrue("for021", ((new android.icu.math.BigDecimal("0.005")).format(4,3)).equals(" 0.005")); 3028 TestFmwk.assertTrue("for022", ((new android.icu.math.BigDecimal("0.005")).format(4,4)).equals(" 0.0050")); 3029 3030 TestFmwk.assertTrue("for023", ((new android.icu.math.BigDecimal("1.73")).format(4,2)).equals(" 1.73")); 3031 TestFmwk.assertTrue("for024", ((new android.icu.math.BigDecimal("1.73")).format(4,3)).equals(" 1.730")); 3032 TestFmwk.assertTrue("for025", ((new android.icu.math.BigDecimal("-.76")).format(4,1)).equals(" -0.8")); 3033 TestFmwk.assertTrue("for026", ((new android.icu.math.BigDecimal("-12.73")).format(-1,4)).equals("-12.7300")); 3034 3035 TestFmwk.assertTrue("for027", ((new android.icu.math.BigDecimal("3.03")).format(4,-1)).equals(" 3.03")); 3036 TestFmwk.assertTrue("for028", ((new android.icu.math.BigDecimal("3.03")).format(4,1)).equals(" 3.0")); 3037 TestFmwk.assertTrue("for029", ((new android.icu.math.BigDecimal("3.03")).format(4,-1,3,-1,-1,-1)).equals(" 3.03 ")); 3038 TestFmwk.assertTrue("for030", ((new android.icu.math.BigDecimal("3.03")).format(-1,-1,3,-1,-1,-1)).equals("3.03 ")); 3039 TestFmwk.assertTrue("for031", ((new android.icu.math.BigDecimal("12345.73")).format(-1,-1,-1,4,-1,-1)).equals("1.234573E+4")); 3040 TestFmwk.assertTrue("for032", ((new android.icu.math.BigDecimal("12345.73")).format(-1,-1,-1,5,-1,-1)).equals("12345.73")); 3041 TestFmwk.assertTrue("for033", ((new android.icu.math.BigDecimal("12345.73")).format(-1,-1,-1,6,-1,-1)).equals("12345.73")); 3042 3043 TestFmwk.assertTrue("for034", ((new android.icu.math.BigDecimal("12345.73")).format(-1,8,-1,3,-1,-1)).equals("1.23457300E+4")); 3044 TestFmwk.assertTrue("for035", ((new android.icu.math.BigDecimal("12345.73")).format(-1,7,-1,3,-1,-1)).equals("1.2345730E+4")); 3045 TestFmwk.assertTrue("for036", ((new android.icu.math.BigDecimal("12345.73")).format(-1,6,-1,3,-1,-1)).equals("1.234573E+4")); 3046 TestFmwk.assertTrue("for037", ((new android.icu.math.BigDecimal("12345.73")).format(-1,5,-1,3,-1,-1)).equals("1.23457E+4")); 3047 TestFmwk.assertTrue("for038", ((new android.icu.math.BigDecimal("12345.73")).format(-1,4,-1,3,-1,-1)).equals("1.2346E+4")); 3048 TestFmwk.assertTrue("for039", ((new android.icu.math.BigDecimal("12345.73")).format(-1,3,-1,3,-1,-1)).equals("1.235E+4")); 3049 TestFmwk.assertTrue("for040", ((new android.icu.math.BigDecimal("12345.73")).format(-1,2,-1,3,-1,-1)).equals("1.23E+4")); 3050 TestFmwk.assertTrue("for041", ((new android.icu.math.BigDecimal("12345.73")).format(-1,1,-1,3,-1,-1)).equals("1.2E+4")); 3051 TestFmwk.assertTrue("for042", ((new android.icu.math.BigDecimal("12345.73")).format(-1,0,-1,3,-1,-1)).equals("1E+4")); 3052 3053 TestFmwk.assertTrue("for043", ((new android.icu.math.BigDecimal("99999.99")).format(-1,6,-1,3,-1,-1)).equals("9.999999E+4")); 3054 TestFmwk.assertTrue("for044", ((new android.icu.math.BigDecimal("99999.99")).format(-1,5,-1,3,-1,-1)).equals("1.00000E+5")); 3055 TestFmwk.assertTrue("for045", ((new android.icu.math.BigDecimal("99999.99")).format(-1,2,-1,3,-1,-1)).equals("1.00E+5")); 3056 TestFmwk.assertTrue("for046", ((new android.icu.math.BigDecimal("99999.99")).format(-1,0,-1,3,-1,-1)).equals("1E+5")); 3057 TestFmwk.assertTrue("for047", ((new android.icu.math.BigDecimal("99999.99")).format(3,0,-1,3,-1,-1)).equals(" 1E+5")); 3058 3059 TestFmwk.assertTrue("for048", ((new android.icu.math.BigDecimal("12345.73")).format(-1,-1,2,2,-1,-1)).equals("1.234573E+04")); 3060 TestFmwk.assertTrue("for049", ((new android.icu.math.BigDecimal("12345.73")).format(-1,3,-1,0,-1,-1)).equals("1.235E+4")); 3061 TestFmwk.assertTrue("for050", ((new android.icu.math.BigDecimal("1.234573")).format(-1,3,-1,0,-1,-1)).equals("1.235")); 3062 TestFmwk.assertTrue("for051", ((new android.icu.math.BigDecimal("123.45")).format(-1,3,2,0,-1,-1)).equals("1.235E+02")); 3063 3064 TestFmwk.assertTrue("for052", ((new android.icu.math.BigDecimal("0.444")).format(-1,0)).equals("0")); 3065 TestFmwk.assertTrue("for053", ((new android.icu.math.BigDecimal("-0.444")).format(-1,0)).equals("0")); 3066 TestFmwk.assertTrue("for054", ((new android.icu.math.BigDecimal("0.4")).format(-1,0)).equals("0")); 3067 TestFmwk.assertTrue("for055", ((new android.icu.math.BigDecimal("-0.4")).format(-1,0)).equals("0")); 3068 3069 eng = android.icu.math.MathContext.ENGINEERING; 3070 sci = android.icu.math.MathContext.SCIENTIFIC; 3071 TestFmwk.assertTrue("for060", ((new android.icu.math.BigDecimal("1234.5")).format(-1,3,2,0,eng,-1)).equals("1.235E+03")); 3072 TestFmwk.assertTrue("for061", ((new android.icu.math.BigDecimal("12345")).format(-1,3,3,0,eng,-1)).equals("12.345E+003")); 3073 TestFmwk.assertTrue("for062", ((new android.icu.math.BigDecimal("12345")).format(-1,3,3,0,sci,-1)).equals("1.235E+004")); 3074 TestFmwk.assertTrue("for063", ((new android.icu.math.BigDecimal("1234.5")).format(4,3,2,0,eng,-1)).equals(" 1.235E+03")); 3075 TestFmwk.assertTrue("for064", ((new android.icu.math.BigDecimal("12345")).format(5,3,3,0,eng,-1)).equals(" 12.345E+003")); 3076 TestFmwk.assertTrue("for065", ((new android.icu.math.BigDecimal("12345")).format(6,3,3,0,sci,-1)).equals(" 1.235E+004")); 3077 3078 TestFmwk.assertTrue("for066", ((new android.icu.math.BigDecimal("1.2345")).format(-1,3,2,0,-1,-1)).equals("1.235 ")); 3079 TestFmwk.assertTrue("for067", ((new android.icu.math.BigDecimal("12345.73")).format(-1,-1,3,6,-1,-1)).equals("12345.73 ")); 3080 TestFmwk.assertTrue("for068", ((new android.icu.math.BigDecimal("12345e+5")).format(-1,0)).equals("1234500000")); 3081 TestFmwk.assertTrue("for069", ((new android.icu.math.BigDecimal("12345e+5")).format(-1,1)).equals("1234500000.0")); 3082 TestFmwk.assertTrue("for070", ((new android.icu.math.BigDecimal("12345e+5")).format(-1,2)).equals("1234500000.00")); 3083 TestFmwk.assertTrue("for071", ((new android.icu.math.BigDecimal("12345e+5")).format(-1,3)).equals("1234500000.000")); 3084 TestFmwk.assertTrue("for072", ((new android.icu.math.BigDecimal("12345e+5")).format(-1,4)).equals("1234500000.0000")); 3085 3086 // some from ANSI Dallas [Nov 1998] 3087 TestFmwk.assertTrue("for073", ((new android.icu.math.BigDecimal("99.999")).format(-1,2,-1,2,-1,-1)).equals("100.00")); 3088 TestFmwk.assertTrue("for074", ((new android.icu.math.BigDecimal("0.99999")).format(-1,4,2,2,-1,-1)).equals("1.0000 ")); 3089 3090 // try some rounding modes [default ROUND_HALF_UP widely tested above] 3091 // the first few also tests that defaults are accepted for the others 3092 d04 = new android.icu.math.BigDecimal("0.04"); 3093 d05 = new android.icu.math.BigDecimal("0.05"); 3094 d06 = new android.icu.math.BigDecimal("0.06"); 3095 d15 = new android.icu.math.BigDecimal("0.15"); 3096 TestFmwk.assertTrue("for080", (d05.format(-1, 1)).equals("0.1")); 3097 TestFmwk.assertTrue("for081", (d05.format(-1, 1, -1, -1, -1, android.icu.math.MathContext.ROUND_HALF_UP)).equals("0.1")); 3098 TestFmwk.assertTrue("for082", (d05.format(-1, 1, -1, -1, -1, -1)).equals("0.1")); 3099 TestFmwk.assertTrue("for083", (d05.format(-1, -1, -1, -1, -1, -1)).equals("0.05")); 3100 TestFmwk.assertTrue("for084", (d05.format(-1, -1)).equals("0.05")); 3101 try { 3102 d05.format(-1, -1, -1, -1, -1, 30); // bad mode 3103 flag = false; // shouldn't get here 3104 } catch (java.lang.IllegalArgumentException $94) { 3105 iae = $94; 3106 flag = (iae.getMessage()).equals("Bad argument 6 to format: 30"); 3107 } 3108 TestFmwk.assertTrue("for085", flag); 3109 3110 TestFmwk.assertTrue("for090", (d04.format(-1,1)).equals("0.0")); 3111 TestFmwk.assertTrue("for091", (d06.format(-1,1)).equals("0.1")); 3112 TestFmwk.assertTrue("for092", (d04.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_DOWN)).equals("0.0")); 3113 TestFmwk.assertTrue("for093", (d05.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_DOWN)).equals("0.0")); 3114 TestFmwk.assertTrue("for094", (d06.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_DOWN)).equals("0.1")); 3115 3116 TestFmwk.assertTrue("for095", (d04.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.0")); 3117 TestFmwk.assertTrue("for096", (d05.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.0")); 3118 TestFmwk.assertTrue("for097", (d06.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.1")); 3119 TestFmwk.assertTrue("for098", (d15.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.2")); 3120 d050 = new android.icu.math.BigDecimal("0.050"); 3121 d150 = new android.icu.math.BigDecimal("0.150"); 3122 TestFmwk.assertTrue("for099", (d050.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.0")); 3123 TestFmwk.assertTrue("for100", (d150.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.2")); 3124 m050 = new android.icu.math.BigDecimal("-0.050"); 3125 m150 = new android.icu.math.BigDecimal("-0.150"); 3126 TestFmwk.assertTrue("for101", (m050.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.0")); 3127 TestFmwk.assertTrue("for102", (m150.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_EVEN)).equals("-0.2")); 3128 d051 = new android.icu.math.BigDecimal("0.051"); 3129 d151 = new android.icu.math.BigDecimal("0.151"); 3130 TestFmwk.assertTrue("for103", (d051.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.1")); 3131 TestFmwk.assertTrue("for104", (d151.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.2")); 3132 3133 TestFmwk.assertTrue("for105", (m050.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_CEILING)).equals("0.0")); 3134 TestFmwk.assertTrue("for106", (m150.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_CEILING)).equals("-0.1")); 3135 TestFmwk.assertTrue("for107", (d050.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_CEILING)).equals("0.1")); 3136 TestFmwk.assertTrue("for108", (d150.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_CEILING)).equals("0.2")); 3137 3138 TestFmwk.assertTrue("for109", (m050.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_FLOOR)).equals("-0.1")); 3139 TestFmwk.assertTrue("for110", (m150.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_FLOOR)).equals("-0.2")); 3140 TestFmwk.assertTrue("for111", (d050.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_FLOOR)).equals("0.0")); 3141 TestFmwk.assertTrue("for112", (d150.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_FLOOR)).equals("0.1")); 3142 3143 TestFmwk.assertTrue("for113", (m050.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_UP)).equals("-0.1")); 3144 TestFmwk.assertTrue("for114", (m150.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_UP)).equals("-0.2")); 3145 TestFmwk.assertTrue("for115", (d050.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_UP)).equals("0.1")); 3146 TestFmwk.assertTrue("for116", (d150.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_UP)).equals("0.2")); 3147 3148 TestFmwk.assertTrue("for117", (m050.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_DOWN)).equals("0.0")); 3149 TestFmwk.assertTrue("for118", (m150.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_DOWN)).equals("-0.1")); 3150 TestFmwk.assertTrue("for119", (d050.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_DOWN)).equals("0.0")); 3151 TestFmwk.assertTrue("for120", (d150.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_DOWN)).equals("0.1")); 3152 3153 d000 = new android.icu.math.BigDecimal("0.000"); 3154 d500 = new android.icu.math.BigDecimal("0.500"); 3155 TestFmwk.assertTrue("for121", (d000.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.0")); 3156 TestFmwk.assertTrue("for122", (d000.format(-1,2,-1,-1,-1,android.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.00")); 3157 TestFmwk.assertTrue("for123", (d000.format(-1,3,-1,-1,-1,android.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.000")); 3158 try { // this should trap.. 3159 d050.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_UNNECESSARY); 3160 flag = false; 3161 } catch (java.lang.ArithmeticException $95) { 3162 ae = $95; 3163 flag = (ae.getMessage()).equals("Rounding necessary"); 3164 } 3165 TestFmwk.assertTrue("for124", flag); 3166 TestFmwk.assertTrue("for125", (d050.format(-1,2,-1,-1,-1,android.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.05")); 3167 TestFmwk.assertTrue("for126", (d050.format(-1,3,-1,-1,-1,android.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.050")); 3168 TestFmwk.assertTrue("for127", (d500.format(-1,1,-1,-1,-1,android.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.5")); 3169 TestFmwk.assertTrue("for128", (d500.format(-1,2,-1,-1,-1,android.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.50")); 3170 TestFmwk.assertTrue("for129", (d500.format(-1,3,-1,-1,-1,android.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.500")); 3171 3172 // bad negs -- 3173 try { 3174 d050.format(-2, -1, -1, -1, -1, -1); 3175 flag = false; 3176 } catch (java.lang.IllegalArgumentException $96) { 3177 flag = true; 3178 } 3179 TestFmwk.assertTrue("for131", flag); 3180 try { 3181 d050.format(-1, -2, -1, -1, -1, -1); 3182 flag = false; 3183 } catch (java.lang.IllegalArgumentException $97) { 3184 flag = true; 3185 } 3186 TestFmwk.assertTrue("for132", flag); 3187 try { 3188 d050.format(-1, -1, -2, -1, -1, -1); 3189 flag = false; 3190 } catch (java.lang.IllegalArgumentException $98) { 3191 flag = true; 3192 } 3193 TestFmwk.assertTrue("for133", flag); 3194 try { 3195 d050.format(-1, -1, -1, -2, -1, -1); 3196 flag = false; 3197 } catch (java.lang.IllegalArgumentException $99) { 3198 flag = true; 3199 } 3200 TestFmwk.assertTrue("for134", flag); 3201 try { 3202 d050.format(-1, -1, -1, -1, -2, -1); 3203 flag = false; 3204 } catch (java.lang.IllegalArgumentException $100) { 3205 flag = true; 3206 } 3207 TestFmwk.assertTrue("for135", flag); 3208 try { 3209 d050.format(-1, -1, -1, -1, -1, -2); 3210 flag = false; 3211 } catch (java.lang.IllegalArgumentException $101) { 3212 flag = true; 3213 } 3214 TestFmwk.assertTrue("for136", flag); 3215 } 3216 3217 /* ----------------------------------------------------------------- */ 3218 3219 /** Test the {@link android.icu.math.BigDecimal#hashCode} method. */ 3220 3221 @Test 3222 public void diaghashcode() { 3223 java.lang.String hs; 3224 android.icu.math.BigDecimal d; 3225 hs = "27827817"; 3226 d = new android.icu.math.BigDecimal(hs); 3227 TestFmwk.assertTrue("has001", (d.hashCode()) == (hs.hashCode())); 3228 hs = "1.265E+200"; 3229 d = new android.icu.math.BigDecimal(hs); 3230 TestFmwk.assertTrue("has002", (d.hashCode()) == (hs.hashCode())); 3231 hs = "126.5E+200"; 3232 d = new android.icu.math.BigDecimal(hs); 3233 TestFmwk.assertTrue("has003", (d.hashCode()) != (hs.hashCode())); 3234 } 3235 3236 /* ----------------------------------------------------------------- */ 3237 3238 /** Test the {@link android.icu.math.BigDecimal#intValue} method. */ 3239 3240 @Test 3241 public void diagintvalue() { 3242 boolean flag = false; 3243 java.lang.String v = null; 3244 java.lang.ArithmeticException ae = null; 3245 java.lang.String badstrings[]; 3246 int i = 0; 3247 java.lang.String norm = null; 3248 android.icu.math.BigDecimal dimax; 3249 android.icu.math.BigDecimal num = null; 3250 android.icu.math.BigDecimal dv = null; 3251 android.icu.math.BigDecimal dimin; 3252 3253 // intValue -- 3254 3255 TestFmwk.assertTrue("inv001", imin==((new android.icu.math.BigDecimal(imin)).intValue())); 3256 TestFmwk.assertTrue("inv002", ((99))==((new android.icu.math.BigDecimal("99")).intValue())); 3257 TestFmwk.assertTrue("inv003", ((1))==((new android.icu.math.BigDecimal("1")).intValue())); 3258 TestFmwk.assertTrue("inv004", ((0))==((new android.icu.math.BigDecimal("0")).intValue())); 3259 TestFmwk.assertTrue("inv005", ((-1))==((new android.icu.math.BigDecimal("-1")).intValue())); 3260 TestFmwk.assertTrue("inv006", ((-99))==((new android.icu.math.BigDecimal("-99")).intValue())); 3261 TestFmwk.assertTrue("inv007", imax==((new android.icu.math.BigDecimal(imax)).intValue())); 3262 TestFmwk.assertTrue("inv008", ((5))==((new android.icu.math.BigDecimal("5.0")).intValue())); 3263 TestFmwk.assertTrue("inv009", ((5))==((new android.icu.math.BigDecimal("5.3")).intValue())); 3264 TestFmwk.assertTrue("inv010", ((5))==((new android.icu.math.BigDecimal("5.5")).intValue())); 3265 TestFmwk.assertTrue("inv011", ((5))==((new android.icu.math.BigDecimal("5.7")).intValue())); 3266 TestFmwk.assertTrue("inv012", ((5))==((new android.icu.math.BigDecimal("5.9")).intValue())); 3267 TestFmwk.assertTrue("inv013", ((-5))==((new android.icu.math.BigDecimal("-5.0")).intValue())); 3268 TestFmwk.assertTrue("inv014", ((-5))==((new android.icu.math.BigDecimal("-5.3")).intValue())); 3269 TestFmwk.assertTrue("inv015", ((-5))==((new android.icu.math.BigDecimal("-5.5")).intValue())); 3270 TestFmwk.assertTrue("inv016", ((-5))==((new android.icu.math.BigDecimal("-5.7")).intValue())); 3271 TestFmwk.assertTrue("inv017", ((-5))==((new android.icu.math.BigDecimal("-5.9")).intValue())); 3272 TestFmwk.assertTrue("inv018", ((new android.icu.math.BigDecimal("88888888888")).intValue())==(-1305424328)); // ugh 3273 TestFmwk.assertTrue("inv019", ((new android.icu.math.BigDecimal("-88888888888")).intValue())==1305424328); // ugh 3274 TestFmwk.assertTrue("inv020", ((imin))==((new android.icu.math.BigDecimal((((long)imax))+1)).intValue())); 3275 TestFmwk.assertTrue("inv021", ((imax))==((new android.icu.math.BigDecimal((((long)imin))-1)).intValue())); 3276 3277 // intValueExact -- 3278 3279 TestFmwk.assertTrue("inv101", imin==((new android.icu.math.BigDecimal(imin)).intValueExact())); 3280 TestFmwk.assertTrue("inv102", ((99))==((new android.icu.math.BigDecimal("99")).intValue())); 3281 TestFmwk.assertTrue("inv103", ((1))==((new android.icu.math.BigDecimal("1")).intValue())); 3282 TestFmwk.assertTrue("inv104", ((0))==((new android.icu.math.BigDecimal("0")).intValue())); 3283 TestFmwk.assertTrue("inv105", ((-1))==((new android.icu.math.BigDecimal("-1")).intValue())); 3284 TestFmwk.assertTrue("inv106", ((-99))==((new android.icu.math.BigDecimal("-99")).intValue())); 3285 TestFmwk.assertTrue("inv107", imax==((new android.icu.math.BigDecimal(imax)).intValue())); 3286 TestFmwk.assertTrue("inv108", ((5))==((new android.icu.math.BigDecimal("5.0")).intValue())); 3287 TestFmwk.assertTrue("inv109", ((-5))==((new android.icu.math.BigDecimal("-5.0")).intValue())); 3288 TestFmwk.assertTrue("inv110", imax==((new android.icu.math.BigDecimal(imax)).intValueExact())); 3289 3290 try { 3291 v = "-88588688888"; 3292 (new android.icu.math.BigDecimal(v)).intValueExact(); 3293 flag = false; 3294 } catch (java.lang.ArithmeticException $102) { 3295 ae = $102; 3296 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 3297 } 3298 TestFmwk.assertTrue("inv200", flag); 3299 3300 // this one could raise either overflow or bad decimal part 3301 try { 3302 v = "88088818888.00001"; 3303 (new android.icu.math.BigDecimal(v)).intValueExact(); 3304 flag = false; 3305 } catch (java.lang.ArithmeticException $103) { 3306 flag = true; 3307 } 3308 TestFmwk.assertTrue("inv201", flag); 3309 3310 // 1999.10.28: the testcases marked '*' failed 3311 badstrings = new java.lang.String[] { 3312 "12345678901", 3313 (new android.icu.math.BigDecimal(imax)).add(one).toString(), 3314 (new android.icu.math.BigDecimal(imin)).subtract(one) 3315 .toString(), 3316 "3731367293", 3317 "4731367293", 3318 "5731367293", 3319 "6731367293", 3320 "7731367293", 3321 "8731367293", 3322 "9731367293", 3323 "-3731367293", 3324 "-4731367293", 3325 "-5731367293", 3326 "-6731367293", 3327 "-7731367293", 3328 "-8731367293", 3329 "-9731367293", 3330 (new android.icu.math.BigDecimal(imin)).multiply(two) 3331 .toString(), 3332 (new android.icu.math.BigDecimal(imax)).multiply(two) 3333 .toString(), 3334 (new android.icu.math.BigDecimal(imin)).multiply(ten) 3335 .toString(), 3336 (new android.icu.math.BigDecimal(imax)).multiply(ten) 3337 .toString(), "4731367293", "4831367293", "4931367293", 3338 "5031367293", "5131367293", "5231367293", "5331367293", 3339 "5431367293", "5531367293", "5631367293", "5731367293", 3340 "5831367293", "5931367293", "6031367293", "6131367293", 3341 "6231367293", "6331367293", "6431367293", "6531367293", 3342 "6631367293", "6731367293", "2200000000", "2300000000", 3343 "2400000000", "2500000000", "2600000000", "2700000000", 3344 "2800000000", "2900000000", "-2200000000", "-2300000000", 3345 "-2400000000", "-2500000000", "-2600000000", "-2700000000", 3346 "-2800000000", "-2900000000", "25E+8", "-25E+8", "-12345678901" }; // 220 3347 // 221 3348 // 222 3349 // 223 3350 // 224 3351 // 225 * 3352 // 226 3353 // 227 3354 // 228 3355 // 229 * 3356 // 230 3357 // 231 3358 // 232 * 3359 // 233 3360 // 234 3361 // 235 3362 // 236 * 3363 // 237 3364 // 238 3365 // 239 3366 // 240 3367 // 241 3368 // 242 * 3369 // 243 * 3370 // 244 * 3371 // 245 * 3372 // 246 * 3373 // 247 * 3374 // 248 * 3375 // 249 * 3376 // 250 * 3377 // 251 * 3378 // 252 * 3379 // 253 * 3380 // 254 * 3381 // 255 * 3382 // 256 * 3383 // 257 * 3384 // 258 * 3385 // 259 3386 // 260 3387 // 261 3388 // 262 3389 // 263 3390 // 264 3391 // 265 3392 // 266 3393 // 267 3394 // 268 3395 // 269 3396 // 270 3397 // 271 3398 // 272 3399 // 273 3400 // 274 3401 // 275 3402 // 276 3403 // 277 3404 // 278 3405 // 279 3406 // 280 3407 { 3408 int $104 = badstrings.length; 3409 i = 0; 3410 for (; $104 > 0; $104--, i++) { 3411 try { 3412 v = badstrings[i]; 3413 (new android.icu.math.BigDecimal(v)).intValueExact(); 3414 flag = false; 3415 } catch (java.lang.ArithmeticException $105) { 3416 ae = $105; 3417 norm = (new android.icu.math.BigDecimal(v)).toString(); 3418 flag = (ae.getMessage()).equals("Conversion overflow:" 3419 + " " + norm); 3420 } 3421 TestFmwk.assertTrue("inv" + (220 + i), flag); 3422 } 3423 }/* i */ 3424 3425 // now slip in some single bits... 3426 dimax = new android.icu.math.BigDecimal(imax); 3427 { 3428 i = 0; 3429 for (; i <= 49; i++) { 3430 try { 3431 num = two.pow(new android.icu.math.BigDecimal(i), mc50); 3432 dv = dimax.add(num, mc50); 3433 dv.intValueExact(); 3434 flag = false; 3435 } catch (java.lang.ArithmeticException $106) { 3436 ae = $106; 3437 norm = dv.toString(); 3438 flag = (ae.getMessage()).equals("Conversion overflow:" 3439 + " " + norm); 3440 } 3441 TestFmwk.assertTrue("inv" + (300 + i), flag); 3442 } 3443 }/* i */ 3444 dimin = new android.icu.math.BigDecimal(imin); 3445 { 3446 i = 50; 3447 for (; i <= 99; i++) { 3448 try { 3449 num = two.pow(new android.icu.math.BigDecimal(i), mc50); 3450 dv = dimin.subtract(num, mc50); 3451 dv.intValueExact(); 3452 flag = false; 3453 } catch (java.lang.ArithmeticException $107) { 3454 ae = $107; 3455 norm = dv.toString(); 3456 flag = (ae.getMessage()).equals("Conversion overflow:" 3457 + " " + norm); 3458 } 3459 TestFmwk.assertTrue("inv" + (300 + i), flag); 3460 } 3461 }/* i */ 3462 3463 // the following should all raise bad-decimal-part exceptions 3464 badstrings = new java.lang.String[] { "0.09", "0.9", "0.01", "0.1", 3465 "-0.01", "-0.1", "1.01", "-1.01", "-1.1", "-111.111", 3466 "+111.111", "1.09", "1.05", "1.04", "1.99", "1.9", "1.5", 3467 "1.4", "-1.09", "-1.05", "-1.04", "-1.99", "-1.9", "-1.5", 3468 "-1.4", "1E-1000", "-1E-1000", "11E-1", "1.5" }; // 400-403 3469 // 404-407 3470 // 408-411 3471 // 412-416 3472 // 417-420 3473 // 421-424 3474 // 425-428 3475 3476 { 3477 int $108 = badstrings.length; 3478 i = 0; 3479 for (; $108 > 0; $108--, i++) { 3480 try { 3481 v = badstrings[i]; 3482 (new android.icu.math.BigDecimal(v)).intValueExact(); 3483 flag = false; 3484 } catch (java.lang.ArithmeticException $109) { 3485 ae = $109; 3486 norm = (new android.icu.math.BigDecimal(v)).toString(); 3487 flag = (ae.getMessage()).equals("Decimal part non-zero:" 3488 + " " + norm); 3489 } 3490 TestFmwk.assertTrue("inv" + (400 + i), flag); 3491 } 3492 }/* i */ 3493 } 3494 3495 /* ----------------------------------------------------------------- */ 3496 3497 /** Test the {@link android.icu.math.BigDecimal#longValue} method. */ 3498 3499 @Test 3500 public void diaglongvalue() { 3501 boolean flag = false; 3502 java.lang.String v = null; 3503 java.lang.ArithmeticException ae = null; 3504 java.lang.String badstrings[]; 3505 int i = 0; 3506 java.lang.String norm = null; 3507 android.icu.math.BigDecimal dlmax; 3508 android.icu.math.BigDecimal num = null; 3509 android.icu.math.BigDecimal dv = null; 3510 android.icu.math.BigDecimal dlmin; 3511 3512 // longValue -- 3513 3514 TestFmwk.assertTrue("lov001", lmin==((new android.icu.math.BigDecimal(lmin)).longValue())); 3515 TestFmwk.assertTrue("lov002", ((99))==((new android.icu.math.BigDecimal("99")).longValue())); 3516 TestFmwk.assertTrue("lov003", ((1))==((new android.icu.math.BigDecimal("1")).longValue())); 3517 TestFmwk.assertTrue("lov004", ((0))==((new android.icu.math.BigDecimal("0")).longValue())); 3518 TestFmwk.assertTrue("lov005", ((-1))==((new android.icu.math.BigDecimal("-1")).longValue())); 3519 TestFmwk.assertTrue("lov006", ((-99))==((new android.icu.math.BigDecimal("-99")).longValue())); 3520 TestFmwk.assertTrue("lov007", lmax==((new android.icu.math.BigDecimal(lmax)).longValue())); 3521 TestFmwk.assertTrue("lov008", ((5))==((new android.icu.math.BigDecimal("5.0")).longValue())); 3522 TestFmwk.assertTrue("lov009", ((5))==((new android.icu.math.BigDecimal("5.3")).longValue())); 3523 TestFmwk.assertTrue("lov010", ((5))==((new android.icu.math.BigDecimal("5.5")).longValue())); 3524 TestFmwk.assertTrue("lov011", ((5))==((new android.icu.math.BigDecimal("5.7")).longValue())); 3525 TestFmwk.assertTrue("lov012", ((5))==((new android.icu.math.BigDecimal("5.9")).longValue())); 3526 TestFmwk.assertTrue("lov013", ((-5))==((new android.icu.math.BigDecimal("-5.0")).longValue())); 3527 TestFmwk.assertTrue("lov014", ((-5))==((new android.icu.math.BigDecimal("-5.3")).longValue())); 3528 TestFmwk.assertTrue("lov015", ((-5))==((new android.icu.math.BigDecimal("-5.5")).longValue())); 3529 TestFmwk.assertTrue("lov016", ((-5))==((new android.icu.math.BigDecimal("-5.7")).longValue())); 3530 TestFmwk.assertTrue("lov017", ((-5))==((new android.icu.math.BigDecimal("-5.9")).longValue())); 3531 TestFmwk.assertTrue("lov018", ((new android.icu.math.BigDecimal("888888888899999999998")).longValue())==3445173361941522430L); // ugh 3532 TestFmwk.assertTrue("lov019", ((new android.icu.math.BigDecimal("-888888888899999999998")).longValue())==(-3445173361941522430L)); // ugh 3533 3534 // longValueExact -- 3535 3536 TestFmwk.assertTrue("lov101", lmin==((new android.icu.math.BigDecimal(lmin)).longValue())); 3537 TestFmwk.assertTrue("lov102", ((99))==((new android.icu.math.BigDecimal("99")).longValue())); 3538 TestFmwk.assertTrue("lov103", ((1))==((new android.icu.math.BigDecimal("1")).longValue())); 3539 TestFmwk.assertTrue("lov104", ((0))==((new android.icu.math.BigDecimal("0")).longValue())); 3540 TestFmwk.assertTrue("lov105", ((-1))==((new android.icu.math.BigDecimal("-1")).longValue())); 3541 TestFmwk.assertTrue("lov106", ((-99))==((new android.icu.math.BigDecimal("-99")).longValue())); 3542 TestFmwk.assertTrue("lov107", lmax==((new android.icu.math.BigDecimal(lmax)).longValue())); 3543 TestFmwk.assertTrue("lov108", ((5))==((new android.icu.math.BigDecimal("5.0")).longValue())); 3544 TestFmwk.assertTrue("lov109", ((-5))==((new android.icu.math.BigDecimal("-5.0")).longValue())); 3545 3546 try { 3547 v = "-888888888899999999998"; 3548 (new android.icu.math.BigDecimal(v)).longValueExact(); 3549 flag = false; 3550 } catch (java.lang.ArithmeticException $110) { 3551 ae = $110; 3552 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 3553 } 3554 TestFmwk.assertTrue("lov200", flag); 3555 try { 3556 v = "88888887487487479488888"; 3557 (new android.icu.math.BigDecimal(v)).longValueExact(); 3558 flag = false; 3559 } catch (java.lang.ArithmeticException $111) { 3560 ae = $111; 3561 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 3562 } 3563 TestFmwk.assertTrue("lov201", flag); 3564 try { 3565 v = "1.5"; 3566 (new android.icu.math.BigDecimal(v)).longValueExact(); 3567 flag = false; 3568 } catch (java.lang.ArithmeticException $112) { 3569 ae = $112; 3570 flag = (ae.getMessage()).equals("Decimal part non-zero:" + " " + v); 3571 } 3572 TestFmwk.assertTrue("lov202", flag); 3573 3574 badstrings = new java.lang.String[] { 3575 "1234567890110987654321", 3576 "-1234567890110987654321", 3577 (new android.icu.math.BigDecimal(lmax)).add(one).toString(), 3578 (new android.icu.math.BigDecimal(lmin)).subtract(one) 3579 .toString(), 3580 (new android.icu.math.BigDecimal(lmin)).multiply(two) 3581 .toString(), 3582 (new android.icu.math.BigDecimal(lmax)).multiply(two) 3583 .toString(), 3584 (new android.icu.math.BigDecimal(lmin)).multiply(ten) 3585 .toString(), 3586 (new android.icu.math.BigDecimal(lmax)).multiply(ten) 3587 .toString(), "9223372036854775818", 3588 "9323372036854775818", "9423372036854775818", 3589 "9523372036854775818", "9623372036854775818", 3590 "9723372036854775818", "9823372036854775818", 3591 "9923372036854775818", "-9223372036854775818", 3592 "-9323372036854775818", "-9423372036854775818", 3593 "-9523372036854775818", "-9623372036854775818", 3594 "-9723372036854775818", "-9823372036854775818", 3595 "-9923372036854775818", "12345678901234567890" }; // 220 3596 // 221 3597 // 222 3598 // 223 3599 // 224 3600 // 225 3601 // 226 3602 // 227 3603 // 228 3604 // 229 3605 // 230 3606 // 231 3607 // 232 3608 // 233 3609 // 234 3610 // 235 3611 // 236 3612 // 237 3613 // 238 3614 // 239 3615 // 240 3616 // 241 3617 // 242 3618 // 243 3619 // 244 3620 { 3621 int $113 = badstrings.length; 3622 i = 0; 3623 for (; $113 > 0; $113--, i++) { 3624 try { 3625 v = badstrings[i]; 3626 (new android.icu.math.BigDecimal(v)).longValueExact(); 3627 flag = false; 3628 } catch (java.lang.ArithmeticException $114) { 3629 ae = $114; 3630 norm = (new android.icu.math.BigDecimal(v)).toString(); 3631 flag = (ae.getMessage()).equals("Conversion overflow:" 3632 + " " + norm); 3633 } 3634 TestFmwk.assertTrue("lov" + (220 + i), flag); 3635 } 3636 }/* i */ 3637 3638 // now slip in some single bits... 3639 dlmax = new android.icu.math.BigDecimal(lmax); 3640 { 3641 i = 0; 3642 for (; i <= 99; i++) { 3643 try { 3644 num = two.pow(new android.icu.math.BigDecimal(i), mc50); 3645 dv = dlmax.add(num, mc50); 3646 dv.longValueExact(); 3647 flag = false; 3648 } catch (java.lang.ArithmeticException $115) { 3649 ae = $115; 3650 norm = dv.toString(); 3651 flag = (ae.getMessage()).equals("Conversion overflow:" 3652 + " " + norm); 3653 } 3654 TestFmwk.assertTrue("lov" + (300 + i), flag); 3655 } 3656 }/* i */ 3657 dlmin = new android.icu.math.BigDecimal(lmin); 3658 { 3659 i = 0; 3660 for (; i <= 99; i++) { 3661 try { 3662 num = two.pow(new android.icu.math.BigDecimal(i), mc50); 3663 dv = dlmin.subtract(num, mc50); 3664 dv.longValueExact(); 3665 flag = false; 3666 } catch (java.lang.ArithmeticException $116) { 3667 ae = $116; 3668 norm = dv.toString(); 3669 flag = (ae.getMessage()).equals("Conversion overflow:" 3670 + " " + norm); 3671 } 3672 TestFmwk.assertTrue("lov" + (400 + i), flag); 3673 } 3674 }/* i */ 3675 } 3676 3677 /* ----------------------------------------------------------------- */ 3678 3679 /** Test the {@link android.icu.math.BigDecimal#movePointLeft} method. */ 3680 3681 @Test 3682 public void diagmovepointleft() { 3683 TestFmwk.assertTrue("mpl001", ((new android.icu.math.BigDecimal("-1")).movePointLeft(-10).toString()).equals("-10000000000")); 3684 TestFmwk.assertTrue("mpl002", ((new android.icu.math.BigDecimal("-1")).movePointLeft(-5).toString()).equals("-100000")); 3685 TestFmwk.assertTrue("mpl003", ((new android.icu.math.BigDecimal("-1")).movePointLeft(-1).toString()).equals("-10")); 3686 TestFmwk.assertTrue("mpl004", ((new android.icu.math.BigDecimal("-1")).movePointLeft(0).toString()).equals("-1")); 3687 TestFmwk.assertTrue("mpl005", ((new android.icu.math.BigDecimal("-1")).movePointLeft(+1).toString()).equals("-0.1")); 3688 TestFmwk.assertTrue("mpl006", ((new android.icu.math.BigDecimal("-1")).movePointLeft(+5).toString()).equals("-0.00001")); 3689 TestFmwk.assertTrue("mpl007", ((new android.icu.math.BigDecimal("-1")).movePointLeft(+10).toString()).equals("-0.0000000001")); 3690 3691 TestFmwk.assertTrue("mpl010", ((new android.icu.math.BigDecimal("0")).movePointLeft(-10).toString()).equals("0")); 3692 TestFmwk.assertTrue("mpl010", ((new android.icu.math.BigDecimal("0")).movePointLeft(-5).toString()).equals("0")); 3693 TestFmwk.assertTrue("mpl010", ((new android.icu.math.BigDecimal("0")).movePointLeft(-1).toString()).equals("0")); 3694 TestFmwk.assertTrue("mpl010", ((new android.icu.math.BigDecimal("0")).movePointLeft(0).toString()).equals("0")); 3695 TestFmwk.assertTrue("mpl010", ((new android.icu.math.BigDecimal("0")).movePointLeft(+1).toString()).equals("0.0")); 3696 TestFmwk.assertTrue("mpl010", ((new android.icu.math.BigDecimal("0")).movePointLeft(+5).toString()).equals("0.00000")); 3697 TestFmwk.assertTrue("mpl010", ((new android.icu.math.BigDecimal("0")).movePointLeft(+10).toString()).equals("0.0000000000")); 3698 3699 TestFmwk.assertTrue("mpl020", ((new android.icu.math.BigDecimal("+1")).movePointLeft(-10).toString()).equals("10000000000")); 3700 TestFmwk.assertTrue("mpl021", ((new android.icu.math.BigDecimal("+1")).movePointLeft(-5).toString()).equals("100000")); 3701 TestFmwk.assertTrue("mpl022", ((new android.icu.math.BigDecimal("+1")).movePointLeft(-1).toString()).equals("10")); 3702 TestFmwk.assertTrue("mpl023", ((new android.icu.math.BigDecimal("+1")).movePointLeft(0).toString()).equals("1")); 3703 TestFmwk.assertTrue("mpl024", ((new android.icu.math.BigDecimal("+1")).movePointLeft(+1).toString()).equals("0.1")); 3704 TestFmwk.assertTrue("mpl025", ((new android.icu.math.BigDecimal("+1")).movePointLeft(+5).toString()).equals("0.00001")); 3705 TestFmwk.assertTrue("mpl026", ((new android.icu.math.BigDecimal("+1")).movePointLeft(+10).toString()).equals("0.0000000001")); 3706 3707 TestFmwk.assertTrue("mpl030", ((new android.icu.math.BigDecimal("0.5E+1")).movePointLeft(-10).toString()).equals("50000000000")); 3708 TestFmwk.assertTrue("mpl031", ((new android.icu.math.BigDecimal("0.5E+1")).movePointLeft(-5).toString()).equals("500000")); 3709 TestFmwk.assertTrue("mpl032", ((new android.icu.math.BigDecimal("0.5E+1")).movePointLeft(-1).toString()).equals("50")); 3710 TestFmwk.assertTrue("mpl033", ((new android.icu.math.BigDecimal("0.5E+1")).movePointLeft(0).toString()).equals("5")); 3711 TestFmwk.assertTrue("mpl034", ((new android.icu.math.BigDecimal("0.5E+1")).movePointLeft(+1).toString()).equals("0.5")); 3712 TestFmwk.assertTrue("mpl035", ((new android.icu.math.BigDecimal("0.5E+1")).movePointLeft(+5).toString()).equals("0.00005")); 3713 TestFmwk.assertTrue("mpl036", ((new android.icu.math.BigDecimal("0.5E+1")).movePointLeft(+10).toString()).equals("0.0000000005")); 3714 } 3715 3716 /* ----------------------------------------------------------------- */ 3717 3718 /** Test the {@link android.icu.math.BigDecimal#movePointRight} method. */ 3719 3720 @Test 3721 public void diagmovepointright() { 3722 TestFmwk.assertTrue("mpr001", ((new android.icu.math.BigDecimal("-1")).movePointRight(+10).toString()).equals("-10000000000")); 3723 TestFmwk.assertTrue("mpr002", ((new android.icu.math.BigDecimal("-1")).movePointRight(+5).toString()).equals("-100000")); 3724 TestFmwk.assertTrue("mpr003", ((new android.icu.math.BigDecimal("-1")).movePointRight(+1).toString()).equals("-10")); 3725 TestFmwk.assertTrue("mpr004", ((new android.icu.math.BigDecimal("-1")).movePointRight(0).toString()).equals("-1")); 3726 TestFmwk.assertTrue("mpr005", ((new android.icu.math.BigDecimal("-1")).movePointRight(-1).toString()).equals("-0.1")); 3727 TestFmwk.assertTrue("mpr006", ((new android.icu.math.BigDecimal("-1")).movePointRight(-5).toString()).equals("-0.00001")); 3728 TestFmwk.assertTrue("mpr007", ((new android.icu.math.BigDecimal("-1")).movePointRight(-10).toString()).equals("-0.0000000001")); 3729 3730 TestFmwk.assertTrue("mpr010", ((new android.icu.math.BigDecimal("0")).movePointRight(+10).toString()).equals("0")); 3731 TestFmwk.assertTrue("mpr011", ((new android.icu.math.BigDecimal("0")).movePointRight(+5).toString()).equals("0")); 3732 TestFmwk.assertTrue("mpr012", ((new android.icu.math.BigDecimal("0")).movePointRight(+1).toString()).equals("0")); 3733 TestFmwk.assertTrue("mpr013", ((new android.icu.math.BigDecimal("0")).movePointRight(0).toString()).equals("0")); 3734 TestFmwk.assertTrue("mpr014", ((new android.icu.math.BigDecimal("0")).movePointRight(-1).toString()).equals("0.0")); 3735 TestFmwk.assertTrue("mpr015", ((new android.icu.math.BigDecimal("0")).movePointRight(-5).toString()).equals("0.00000")); 3736 TestFmwk.assertTrue("mpr016", ((new android.icu.math.BigDecimal("0")).movePointRight(-10).toString()).equals("0.0000000000")); 3737 3738 TestFmwk.assertTrue("mpr020", ((new android.icu.math.BigDecimal("+1")).movePointRight(+10).toString()).equals("10000000000")); 3739 TestFmwk.assertTrue("mpr021", ((new android.icu.math.BigDecimal("+1")).movePointRight(+5).toString()).equals("100000")); 3740 TestFmwk.assertTrue("mpr022", ((new android.icu.math.BigDecimal("+1")).movePointRight(+1).toString()).equals("10")); 3741 TestFmwk.assertTrue("mpr023", ((new android.icu.math.BigDecimal("+1")).movePointRight(0).toString()).equals("1")); 3742 TestFmwk.assertTrue("mpr024", ((new android.icu.math.BigDecimal("+1")).movePointRight(-1).toString()).equals("0.1")); 3743 TestFmwk.assertTrue("mpr025", ((new android.icu.math.BigDecimal("+1")).movePointRight(-5).toString()).equals("0.00001")); 3744 TestFmwk.assertTrue("mpr026", ((new android.icu.math.BigDecimal("+1")).movePointRight(-10).toString()).equals("0.0000000001")); 3745 3746 TestFmwk.assertTrue("mpr030", ((new android.icu.math.BigDecimal("0.5E+1")).movePointRight(+10).toString()).equals("50000000000")); 3747 TestFmwk.assertTrue("mpr031", ((new android.icu.math.BigDecimal("0.5E+1")).movePointRight(+5).toString()).equals("500000")); 3748 TestFmwk.assertTrue("mpr032", ((new android.icu.math.BigDecimal("0.5E+1")).movePointRight(+1).toString()).equals("50")); 3749 TestFmwk.assertTrue("mpr033", ((new android.icu.math.BigDecimal("0.5E+1")).movePointRight(0).toString()).equals("5")); 3750 TestFmwk.assertTrue("mpr034", ((new android.icu.math.BigDecimal("0.5E+1")).movePointRight(-1).toString()).equals("0.5")); 3751 TestFmwk.assertTrue("mpr035", ((new android.icu.math.BigDecimal("0.5E+1")).movePointRight(-5).toString()).equals("0.00005")); 3752 TestFmwk.assertTrue("mpr036", ((new android.icu.math.BigDecimal("0.5E+1")).movePointRight(-10).toString()).equals("0.0000000005")); 3753 } 3754 3755 /* ----------------------------------------------------------------- */ 3756 3757 /** Test the {@link android.icu.math.BigDecimal#scale} method. */ 3758 3759 @Test 3760 public void diagscale() { 3761 TestFmwk.assertTrue("sca001", ((new android.icu.math.BigDecimal("-1")).scale())==0); 3762 TestFmwk.assertTrue("sca002", ((new android.icu.math.BigDecimal("-10")).scale())==0); 3763 TestFmwk.assertTrue("sca003", ((new android.icu.math.BigDecimal("+1")).scale())==0); 3764 TestFmwk.assertTrue("sca004", ((new android.icu.math.BigDecimal("+10")).scale())==0); 3765 TestFmwk.assertTrue("sca005", ((new android.icu.math.BigDecimal("1E+10")).scale())==0); 3766 TestFmwk.assertTrue("sca006", ((new android.icu.math.BigDecimal("1E-10")).scale())==10); 3767 TestFmwk.assertTrue("sca007", ((new android.icu.math.BigDecimal("0E-10")).scale())==0); 3768 TestFmwk.assertTrue("sca008", ((new android.icu.math.BigDecimal("0.000")).scale())==3); 3769 TestFmwk.assertTrue("sca009", ((new android.icu.math.BigDecimal("0.00")).scale())==2); 3770 TestFmwk.assertTrue("sca010", ((new android.icu.math.BigDecimal("0.0")).scale())==1); 3771 TestFmwk.assertTrue("sca011", ((new android.icu.math.BigDecimal("0.1")).scale())==1); 3772 TestFmwk.assertTrue("sca012", ((new android.icu.math.BigDecimal("0.12")).scale())==2); 3773 TestFmwk.assertTrue("sca013", ((new android.icu.math.BigDecimal("0.123")).scale())==3); 3774 TestFmwk.assertTrue("sca014", ((new android.icu.math.BigDecimal("-0.0")).scale())==1); 3775 TestFmwk.assertTrue("sca015", ((new android.icu.math.BigDecimal("-0.1")).scale())==1); 3776 TestFmwk.assertTrue("sca016", ((new android.icu.math.BigDecimal("-0.12")).scale())==2); 3777 TestFmwk.assertTrue("sca017", ((new android.icu.math.BigDecimal("-0.123")).scale())==3); 3778 } 3779 3780 /* ----------------------------------------------------------------- */ 3781 3782 /** Test the {@link android.icu.math.BigDecimal#setScale} method. */ 3783 3784 @Test 3785 public void diagsetscale() { 3786 boolean flag = false; 3787 java.lang.RuntimeException e = null; 3788 3789 TestFmwk.assertTrue("ssc001", ((new android.icu.math.BigDecimal("-1")).setScale(0).toString()).equals("-1")); 3790 TestFmwk.assertTrue("ssc002", ((new android.icu.math.BigDecimal("-1")).setScale(1).toString()).equals("-1.0")); 3791 TestFmwk.assertTrue("ssc003", ((new android.icu.math.BigDecimal("-1")).setScale(2).toString()).equals("-1.00")); 3792 TestFmwk.assertTrue("ssc004", ((new android.icu.math.BigDecimal("0")).setScale(0).toString()).equals("0")); 3793 TestFmwk.assertTrue("ssc005", ((new android.icu.math.BigDecimal("0")).setScale(1).toString()).equals("0.0")); 3794 TestFmwk.assertTrue("ssc006", ((new android.icu.math.BigDecimal("0")).setScale(2).toString()).equals("0.00")); 3795 TestFmwk.assertTrue("ssc007", ((new android.icu.math.BigDecimal("+1")).setScale(0).toString()).equals("1")); 3796 TestFmwk.assertTrue("ssc008", ((new android.icu.math.BigDecimal("+1")).setScale(1).toString()).equals("1.0")); 3797 TestFmwk.assertTrue("ssc009", ((new android.icu.math.BigDecimal("+1")).setScale(2).toString()).equals("1.00")); 3798 TestFmwk.assertTrue("ssc010", ((new android.icu.math.BigDecimal("-1")).setScale(0,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("-1")); 3799 TestFmwk.assertTrue("ssc011", ((new android.icu.math.BigDecimal("-1")).setScale(1,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("-1.0")); 3800 TestFmwk.assertTrue("ssc012", ((new android.icu.math.BigDecimal("-1")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("-1.00")); 3801 TestFmwk.assertTrue("ssc013", ((new android.icu.math.BigDecimal("0")).setScale(0,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 3802 TestFmwk.assertTrue("ssc014", ((new android.icu.math.BigDecimal("0")).setScale(1,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.0")); 3803 TestFmwk.assertTrue("ssc015", ((new android.icu.math.BigDecimal("0")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.00")); 3804 TestFmwk.assertTrue("ssc016", ((new android.icu.math.BigDecimal("+1")).setScale(0,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1")); 3805 TestFmwk.assertTrue("ssc017", ((new android.icu.math.BigDecimal("+1")).setScale(1,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.0")); 3806 TestFmwk.assertTrue("ssc018", ((new android.icu.math.BigDecimal("+1")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.00")); 3807 3808 TestFmwk.assertTrue("ssc020", ((new android.icu.math.BigDecimal("1.04")).setScale(3,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.040")); 3809 TestFmwk.assertTrue("ssc021", ((new android.icu.math.BigDecimal("1.04")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.04")); 3810 TestFmwk.assertTrue("ssc022", ((new android.icu.math.BigDecimal("1.04")).setScale(1,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.0")); 3811 TestFmwk.assertTrue("ssc023", ((new android.icu.math.BigDecimal("1.04")).setScale(0,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1")); 3812 TestFmwk.assertTrue("ssc024", ((new android.icu.math.BigDecimal("1.05")).setScale(3,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.050")); 3813 TestFmwk.assertTrue("ssc025", ((new android.icu.math.BigDecimal("1.05")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.05")); 3814 TestFmwk.assertTrue("ssc026", ((new android.icu.math.BigDecimal("1.05")).setScale(1,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.1")); 3815 TestFmwk.assertTrue("ssc027", ((new android.icu.math.BigDecimal("1.05")).setScale(0,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1")); 3816 TestFmwk.assertTrue("ssc028", ((new android.icu.math.BigDecimal("1.05")).setScale(3,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("1.050")); 3817 TestFmwk.assertTrue("ssc029", ((new android.icu.math.BigDecimal("1.05")).setScale(2,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("1.05")); 3818 TestFmwk.assertTrue("ssc030", ((new android.icu.math.BigDecimal("1.05")).setScale(1,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("1.0")); 3819 TestFmwk.assertTrue("ssc031", ((new android.icu.math.BigDecimal("1.05")).setScale(0,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("1")); 3820 TestFmwk.assertTrue("ssc032", ((new android.icu.math.BigDecimal("1.06")).setScale(3,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.060")); 3821 TestFmwk.assertTrue("ssc033", ((new android.icu.math.BigDecimal("1.06")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.06")); 3822 TestFmwk.assertTrue("ssc034", ((new android.icu.math.BigDecimal("1.06")).setScale(1,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.1")); 3823 TestFmwk.assertTrue("ssc035", ((new android.icu.math.BigDecimal("1.06")).setScale(0,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1")); 3824 3825 TestFmwk.assertTrue("ssc040", ((new android.icu.math.BigDecimal("-10")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("-10.00")); 3826 TestFmwk.assertTrue("ssc041", ((new android.icu.math.BigDecimal("+1")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.00")); 3827 TestFmwk.assertTrue("ssc042", ((new android.icu.math.BigDecimal("+10")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("10.00")); 3828 TestFmwk.assertTrue("ssc043", ((new android.icu.math.BigDecimal("1E+10")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("10000000000.00")); 3829 TestFmwk.assertTrue("ssc044", ((new android.icu.math.BigDecimal("1E-10")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.00")); 3830 TestFmwk.assertTrue("ssc045", ((new android.icu.math.BigDecimal("1E-2")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.01")); 3831 TestFmwk.assertTrue("ssc046", ((new android.icu.math.BigDecimal("0E-10")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.00")); 3832 3833 // check rounding 3834 TestFmwk.assertTrue("ssc050", ((new android.icu.math.BigDecimal("0.005")).setScale(2,android.icu.math.MathContext.ROUND_CEILING).toString()).equals("0.01")); 3835 TestFmwk.assertTrue("ssc051", ((new android.icu.math.BigDecimal("0.005")).setScale(1,android.icu.math.MathContext.ROUND_CEILING).toString()).equals("0.1")); 3836 TestFmwk.assertTrue("ssc052", ((new android.icu.math.BigDecimal("0.005")).setScale(0,android.icu.math.MathContext.ROUND_CEILING).toString()).equals("1")); 3837 TestFmwk.assertTrue("ssc053", ((new android.icu.math.BigDecimal("0.005")).setScale(2,android.icu.math.MathContext.ROUND_DOWN).toString()).equals("0.00")); 3838 TestFmwk.assertTrue("ssc054", ((new android.icu.math.BigDecimal("0.005")).setScale(1,android.icu.math.MathContext.ROUND_DOWN).toString()).equals("0.0")); 3839 TestFmwk.assertTrue("ssc055", ((new android.icu.math.BigDecimal("0.005")).setScale(0,android.icu.math.MathContext.ROUND_DOWN).toString()).equals("0")); 3840 TestFmwk.assertTrue("ssc056", ((new android.icu.math.BigDecimal("0.005")).setScale(2,android.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0.00")); 3841 TestFmwk.assertTrue("ssc057", ((new android.icu.math.BigDecimal("0.005")).setScale(1,android.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0.0")); 3842 TestFmwk.assertTrue("ssc058", ((new android.icu.math.BigDecimal("0.005")).setScale(0,android.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0")); 3843 TestFmwk.assertTrue("ssc059", ((new android.icu.math.BigDecimal("0.005")).setScale(2,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.00")); 3844 TestFmwk.assertTrue("ssc060", ((new android.icu.math.BigDecimal("0.005")).setScale(1,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.0")); 3845 TestFmwk.assertTrue("ssc061", ((new android.icu.math.BigDecimal("0.005")).setScale(0,android.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0")); 3846 TestFmwk.assertTrue("ssc062", ((new android.icu.math.BigDecimal("0.005")).setScale(2,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.00")); 3847 TestFmwk.assertTrue("ssc063", ((new android.icu.math.BigDecimal("0.005")).setScale(1,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.0")); 3848 TestFmwk.assertTrue("ssc064", ((new android.icu.math.BigDecimal("0.005")).setScale(0,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 3849 TestFmwk.assertTrue("ssc065", ((new android.icu.math.BigDecimal("0.015")).setScale(2,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.02")); 3850 TestFmwk.assertTrue("ssc066", ((new android.icu.math.BigDecimal("0.015")).setScale(1,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.0")); 3851 TestFmwk.assertTrue("ssc067", ((new android.icu.math.BigDecimal("0.015")).setScale(0,android.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 3852 TestFmwk.assertTrue("ssc068", ((new android.icu.math.BigDecimal("0.005")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.01")); 3853 TestFmwk.assertTrue("ssc069", ((new android.icu.math.BigDecimal("0.005")).setScale(1,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.0")); 3854 TestFmwk.assertTrue("ssc070", ((new android.icu.math.BigDecimal("0.005")).setScale(0,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 3855 TestFmwk.assertTrue("ssc071", ((new android.icu.math.BigDecimal("0.095")).setScale(2,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.10")); 3856 TestFmwk.assertTrue("ssc072", ((new android.icu.math.BigDecimal("0.095")).setScale(1,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.1")); 3857 TestFmwk.assertTrue("ssc073", ((new android.icu.math.BigDecimal("0.095")).setScale(0,android.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 3858 TestFmwk.assertTrue("ssc074", ((new android.icu.math.BigDecimal("0.005")).setScale(2,android.icu.math.MathContext.ROUND_UP).toString()).equals("0.01")); 3859 TestFmwk.assertTrue("ssc075", ((new android.icu.math.BigDecimal("0.005")).setScale(1,android.icu.math.MathContext.ROUND_UP).toString()).equals("0.1")); 3860 TestFmwk.assertTrue("ssc076", ((new android.icu.math.BigDecimal("0.005")).setScale(0,android.icu.math.MathContext.ROUND_UP).toString()).equals("1")); 3861 3862 try { 3863 (new android.icu.math.BigDecimal(1)).setScale(-8); 3864 flag = false; 3865 } catch (java.lang.RuntimeException $117) { 3866 e = $117; 3867 flag = (e.getMessage()).equals("Negative scale: -8"); 3868 }/* checkscale */ 3869 TestFmwk.assertTrue("ssc100", flag); 3870 try { 3871 (new android.icu.math.BigDecimal(1.0001D)).setScale(3); 3872 flag = false; 3873 } catch (java.lang.RuntimeException $118) { 3874 e = $118; 3875 flag = (e.getMessage()).equals("Rounding necessary"); 3876 }/* checkrunn */ 3877 TestFmwk.assertTrue("ssc101", flag); 3878 try { 3879 (new android.icu.math.BigDecimal(1E-8D)).setScale(3); 3880 flag = false; 3881 } catch (java.lang.RuntimeException $119) { 3882 e = $119; 3883 flag = (e.getMessage()).equals("Rounding necessary"); 3884 }/* checkrunn */ 3885 TestFmwk.assertTrue("ssc102", flag); 3886 } 3887 3888 /* ----------------------------------------------------------------- */ 3889 3890 /** Test the <code>BigDecimal.shortValue()</code> method. */ 3891 3892 @Test 3893 public void diagshortvalue() { 3894 boolean flag = false; 3895 java.lang.String v = null; 3896 java.lang.ArithmeticException ae = null; 3897 java.lang.String badstrings[]; 3898 int i = 0; 3899 java.lang.String norm = null; 3900 3901 TestFmwk.assertTrue("shv002", (((short)0))==((new android.icu.math.BigDecimal("0")).shortValue())); 3902 TestFmwk.assertTrue("shv003", (((short)1))==((new android.icu.math.BigDecimal("1")).shortValue())); 3903 TestFmwk.assertTrue("shv004", (((short)99))==((new android.icu.math.BigDecimal("99")).shortValue())); 3904 TestFmwk.assertTrue("shv006", ((smax))==((new android.icu.math.BigDecimal(smax)).shortValue())); 3905 TestFmwk.assertTrue("shv007", ((smin))==((new android.icu.math.BigDecimal(smin)).shortValue())); 3906 TestFmwk.assertTrue("shv008", ((sneg))==((new android.icu.math.BigDecimal(sneg)).shortValue())); 3907 TestFmwk.assertTrue("shv009", ((szer))==((new android.icu.math.BigDecimal(szer)).shortValue())); 3908 TestFmwk.assertTrue("shv010", ((spos))==((new android.icu.math.BigDecimal(spos)).shortValue())); 3909 TestFmwk.assertTrue("shv011", ((smin))==((new android.icu.math.BigDecimal(smax+1)).shortValue())); 3910 TestFmwk.assertTrue("shv012", ((smax))==((new android.icu.math.BigDecimal(smin-1)).shortValue())); 3911 3912 TestFmwk.assertTrue("shv022", (((short)0))==((new android.icu.math.BigDecimal("0")).shortValueExact())); 3913 TestFmwk.assertTrue("shv023", (((short)1))==((new android.icu.math.BigDecimal("1")).shortValueExact())); 3914 TestFmwk.assertTrue("shv024", (((short)99))==((new android.icu.math.BigDecimal("99")).shortValueExact())); 3915 TestFmwk.assertTrue("shv026", ((smax))==((new android.icu.math.BigDecimal(smax)).shortValueExact())); 3916 TestFmwk.assertTrue("shv027", ((smin))==((new android.icu.math.BigDecimal(smin)).shortValueExact())); 3917 TestFmwk.assertTrue("shv028", ((sneg))==((new android.icu.math.BigDecimal(sneg)).shortValueExact())); 3918 TestFmwk.assertTrue("shv029", ((szer))==((new android.icu.math.BigDecimal(szer)).shortValueExact())); 3919 TestFmwk.assertTrue("shv030", ((spos))==((new android.icu.math.BigDecimal(spos)).shortValueExact())); 3920 try { 3921 v = "-88888888888"; 3922 (new android.icu.math.BigDecimal(v)).shortValueExact(); 3923 flag = false; 3924 } catch (java.lang.ArithmeticException $120) { 3925 ae = $120; 3926 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 3927 } 3928 TestFmwk.assertTrue("shv100", flag); 3929 try { 3930 v = "88888888888"; 3931 (new android.icu.math.BigDecimal(v)).shortValueExact(); 3932 flag = false; 3933 } catch (java.lang.ArithmeticException $121) { 3934 ae = $121; 3935 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 3936 } 3937 TestFmwk.assertTrue("shv101", flag); 3938 try { 3939 v = "1.5"; 3940 (new android.icu.math.BigDecimal(v)).shortValueExact(); 3941 flag = false; 3942 } catch (java.lang.ArithmeticException $122) { 3943 ae = $122; 3944 flag = (ae.getMessage()).equals("Decimal part non-zero:" + " " + v); 3945 } 3946 TestFmwk.assertTrue("shv102", flag); 3947 3948 badstrings = new java.lang.String[] { 3949 "123456", 3950 (new android.icu.math.BigDecimal(smax)).add(one).toString(), 3951 (new android.icu.math.BigDecimal(smin)).subtract(one) 3952 .toString(), 3953 "71111", 3954 "81111", 3955 "91111", 3956 "-71111", 3957 "-81111", 3958 "-91111", 3959 (new android.icu.math.BigDecimal(smin)).multiply(two) 3960 .toString(), 3961 (new android.icu.math.BigDecimal(smax)).multiply(two) 3962 .toString(), 3963 (new android.icu.math.BigDecimal(smin)).multiply(ten) 3964 .toString(), 3965 (new android.icu.math.BigDecimal(smax)).multiply(ten) 3966 .toString(), "-123456" }; // 220 3967 // 221 3968 // 222 3969 // 223 3970 // 224 3971 // 225 3972 // 226 3973 // 227 3974 // 228 3975 // 229 3976 // 230 3977 // 231 3978 // 232 3979 // 233 3980 { 3981 int $123 = badstrings.length; 3982 i = 0; 3983 for (; $123 > 0; $123--, i++) { 3984 try { 3985 v = badstrings[i]; 3986 (new android.icu.math.BigDecimal(v)).shortValueExact(); 3987 flag = false; 3988 } catch (java.lang.ArithmeticException $124) { 3989 ae = $124; 3990 norm = (new android.icu.math.BigDecimal(v)).toString(); 3991 flag = (ae.getMessage()).equals("Conversion overflow:" 3992 + " " + norm); 3993 } 3994 TestFmwk.assertTrue("shv" + (220 + i), flag); 3995 } 3996 }/* i */ 3997 } 3998 3999 /* ----------------------------------------------------------------- */ 4000 4001 /** Test the {@link android.icu.math.BigDecimal#signum} method. */ 4002 4003 @Test 4004 public void diagsignum() { 4005 // necessarily checks some obscure constructions, too 4006 TestFmwk.assertTrue("sig001", (-1)==((new android.icu.math.BigDecimal("-1")).signum())); 4007 TestFmwk.assertTrue("sig002", (-1)==((new android.icu.math.BigDecimal("-0.0010")).signum())); 4008 TestFmwk.assertTrue("sig003", (-1)==((new android.icu.math.BigDecimal("-0.001")).signum())); 4009 TestFmwk.assertTrue("sig004", 0==((new android.icu.math.BigDecimal("-0.00")).signum())); 4010 TestFmwk.assertTrue("sig005", 0==((new android.icu.math.BigDecimal("-0")).signum())); 4011 TestFmwk.assertTrue("sig006", 0==((new android.icu.math.BigDecimal("0")).signum())); 4012 TestFmwk.assertTrue("sig007", 0==((new android.icu.math.BigDecimal("00")).signum())); 4013 TestFmwk.assertTrue("sig008", 0==((new android.icu.math.BigDecimal("00.0")).signum())); 4014 TestFmwk.assertTrue("sig009", 1==((new android.icu.math.BigDecimal("00.01")).signum())); 4015 TestFmwk.assertTrue("sig010", 1==((new android.icu.math.BigDecimal("00.01")).signum())); 4016 TestFmwk.assertTrue("sig011", 1==((new android.icu.math.BigDecimal("00.010")).signum())); 4017 TestFmwk.assertTrue("sig012", 1==((new android.icu.math.BigDecimal("01.01")).signum())); 4018 TestFmwk.assertTrue("sig013", 1==((new android.icu.math.BigDecimal("+0.01")).signum())); 4019 TestFmwk.assertTrue("sig014", 1==((new android.icu.math.BigDecimal("+0.001")).signum())); 4020 TestFmwk.assertTrue("sig015", 1==((new android.icu.math.BigDecimal("1")).signum())); 4021 TestFmwk.assertTrue("sig016", 1==((new android.icu.math.BigDecimal("1e+12")).signum())); 4022 TestFmwk.assertTrue("sig017", 0==((new android.icu.math.BigDecimal("00e+12")).signum())); 4023 } 4024 4025 /* ----------------------------------------------------------------- */ 4026 4027 /** Test the {@link android.icu.math.BigDecimal#toBigDecimal} method. */ 4028 4029 @Test 4030 public void diagtobigdecimal() { 4031 TestFmwk.assertTrue("tbd001", ((new android.icu.math.BigDecimal("0")).toBigDecimal().toString()).equals("0")); 4032 TestFmwk.assertTrue("tbd002", ((new android.icu.math.BigDecimal("-1")).toBigDecimal().toString()).equals("-1")); 4033 TestFmwk.assertTrue("tbd003", ((new android.icu.math.BigDecimal("+1")).toBigDecimal().toString()).equals("1")); 4034 TestFmwk.assertTrue("tbd004", ((new android.icu.math.BigDecimal("1")).toBigDecimal().toString()).equals("1")); 4035 TestFmwk.assertTrue("tbd005", ((new android.icu.math.BigDecimal("1E+2")).toBigDecimal().toString()).equals("100")); 4036 TestFmwk.assertTrue("tbd006", ((new android.icu.math.BigDecimal("1E-2")).toBigDecimal().toString()).equals("0.01")); 4037 if (!isJDK15OrLater) { 4038 TestFmwk.assertTrue("tbd007", ((new android.icu.math.BigDecimal("1E-8")).toBigDecimal().toString()).equals("0.00000001")); 4039 } 4040 if (!isJDK15OrLater) { 4041 TestFmwk.assertTrue("tbd008", ((new android.icu.math.BigDecimal("1E-9")).toBigDecimal().toString()).equals("0.000000001")); 4042 } 4043 TestFmwk.assertTrue("tbd009", ((new android.icu.math.BigDecimal("1E10")).toBigDecimal().toString()).equals("10000000000")); 4044 TestFmwk.assertTrue("tbd010", ((new android.icu.math.BigDecimal("1E12")).toBigDecimal().toString()).equals("1000000000000")); 4045 } 4046 4047 /* ----------------------------------------------------------------- */ 4048 4049 /** Test the {@link android.icu.math.BigDecimal#toBigInteger} method. */ 4050 4051 @Test 4052 public void diagtobiginteger() { 4053 boolean flag = false; 4054 java.lang.String badstrings[]; 4055 int i = 0; 4056 TestFmwk.assertTrue("tbi001", ((new android.icu.math.BigDecimal("-1")).toBigInteger().toString()).equals("-1")); 4057 TestFmwk.assertTrue("tbi002", ((new android.icu.math.BigDecimal("0")).toBigInteger().toString()).equals("0")); 4058 TestFmwk.assertTrue("tbi003", ((new android.icu.math.BigDecimal("+1")).toBigInteger().toString()).equals("1")); 4059 TestFmwk.assertTrue("tbi004", ((new android.icu.math.BigDecimal("10")).toBigInteger().toString()).equals("10")); 4060 TestFmwk.assertTrue("tbi005", ((new android.icu.math.BigDecimal("1000")).toBigInteger().toString()).equals("1000")); 4061 TestFmwk.assertTrue("tbi006", ((new android.icu.math.BigDecimal("-1E+0")).toBigInteger().toString()).equals("-1")); 4062 TestFmwk.assertTrue("tbi007", ((new android.icu.math.BigDecimal("0E+0")).toBigInteger().toString()).equals("0")); 4063 TestFmwk.assertTrue("tbi008", ((new android.icu.math.BigDecimal("+1E+0")).toBigInteger().toString()).equals("1")); 4064 TestFmwk.assertTrue("tbi009", ((new android.icu.math.BigDecimal("10E+0")).toBigInteger().toString()).equals("10")); 4065 TestFmwk.assertTrue("tbi010", ((new android.icu.math.BigDecimal("1E+3")).toBigInteger().toString()).equals("1000")); 4066 TestFmwk.assertTrue("tbi011", ((new android.icu.math.BigDecimal("0.00")).toBigInteger().toString()).equals("0")); 4067 TestFmwk.assertTrue("tbi012", ((new android.icu.math.BigDecimal("0.01")).toBigInteger().toString()).equals("0")); 4068 TestFmwk.assertTrue("tbi013", ((new android.icu.math.BigDecimal("0.0")).toBigInteger().toString()).equals("0")); 4069 TestFmwk.assertTrue("tbi014", ((new android.icu.math.BigDecimal("0.1")).toBigInteger().toString()).equals("0")); 4070 TestFmwk.assertTrue("tbi015", ((new android.icu.math.BigDecimal("-0.00")).toBigInteger().toString()).equals("0")); 4071 TestFmwk.assertTrue("tbi016", ((new android.icu.math.BigDecimal("-0.01")).toBigInteger().toString()).equals("0")); 4072 TestFmwk.assertTrue("tbi017", ((new android.icu.math.BigDecimal("-0.0")).toBigInteger().toString()).equals("0")); 4073 TestFmwk.assertTrue("tbi018", ((new android.icu.math.BigDecimal("-0.1")).toBigInteger().toString()).equals("0")); 4074 TestFmwk.assertTrue("tbi019", ((new android.icu.math.BigDecimal("1.00")).toBigInteger().toString()).equals("1")); 4075 TestFmwk.assertTrue("tbi020", ((new android.icu.math.BigDecimal("1.01")).toBigInteger().toString()).equals("1")); 4076 TestFmwk.assertTrue("tbi021", ((new android.icu.math.BigDecimal("1.0")).toBigInteger().toString()).equals("1")); 4077 TestFmwk.assertTrue("tbi022", ((new android.icu.math.BigDecimal("1.1")).toBigInteger().toString()).equals("1")); 4078 TestFmwk.assertTrue("tbi023", ((new android.icu.math.BigDecimal("-1.00")).toBigInteger().toString()).equals("-1")); 4079 TestFmwk.assertTrue("tbi024", ((new android.icu.math.BigDecimal("-1.01")).toBigInteger().toString()).equals("-1")); 4080 TestFmwk.assertTrue("tbi025", ((new android.icu.math.BigDecimal("-1.0")).toBigInteger().toString()).equals("-1")); 4081 TestFmwk.assertTrue("tbi026", ((new android.icu.math.BigDecimal("-1.1")).toBigInteger().toString()).equals("-1")); 4082 TestFmwk.assertTrue("tbi027", ((new android.icu.math.BigDecimal("-111.111")).toBigInteger().toString()).equals("-111")); 4083 TestFmwk.assertTrue("tbi028", ((new android.icu.math.BigDecimal("+111.111")).toBigInteger().toString()).equals("111")); 4084 TestFmwk.assertTrue("tbi029", ((new android.icu.math.BigDecimal("0.09")).toBigInteger().toString()).equals("0")); 4085 TestFmwk.assertTrue("tbi030", ((new android.icu.math.BigDecimal("0.9")).toBigInteger().toString()).equals("0")); 4086 TestFmwk.assertTrue("tbi031", ((new android.icu.math.BigDecimal("1.09")).toBigInteger().toString()).equals("1")); 4087 TestFmwk.assertTrue("tbi032", ((new android.icu.math.BigDecimal("1.05")).toBigInteger().toString()).equals("1")); 4088 TestFmwk.assertTrue("tbi033", ((new android.icu.math.BigDecimal("1.04")).toBigInteger().toString()).equals("1")); 4089 TestFmwk.assertTrue("tbi034", ((new android.icu.math.BigDecimal("1.99")).toBigInteger().toString()).equals("1")); 4090 TestFmwk.assertTrue("tbi034", ((new android.icu.math.BigDecimal("1.9")).toBigInteger().toString()).equals("1")); 4091 TestFmwk.assertTrue("tbi035", ((new android.icu.math.BigDecimal("1.5")).toBigInteger().toString()).equals("1")); 4092 TestFmwk.assertTrue("tbi036", ((new android.icu.math.BigDecimal("1.4")).toBigInteger().toString()).equals("1")); 4093 TestFmwk.assertTrue("tbi037", ((new android.icu.math.BigDecimal("-1.09")).toBigInteger().toString()).equals("-1")); 4094 TestFmwk.assertTrue("tbi038", ((new android.icu.math.BigDecimal("-1.05")).toBigInteger().toString()).equals("-1")); 4095 TestFmwk.assertTrue("tbi039", ((new android.icu.math.BigDecimal("-1.04")).toBigInteger().toString()).equals("-1")); 4096 TestFmwk.assertTrue("tbi040", ((new android.icu.math.BigDecimal("-1.99")).toBigInteger().toString()).equals("-1")); 4097 TestFmwk.assertTrue("tbi041", ((new android.icu.math.BigDecimal("-1.9")).toBigInteger().toString()).equals("-1")); 4098 TestFmwk.assertTrue("tbi042", ((new android.icu.math.BigDecimal("-1.5")).toBigInteger().toString()).equals("-1")); 4099 TestFmwk.assertTrue("tbi043", ((new android.icu.math.BigDecimal("-1.4")).toBigInteger().toString()).equals("-1")); 4100 TestFmwk.assertTrue("tbi044", ((new android.icu.math.BigDecimal("1E-1000")).toBigInteger().toString()).equals("0")); 4101 TestFmwk.assertTrue("tbi045", ((new android.icu.math.BigDecimal("-1E-1000")).toBigInteger().toString()).equals("0")); 4102 4103 // Exact variety -- 4104 TestFmwk.assertTrue("tbi101", ((new android.icu.math.BigDecimal("-1")).toBigIntegerExact().toString()).equals("-1")); 4105 TestFmwk.assertTrue("tbi102", ((new android.icu.math.BigDecimal("0")).toBigIntegerExact().toString()).equals("0")); 4106 TestFmwk.assertTrue("tbi103", ((new android.icu.math.BigDecimal("+1")).toBigIntegerExact().toString()).equals("1")); 4107 TestFmwk.assertTrue("tbi104", ((new android.icu.math.BigDecimal("10")).toBigIntegerExact().toString()).equals("10")); 4108 TestFmwk.assertTrue("tbi105", ((new android.icu.math.BigDecimal("1000")).toBigIntegerExact().toString()).equals("1000")); 4109 TestFmwk.assertTrue("tbi106", ((new android.icu.math.BigDecimal("-1E+0")).toBigIntegerExact().toString()).equals("-1")); 4110 TestFmwk.assertTrue("tbi107", ((new android.icu.math.BigDecimal("0E+0")).toBigIntegerExact().toString()).equals("0")); 4111 TestFmwk.assertTrue("tbi108", ((new android.icu.math.BigDecimal("+1E+0")).toBigIntegerExact().toString()).equals("1")); 4112 TestFmwk.assertTrue("tbi109", ((new android.icu.math.BigDecimal("10E+0")).toBigIntegerExact().toString()).equals("10")); 4113 TestFmwk.assertTrue("tbi110", ((new android.icu.math.BigDecimal("1E+3")).toBigIntegerExact().toString()).equals("1000")); 4114 TestFmwk.assertTrue("tbi111", ((new android.icu.math.BigDecimal("0.00")).toBigIntegerExact().toString()).equals("0")); 4115 TestFmwk.assertTrue("tbi112", ((new android.icu.math.BigDecimal("0.0")).toBigIntegerExact().toString()).equals("0")); 4116 TestFmwk.assertTrue("tbi113", ((new android.icu.math.BigDecimal("-0.00")).toBigIntegerExact().toString()).equals("0")); 4117 TestFmwk.assertTrue("tbi114", ((new android.icu.math.BigDecimal("-0.0")).toBigIntegerExact().toString()).equals("0")); 4118 TestFmwk.assertTrue("tbi115", ((new android.icu.math.BigDecimal("1.00")).toBigIntegerExact().toString()).equals("1")); 4119 TestFmwk.assertTrue("tbi116", ((new android.icu.math.BigDecimal("1.0")).toBigIntegerExact().toString()).equals("1")); 4120 TestFmwk.assertTrue("tbi117", ((new android.icu.math.BigDecimal("-1.00")).toBigIntegerExact().toString()).equals("-1")); 4121 TestFmwk.assertTrue("tbi118", ((new android.icu.math.BigDecimal("-1.0")).toBigIntegerExact().toString()).equals("-1")); 4122 TestFmwk.assertTrue("tbi119", ((new android.icu.math.BigDecimal("1.00000000000000000000000000000")).toBigIntegerExact().toString()).equals("1")); 4123 4124 4125 // the following should all raise exceptions 4126 4127 badstrings = new java.lang.String[] { "0.09", "0.9", "0.01", "0.1", 4128 "-0.01", "-0.1", "1.01", "-1.01", "-1.1", "-111.111", 4129 "+111.111", "1.09", "1.05", "1.04", "1.99", "1.9", "1.5", 4130 "1.4", "-1.09", "-1.05", "-1.04", "-1.99", "-1.9", "-1.5", 4131 "-1.4", "1E-1000", "-1E-1000", "11E-1", "1.1", 4132 "127623156123656561356123512315631231551312356.000001", 4133 "0.000000000000000000000000000000000000000000000001" }; // 300-303 4134 // 304-307 4135 // 308-311 4136 // 312-316 4137 // 317-320 4138 // 321-324 4139 // 325-328 4140 // 329 4141 // 330 4142 4143 { 4144 int $125 = badstrings.length; 4145 i = 0; 4146 for (; $125 > 0; $125--, i++) { 4147 try { 4148 (new android.icu.math.BigDecimal(badstrings[i])) 4149 .toBigIntegerExact(); 4150 flag = false; 4151 } catch (java.lang.ArithmeticException $126) { 4152 flag = true; 4153 } 4154 TestFmwk.assertTrue("tbi" + (300 + i), flag); 4155 } 4156 }/* i */ 4157 } 4158 4159 /* ----------------------------------------------------------------- */ 4160 4161 /** Test the {@link android.icu.math.BigDecimal#toCharArray} method. */ 4162 4163 @Test 4164 public void diagtochararray() { 4165 java.lang.String str; 4166 char car[]; 4167 android.icu.math.BigDecimal d; 4168 char ca[]; 4169 // the function of this has been tested above, this is simply an 4170 // existence proof and type-check 4171 str = "-123.45"; 4172 car = (str).toCharArray(); 4173 d = new android.icu.math.BigDecimal(str); 4174 ca = d.toCharArray(); 4175 TestFmwk.assertTrue("tca001", ca.length == car.length); 4176 TestFmwk.assertTrue("tca002", (new java.lang.String(ca)) 4177 .equals((new java.lang.String(car)))); 4178 TestFmwk.assertTrue("tca003", (d.toCharArray() instanceof char[])); 4179 TestFmwk.assertTrue("tca004", (ca instanceof char[])); 4180 } 4181 4182 /* ----------------------------------------------------------------- */ 4183 4184 /** Test the {@link android.icu.math.BigDecimal#toString} method. */ 4185 4186 @Test 4187 public void diagtostring() { 4188 java.lang.String str; 4189 char car[]; 4190 android.icu.math.BigDecimal d; 4191 char ca[]; 4192 java.lang.String cs; 4193 // the function of this has been tested above, this is simply an 4194 // existence proof and type-check 4195 str = "123.45"; 4196 car = (str).toCharArray(); 4197 d = new android.icu.math.BigDecimal(car, 0, car.length); 4198 ca = d.toCharArray(); 4199 cs = d.toString(); 4200 TestFmwk.assertTrue("tos001", (str.toCharArray().length) == ca.length); 4201 TestFmwk.assertTrue("tos002", (str.length()) == (cs.length())); 4202 TestFmwk.assertTrue("tos003", str.equals((new java.lang.String(ca)))); 4203 TestFmwk.assertTrue("tos004", str.equals(cs)); 4204 TestFmwk.assertTrue("tos005", (cs instanceof java.lang.String)); 4205 TestFmwk.assertTrue("tos006", (d.toString() instanceof java.lang.String)); 4206 } 4207 4208 /* ----------------------------------------------------------------- */ 4209 4210 /** Test the {@link android.icu.math.BigDecimal#unscaledValue} method. */ 4211 4212 @Test 4213 public void diagunscaledvalue() { 4214 // just like toBigInteger, but scaly bits are preserved [without dots] 4215 TestFmwk.assertTrue("uns001", ((new android.icu.math.BigDecimal("-1")).unscaledValue().toString()).equals("-1")); 4216 TestFmwk.assertTrue("uns002", ((new android.icu.math.BigDecimal("0")).unscaledValue().toString()).equals("0")); 4217 TestFmwk.assertTrue("uns003", ((new android.icu.math.BigDecimal("+1")).unscaledValue().toString()).equals("1")); 4218 TestFmwk.assertTrue("uns004", ((new android.icu.math.BigDecimal("10")).unscaledValue().toString()).equals("10")); 4219 TestFmwk.assertTrue("uns005", ((new android.icu.math.BigDecimal("1000")).unscaledValue().toString()).equals("1000")); 4220 TestFmwk.assertTrue("uns006", ((new android.icu.math.BigDecimal("-1E+0")).unscaledValue().toString()).equals("-1")); 4221 TestFmwk.assertTrue("uns007", ((new android.icu.math.BigDecimal("0E+0")).unscaledValue().toString()).equals("0")); 4222 TestFmwk.assertTrue("uns008", ((new android.icu.math.BigDecimal("+1E+0")).unscaledValue().toString()).equals("1")); 4223 TestFmwk.assertTrue("uns009", ((new android.icu.math.BigDecimal("10E+0")).unscaledValue().toString()).equals("10")); 4224 TestFmwk.assertTrue("uns010", ((new android.icu.math.BigDecimal("1E+3")).unscaledValue().toString()).equals("1000")); 4225 TestFmwk.assertTrue("uns011", ((new android.icu.math.BigDecimal("0.00")).unscaledValue().toString()).equals("0")); 4226 TestFmwk.assertTrue("uns012", ((new android.icu.math.BigDecimal("0.01")).unscaledValue().toString()).equals("1")); 4227 TestFmwk.assertTrue("uns013", ((new android.icu.math.BigDecimal("0.0")).unscaledValue().toString()).equals("0")); 4228 TestFmwk.assertTrue("uns014", ((new android.icu.math.BigDecimal("0.1")).unscaledValue().toString()).equals("1")); 4229 TestFmwk.assertTrue("uns015", ((new android.icu.math.BigDecimal("-0.00")).unscaledValue().toString()).equals("0")); 4230 TestFmwk.assertTrue("uns016", ((new android.icu.math.BigDecimal("-0.01")).unscaledValue().toString()).equals("-1")); 4231 TestFmwk.assertTrue("uns017", ((new android.icu.math.BigDecimal("-0.0")).unscaledValue().toString()).equals("0")); 4232 TestFmwk.assertTrue("uns018", ((new android.icu.math.BigDecimal("-0.1")).unscaledValue().toString()).equals("-1")); 4233 TestFmwk.assertTrue("uns019", ((new android.icu.math.BigDecimal("1.00")).unscaledValue().toString()).equals("100")); 4234 TestFmwk.assertTrue("uns020", ((new android.icu.math.BigDecimal("1.01")).unscaledValue().toString()).equals("101")); 4235 TestFmwk.assertTrue("uns021", ((new android.icu.math.BigDecimal("1.0")).unscaledValue().toString()).equals("10")); 4236 TestFmwk.assertTrue("uns022", ((new android.icu.math.BigDecimal("1.1")).unscaledValue().toString()).equals("11")); 4237 TestFmwk.assertTrue("uns023", ((new android.icu.math.BigDecimal("-1.00")).unscaledValue().toString()).equals("-100")); 4238 TestFmwk.assertTrue("uns024", ((new android.icu.math.BigDecimal("-1.01")).unscaledValue().toString()).equals("-101")); 4239 TestFmwk.assertTrue("uns025", ((new android.icu.math.BigDecimal("-1.0")).unscaledValue().toString()).equals("-10")); 4240 TestFmwk.assertTrue("uns026", ((new android.icu.math.BigDecimal("-1.1")).unscaledValue().toString()).equals("-11")); 4241 TestFmwk.assertTrue("uns027", ((new android.icu.math.BigDecimal("-111.111")).unscaledValue().toString()).equals("-111111")); 4242 TestFmwk.assertTrue("uns028", ((new android.icu.math.BigDecimal("+111.111")).unscaledValue().toString()).equals("111111")); 4243 } 4244 4245 /* ----------------------------------------------------------------- */ 4246 4247 /** 4248 * Test the {@link android.icu.math.BigDecimal#valueOf} method [long and 4249 * double]. 4250 */ 4251 4252 @Test 4253 public void diagvalueof() { 4254 boolean flag = false; 4255 java.lang.NumberFormatException e = null; 4256 double dzer; 4257 double dpos; 4258 double dneg; 4259 double dpos5; 4260 double dneg5; 4261 double dmin; 4262 double dmax; 4263 double d; 4264 4265 // valueOf(long [,scale]) -- 4266 4267 TestFmwk.assertTrue("val001", (android.icu.math.BigDecimal.valueOf(((byte)-2)).toString()).equals("-2")); 4268 TestFmwk.assertTrue("val002", (android.icu.math.BigDecimal.valueOf(((byte)-1)).toString()).equals("-1")); 4269 TestFmwk.assertTrue("val003", (android.icu.math.BigDecimal.valueOf(((byte)-0)).toString()).equals("0")); 4270 TestFmwk.assertTrue("val004", (android.icu.math.BigDecimal.valueOf(((byte)+1)).toString()).equals("1")); 4271 TestFmwk.assertTrue("val005", (android.icu.math.BigDecimal.valueOf(((byte)+2)).toString()).equals("2")); 4272 TestFmwk.assertTrue("val006", (android.icu.math.BigDecimal.valueOf(((byte)10)).toString()).equals("10")); 4273 TestFmwk.assertTrue("val007", (android.icu.math.BigDecimal.valueOf(((byte)11)).toString()).equals("11")); 4274 TestFmwk.assertTrue("val008", (android.icu.math.BigDecimal.valueOf(lmin).toString()).equals("-9223372036854775808")); 4275 TestFmwk.assertTrue("val009", (android.icu.math.BigDecimal.valueOf(lmax).toString()).equals("9223372036854775807")); 4276 TestFmwk.assertTrue("val010", (android.icu.math.BigDecimal.valueOf(lneg).toString()).equals("-1")); 4277 TestFmwk.assertTrue("val011", (android.icu.math.BigDecimal.valueOf(lzer).toString()).equals("0")); 4278 TestFmwk.assertTrue("val012", (android.icu.math.BigDecimal.valueOf(lpos).toString()).equals("1")); 4279 TestFmwk.assertTrue("val013", (android.icu.math.BigDecimal.valueOf(lmin,0).toString()).equals("-9223372036854775808")); 4280 TestFmwk.assertTrue("val014", (android.icu.math.BigDecimal.valueOf(lmax,0).toString()).equals("9223372036854775807")); 4281 TestFmwk.assertTrue("val015", (android.icu.math.BigDecimal.valueOf(lneg,0).toString()).equals("-1")); 4282 TestFmwk.assertTrue("val016", (android.icu.math.BigDecimal.valueOf(lpos,0).toString()).equals("1")); 4283 4284 TestFmwk.assertTrue("val017", (android.icu.math.BigDecimal.valueOf(lzer,0).toString()).equals("0")); 4285 TestFmwk.assertTrue("val018", (android.icu.math.BigDecimal.valueOf(lzer,1).toString()).equals("0.0")); 4286 TestFmwk.assertTrue("val019", (android.icu.math.BigDecimal.valueOf(lzer,2).toString()).equals("0.00")); 4287 TestFmwk.assertTrue("val020", (android.icu.math.BigDecimal.valueOf(lzer,3).toString()).equals("0.000")); 4288 TestFmwk.assertTrue("val021", (android.icu.math.BigDecimal.valueOf(lzer,10).toString()).equals("0.0000000000")); 4289 4290 TestFmwk.assertTrue("val022", (android.icu.math.BigDecimal.valueOf(lmin,7).toString()).equals("-922337203685.4775808")); 4291 TestFmwk.assertTrue("val023", (android.icu.math.BigDecimal.valueOf(lmax,11).toString()).equals("92233720.36854775807")); 4292 4293 try { 4294 android.icu.math.BigDecimal.valueOf(23, -8); 4295 flag = false; 4296 } catch (java.lang.NumberFormatException $127) { 4297 e = $127; 4298 flag = (e.getMessage()).equals("Negative scale: -8"); 4299 }/* checkscale */ 4300 TestFmwk.assertTrue("val100", flag); 4301 4302 // valueOf(double) -- 4303 4304 dzer = 0; 4305 dpos = 1; 4306 dpos = dpos / (10); 4307 dneg = -dpos; 4308 TestFmwk.assertTrue("val201", (android.icu.math.BigDecimal.valueOf(dneg).toString()).equals("-0.1")); 4309 TestFmwk.assertTrue("val202", (android.icu.math.BigDecimal.valueOf(dzer).toString()).equals("0.0")); // cf. constructor 4310 TestFmwk.assertTrue("val203", (android.icu.math.BigDecimal.valueOf(dpos).toString()).equals("0.1")); 4311 dpos5 = 0.5D; 4312 dneg5 = -dpos5; 4313 TestFmwk.assertTrue("val204", (android.icu.math.BigDecimal.valueOf(dneg5).toString()).equals("-0.5")); 4314 TestFmwk.assertTrue("val205", (android.icu.math.BigDecimal.valueOf(dpos5).toString()).equals("0.5")); 4315 dmin = java.lang.Double.MIN_VALUE; 4316 dmax = java.lang.Double.MAX_VALUE; 4317 TestFmwk.assertTrue("val206", (android.icu.math.BigDecimal.valueOf(dmin).toString()).equals("4.9E-324")); 4318 TestFmwk.assertTrue("val207", (android.icu.math.BigDecimal.valueOf(dmax).toString()).equals("1.7976931348623157E+308")); 4319 4320 // nasties 4321 d = 9; 4322 d = d / (10); 4323 TestFmwk.assertTrue("val210", (android.icu.math.BigDecimal.valueOf(d).toString()).equals("0.9")); 4324 d = d / (10); 4325 TestFmwk.assertTrue("val211", (android.icu.math.BigDecimal.valueOf(d).toString()).equals("0.09")); 4326 d = d / (10); 4327 // The primitive double 0.009 is different in OpenJDK. In Oracle/IBM java <= 6, there is a trailing 0 (e.g 0.0090). 4328 String s = android.icu.math.BigDecimal.valueOf(d).toString(); 4329 TestFmwk.assertTrue("val212", s.equals("0.0090") || s.equals("0.009")); 4330 d = d / (10); 4331 TestFmwk.assertTrue("val213", (android.icu.math.BigDecimal.valueOf(d).toString()).equals("9.0E-4")); 4332 d = d / (10); 4333 TestFmwk.assertTrue("val214", (android.icu.math.BigDecimal.valueOf(d).toString()).equals("8.999999999999999E-5")); 4334 d = d / (10); 4335 TestFmwk.assertTrue("val215", (android.icu.math.BigDecimal.valueOf(d).toString()).equals("8.999999999999999E-6")); 4336 d = d / (10); 4337 TestFmwk.assertTrue("val216", (android.icu.math.BigDecimal.valueOf(d).toString()).equals("8.999999999999999E-7")); 4338 d = d / (10); 4339 TestFmwk.assertTrue("val217", (android.icu.math.BigDecimal.valueOf(d).toString()).equals("8.999999999999999E-8")); 4340 d = d / (10); 4341 TestFmwk.assertTrue("val218", (android.icu.math.BigDecimal.valueOf(d).toString()).equals("8.999999999999998E-9")); 4342 4343 try { 4344 android.icu.math.BigDecimal 4345 .valueOf(java.lang.Double.POSITIVE_INFINITY); 4346 flag = false; 4347 } catch (java.lang.NumberFormatException $128) { 4348 flag = true; 4349 }/* checkpin */ 4350 TestFmwk.assertTrue("val301", flag); 4351 try { 4352 android.icu.math.BigDecimal 4353 .valueOf(java.lang.Double.NEGATIVE_INFINITY); 4354 flag = false; 4355 } catch (java.lang.NumberFormatException $129) { 4356 flag = true; 4357 }/* checknin */ 4358 TestFmwk.assertTrue("val302", flag); 4359 try { 4360 android.icu.math.BigDecimal.valueOf(java.lang.Double.NaN); 4361 flag = false; 4362 } catch (java.lang.NumberFormatException $130) { 4363 flag = true; 4364 }/* checknan */ 4365 TestFmwk.assertTrue("val303", flag); 4366 } 4367 4368 /* ----------------------------------------------------------------- */ 4369 4370 /** Test the {@link android.icu.math.MathContext} class. */ 4371 4372 @Test 4373 public void diagmathcontext() { 4374 android.icu.math.MathContext mccon1; 4375 android.icu.math.MathContext mccon2; 4376 android.icu.math.MathContext mccon3; 4377 android.icu.math.MathContext mccon4; 4378 android.icu.math.MathContext mcrmc; 4379 android.icu.math.MathContext mcrmd; 4380 android.icu.math.MathContext mcrmf; 4381 android.icu.math.MathContext mcrmhd; 4382 android.icu.math.MathContext mcrmhe; 4383 android.icu.math.MathContext mcrmhu; 4384 android.icu.math.MathContext mcrmun; 4385 android.icu.math.MathContext mcrmu; 4386 boolean flag = false; 4387 java.lang.IllegalArgumentException e = null; 4388 // these tests are mostly existence checks 4389 TestFmwk.assertTrue("mcn001", (android.icu.math.MathContext.DEFAULT.getDigits())==9); 4390 TestFmwk.assertTrue("mcn002", (android.icu.math.MathContext.DEFAULT.getForm())==android.icu.math.MathContext.SCIENTIFIC); 4391 TestFmwk.assertTrue("mcn003", (android.icu.math.MathContext.DEFAULT.getForm())!=android.icu.math.MathContext.ENGINEERING); 4392 TestFmwk.assertTrue("mcn004", (android.icu.math.MathContext.DEFAULT.getForm())!=android.icu.math.MathContext.PLAIN); 4393 TestFmwk.assertTrue("mcn005", (android.icu.math.MathContext.DEFAULT.getLostDigits()?1:0)==0); 4394 TestFmwk.assertTrue("mcn006", (android.icu.math.MathContext.DEFAULT.getRoundingMode())==android.icu.math.MathContext.ROUND_HALF_UP); 4395 4396 TestFmwk.assertTrue("mcn010", android.icu.math.MathContext.ROUND_CEILING>=0); 4397 TestFmwk.assertTrue("mcn011", android.icu.math.MathContext.ROUND_DOWN>=0); 4398 TestFmwk.assertTrue("mcn012", android.icu.math.MathContext.ROUND_FLOOR>=0); 4399 TestFmwk.assertTrue("mcn013", android.icu.math.MathContext.ROUND_HALF_DOWN>=0); 4400 TestFmwk.assertTrue("mcn014", android.icu.math.MathContext.ROUND_HALF_EVEN>=0); 4401 TestFmwk.assertTrue("mcn015", android.icu.math.MathContext.ROUND_HALF_UP>=0); 4402 TestFmwk.assertTrue("mcn016", android.icu.math.MathContext.ROUND_UNNECESSARY>=0); 4403 TestFmwk.assertTrue("mcn017", android.icu.math.MathContext.ROUND_UP>=0); 4404 4405 mccon1=new android.icu.math.MathContext(111); 4406 TestFmwk.assertTrue("mcn021", (mccon1.getDigits())==111); 4407 TestFmwk.assertTrue("mcn022", (mccon1.getForm())==android.icu.math.MathContext.SCIENTIFIC); 4408 TestFmwk.assertTrue("mcn023", (mccon1.getLostDigits()?1:0)==0); 4409 TestFmwk.assertTrue("mcn024", (mccon1.getRoundingMode())==android.icu.math.MathContext.ROUND_HALF_UP); 4410 4411 mccon2=new android.icu.math.MathContext(78,android.icu.math.MathContext.ENGINEERING); 4412 TestFmwk.assertTrue("mcn031", (mccon2.getDigits())==78); 4413 TestFmwk.assertTrue("mcn032", (mccon2.getForm())==android.icu.math.MathContext.ENGINEERING); 4414 TestFmwk.assertTrue("mcn033", (mccon2.getLostDigits()?1:0)==0); 4415 TestFmwk.assertTrue("mcn034", (mccon2.getRoundingMode())==android.icu.math.MathContext.ROUND_HALF_UP); 4416 4417 mccon3=new android.icu.math.MathContext(5,android.icu.math.MathContext.PLAIN,true); 4418 TestFmwk.assertTrue("mcn041", (mccon3.getDigits())==5); 4419 TestFmwk.assertTrue("mcn042", (mccon3.getForm())==android.icu.math.MathContext.PLAIN); 4420 TestFmwk.assertTrue("mcn043", (mccon3.getLostDigits()?1:0)==1); 4421 TestFmwk.assertTrue("mcn044", (mccon3.getRoundingMode())==android.icu.math.MathContext.ROUND_HALF_UP); 4422 4423 mccon4=new android.icu.math.MathContext(0,android.icu.math.MathContext.SCIENTIFIC,false,android.icu.math.MathContext.ROUND_FLOOR); 4424 TestFmwk.assertTrue("mcn051", (mccon4.getDigits()) == 0); 4425 TestFmwk.assertTrue("mcn052", (mccon4.getForm()) == android.icu.math.MathContext.SCIENTIFIC); 4426 TestFmwk.assertTrue("mcn053", (mccon4.getLostDigits() ? 1 : 0) == 0); 4427 TestFmwk.assertTrue("mcn054", (mccon4.getRoundingMode()) == android.icu.math.MathContext.ROUND_FLOOR); 4428 4429 TestFmwk.assertTrue("mcn061", (mccon1.toString()).equals("digits=111 form=SCIENTIFIC lostDigits=0 roundingMode=ROUND_HALF_UP")); 4430 4431 TestFmwk.assertTrue("mcn062", (mccon2.toString()).equals("digits=78 form=ENGINEERING lostDigits=0 roundingMode=ROUND_HALF_UP")); 4432 4433 TestFmwk.assertTrue("mcn063", (mccon3.toString()).equals("digits=5 form=PLAIN lostDigits=1 roundingMode=ROUND_HALF_UP")); 4434 4435 TestFmwk.assertTrue("mcn064", (mccon4.toString()).equals("digits=0 form=SCIENTIFIC lostDigits=0 roundingMode=ROUND_FLOOR")); 4436 4437 // complete testing rounding modes round trips 4438 mcrmc=new android.icu.math.MathContext(0,android.icu.math.MathContext.PLAIN,false,android.icu.math.MathContext.ROUND_CEILING); 4439 mcrmd=new android.icu.math.MathContext(0,android.icu.math.MathContext.PLAIN,false,android.icu.math.MathContext.ROUND_DOWN); 4440 mcrmf=new android.icu.math.MathContext(0,android.icu.math.MathContext.PLAIN,false,android.icu.math.MathContext.ROUND_FLOOR); 4441 mcrmhd=new android.icu.math.MathContext(0,android.icu.math.MathContext.PLAIN,false,android.icu.math.MathContext.ROUND_HALF_DOWN); 4442 mcrmhe=new android.icu.math.MathContext(0,android.icu.math.MathContext.PLAIN,false,android.icu.math.MathContext.ROUND_HALF_EVEN); 4443 mcrmhu=new android.icu.math.MathContext(0,android.icu.math.MathContext.PLAIN,false,android.icu.math.MathContext.ROUND_HALF_UP); 4444 mcrmun=new android.icu.math.MathContext(0,android.icu.math.MathContext.PLAIN,false,android.icu.math.MathContext.ROUND_UNNECESSARY); 4445 mcrmu=new android.icu.math.MathContext(0,android.icu.math.MathContext.PLAIN,false,android.icu.math.MathContext.ROUND_UP); 4446 4447 TestFmwk.assertTrue("mcn071", (mcrmc.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_CEILING")); 4448 4449 TestFmwk.assertTrue("mcn072", (mcrmd.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_DOWN")); 4450 4451 TestFmwk.assertTrue("mcn073", (mcrmf.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_FLOOR")); 4452 4453 TestFmwk.assertTrue("mcn074", (mcrmhd.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_HALF_DOWN")); 4454 4455 TestFmwk.assertTrue("mcn075", (mcrmhe.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_HALF_EVEN")); 4456 4457 TestFmwk.assertTrue("mcn076", (mcrmhu.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_HALF_UP")); 4458 4459 TestFmwk.assertTrue("mcn077", (mcrmun.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_UNNECESSARY")); 4460 4461 TestFmwk.assertTrue("mcn078", (mcrmu.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_UP")); 4462 4463 // [get methods tested already] 4464 4465 // errors... 4466 4467 try { 4468 new android.icu.math.MathContext(-1); 4469 flag = false; 4470 } catch (java.lang.IllegalArgumentException $131) { 4471 e = $131; 4472 flag = (e.getMessage()).equals("Digits too small: -1"); 4473 }/* checkdig */ 4474 TestFmwk.assertTrue("mcn101", flag); 4475 try { 4476 new android.icu.math.MathContext(1000000000); 4477 flag = false; 4478 } catch (java.lang.IllegalArgumentException $132) { 4479 e = $132; 4480 flag = (e.getMessage()).equals("Digits too large: 1000000000"); 4481 }/* checkdigbig */ 4482 TestFmwk.assertTrue("mcn102", flag); 4483 4484 try { 4485 new android.icu.math.MathContext(0, 5); 4486 flag = false; 4487 } catch (java.lang.IllegalArgumentException $133) { 4488 e = $133; 4489 flag = (e.getMessage()).equals("Bad form value: 5"); 4490 }/* checkform */ 4491 TestFmwk.assertTrue("mcn111", flag); 4492 try { 4493 new android.icu.math.MathContext(0, -1); 4494 flag = false; 4495 } catch (java.lang.IllegalArgumentException $134) { 4496 e = $134; 4497 flag = (e.getMessage()).equals("Bad form value: -1"); 4498 }/* checkformneg */ 4499 TestFmwk.assertTrue("mcn112", flag); 4500 4501 // [lostDigits cannot be invalid] 4502 4503 try { 4504 new android.icu.math.MathContext(0, 4505 android.icu.math.MathContext.PLAIN, false, 12); 4506 flag = false; 4507 } catch (java.lang.IllegalArgumentException $135) { 4508 e = $135; 4509 flag = (e.getMessage()).equals("Bad roundingMode value: 12"); 4510 }/* checkround */ 4511 TestFmwk.assertTrue("mcn121", flag); 4512 try { 4513 new android.icu.math.MathContext(0, 4514 android.icu.math.MathContext.PLAIN, false, -1); 4515 flag = false; 4516 } catch (java.lang.IllegalArgumentException $136) { 4517 e = $136; 4518 flag = (e.getMessage()).equals("Bad roundingMode value: -1"); 4519 }/* checkroundneg */ 4520 TestFmwk.assertTrue("mcn122", flag); 4521 } 4522 4523 /* ----------------------------------------------------------------- */ 4524 4525 /** 4526 * Test general arithmetic (base operators). 4527 * <p> 4528 * Unlike the specific method tests, these tests were randomly generated by 4529 * an IBM Object Rexx procedure, then manually corrected for known 4530 * differences from ANSI X3-274. These differences are: 4531 * <ol> 4532 * <li>the trigger point in exponential notation is fixed in ANSI X3-274 4533 * but varies with DIGITS in Classic and Object Rexx 4534 * <li>some trailing zeros were missing (e.g., 1.3 + 1E-60 should show 4535 * seven trailing zeros) 4536 * <li>the power operator is less accurate in Object Rexx 4537 * <li>ANSI X3-274 [errata 1999] rounds input numbers to DIGITS (rather 4538 * than truncating to DIGITS+1). 4539 * </ol> 4540 */ 4541 4542 @Test 4543 public void diagmath() { 4544 android.icu.math.MathContext def; 4545 def = android.icu.math.MathContext.DEFAULT; 4546 mathtest(1,def,"-9375284.42","5516.99832E+27276984","5.51699832E+27276987","-5.51699832E+27276987","-5.17234284E+27276994","-1.69934516E-27276981","0","-9375284.42","6.79057752E+41"); 4547 mathtest(2,def,"-410.832710","99.3588243E-502740862","-410.832710","-410.832710","-4.08198550E-502740858","-4.13483868E+502740862","","","1.36977786E+26"); 4548 mathtest(3,def,"80025.2340","-8.03097581","80017.2030","80033.2650","-642680.718","-9964.57167","-9964","4.59102916","5.94544517E-40"); 4549 mathtest(4,def,"81052020.2","-464525495","-383473475","545577515","-3.76507298E+16","-0.17448347","0","81052020.2",""); 4550 mathtest(5,def,"715.069294E-26923151","85.4404128E+796388557","8.54404128E+796388558","-8.54404128E+796388558","6.10958157E+769465410","8.36921628E-823311708","0","7.15069294E-26923149","4.88802213E-242308334"); 4551 mathtest(6,def,"-21971575.0E+31454441","-70944960.3E+111238221","-7.09449603E+111238228","7.09449603E+111238228","1.55877252E+142692677","3.09698884E-79783781","0","-2.19715750E+31454448","-4.04549502E-220181139"); 4552 mathtest(7,def,"682.25316","54470185.6","54470867.9","-54469503.4","3.71624563E+10","0.0000125252586","0","682.25316","3.48578699E+154365541"); 4553 mathtest(8,def,"-257586757.","2082888.71","-255503868","-259669646","-5.36524548E+14","-123.668036","-123","-1391445.67","-1.26879515E+17519020"); 4554 mathtest(9,def,"319577540.E+242599761","60.7124561","3.19577540E+242599769","3.19577540E+242599769","1.94023374E+242599771","5.26378869E+242599767","","",""); 4555 mathtest(10,def,"-13769977.0","24371.3381","-13745605.7","-13794348.3","-3.35592765E+11","-565.007015","-565","-170.9735","-8.73734001E+173982"); 4556 mathtest(11,def,"-475.434972E-725464311","-3.22214066E-865476836","-4.75434972E-725464309","-4.75434972E-725464309","","1.47552519E+140012527","","",""); 4557 mathtest(12,def,"842.01250","197199893","197200735","-197199051","1.66044775E+11","0.00000426984258","0","842.01250","7.00674164E+576872502"); 4558 mathtest(13,def,"572.173103E+280128428","-7140.19428","5.72173103E+280128430","5.72173103E+280128430","-4.08542712E+280128434","-8.01341085E+280128426","","",""); 4559 mathtest(14,def,"674235.954E+476135291","9684.82245","6.74235954E+476135296","6.74235954E+476135296","6.52985550E+476135300","6.96177919E+476135292","","",""); 4560 mathtest(15,def,"-360557.921E+437116514","930428850","-3.60557921E+437116519","-3.60557921E+437116519","-3.35473492E+437116528","-3.87517993E+437116510","","",""); 4561 mathtest(16,def,"957165918E-394595705","1676.59073E-829618944","9.57165918E-394595697","9.57165918E-394595697","","5.70900161E+435023244","","","9.16166595E-789191393"); 4562 mathtest(17,def,"-2610864.40","31245912.7","28635048.3","-33856777.1","-8.15788411E+13","-0.0835585897","0","-2610864.40","-3.12008905E+200498284"); 4563 mathtest(18,def,"959.548461","98.994577E+776775426","9.89945770E+776775427","-9.89945770E+776775427","9.49900940E+776775430","9.69293965E-776775426","0","959.548461","6.61712185E+29"); 4564 mathtest(19,def,"-41085.0268","3115477.61","3074392.58","-3156562.64","-1.27999481E+11","-0.0131873927","0","-41085.0268","4.73844173E+14373829"); 4565 mathtest(20,def,"-723420285.","2681660.35","-720738625","-726101945","-1.93996749E+15","-269.765813","-269","-2053650.85","4.14324113E+23757873"); 4566 mathtest(21,def,"63542018.0E-817732230","-8836243.22","-8836243.22","8836243.22","-5.61472726E-817732216","-7.19106711E-817732230","0","6.35420180E-817732223",""); 4567 mathtest(22,def,"-96051.7108","-291201.955","-387253.666","195150.244","2.79704460E+10","0.329845694","0","-96051.7108","3.53617153E-1450916"); 4568 mathtest(23,def,"108490.853","91685996.5","91794487.4","-91577505.7","9.94709197E+12","0.00118328706","0","108490.853","6.98124265E+461675038"); 4569 mathtest(24,def,"-27489.1735","-9835835.4E-506411649","-27489.1735","-27489.1735","2.70378986E-506411638","2.79479804E+506411646","","","4.05866472E-45"); 4570 mathtest(25,def,"-89220406.6","993391.008E-611041175","-89220406.6","-89220406.6","-8.86307496E-611041162","-8.98139865E+611041176","","","3.19625913E+79"); 4571 mathtest(26,def,"4.75502020","-17089144.9","-17089140.2","17089149.7","-81259229.2","-2.78247989E-7","0","4.75502020","1.0630191E-11571955"); 4572 mathtest(27,def,"68027916.2","-796883.839","67231032.4","68824800.0","-5.42103470E+13","-85.3674185","-85","292789.885","8.29415374E-6241744"); 4573 mathtest(28,def,"-8.01969439E+788605478","92154156.0","-8.01969439E+788605478","-8.01969439E+788605478","-7.39048168E+788605486","-8.70247717E+788605470","","",""); 4574 mathtest(29,def,"-8012.98341","96188.8651","88175.8817","-104201.849","-770759780","-0.0833046881","0","-8012.98341","-1.16010156E+375502"); 4575 mathtest(30,def,"21761476E+592330677","-9.70744506","2.17614760E+592330684","2.17614760E+592330684","-2.11248333E+592330685","-2.24173053E+592330683","","",""); 4576 mathtest(31,def,"-9840778.51","-17907.219","-9858685.73","-9822871.29","1.76220976E+11","549.542534","549","-9715.279","-6.62997437E-125225"); 4577 mathtest(32,def,"-4.1097614","-819.225776E-145214751","-4.10976140","-4.10976140","3.36682247E-145214748","5.01664074E+145214748","","","0.0000122876018"); 4578 mathtest(33,def,"-448.880985","-394.087374E-442511435","-448.880985","-448.880985","1.76898329E-442511430","1.13903925E+442511435","","","2.46306099E-11"); 4579 mathtest(34,def,"779.445304E+882688544","-797868519","7.79445304E+882688546","7.79445304E+882688546","-6.21894870E+882688555","-9.7690946E+882688537","","",""); 4580 mathtest(35,def,"799995477","-6.23675208E+156309440","-6.23675208E+156309440","6.23675208E+156309440","-4.98937346E+156309449","-1.28271169E-156309432","0","799995477","3.81482667E-54"); 4581 mathtest(36,def,"-51932.8170","591840275E-278480289","-51932.8170","-51932.8170","-3.07359327E-278480276","-8.7748028E+278480284","","","1.96178443E+28"); 4582 mathtest(37,def,"70.3552392","-4228656.73","-4228586.38","4228727.09","-297508156","-0.0000166377277","0","70.3552392","9.14742382E-7811584"); 4583 mathtest(38,def,"1588359.34","-12232799.2","-10644439.9","13821158.5","-1.94300809E+13","-0.129844307","0","1588359.34","1.56910086E-75854960"); 4584 mathtest(39,def,"2842.16206","-3.23234345","2838.92972","2845.39440","-9186.84392","-879.288388","-879","0.93216745","4.35565514E-11"); 4585 mathtest(40,def,"29960.2305","45.2735747E-95205475","29960.2305","29960.2305","1.35640673E-95205469","6.61759773E+95205477","","","2.413936E+22"); 4586 mathtest(41,def,"2916565.77","1151935.43E-787118724","2916565.77","2916565.77","3.35969544E-787118712","2.53188303E+787118724","","","2916565.77"); 4587 mathtest(42,def,"-52723012.9E-967143787","79.4088237","79.4088237","-79.4088237","-4.18667244E-967143778","-6.63944011E-967143782","0","-5.27230129E-967143780",""); 4588 mathtest(43,def,"-167473465","793646.597","-166679819","-168267112","-1.32914746E+14","-211.017682","-211","-14033.033","-1.19053789E+6526910"); 4589 mathtest(44,def,"-31769071.0","133.4360","-31768937.6","-31769204.4","-4.23913776E+9","-238084.707","-238084","-94.3760","-5.84252432E+997"); 4590 mathtest(45,def,"45960.6383","-93352.7468","-47392.1085","139313.385","-4.29055183E+9","-0.492333004","0","45960.6383","1.88335323E-435248"); 4591 mathtest(46,def,"606.175648","5.28528458E-981983620","606.175648","606.175648","3.20381081E-981983617","1.14691203E+981983622","","","8.18450516E+13"); 4592 mathtest(47,def,"171578.617E+643006110","-407774.293","1.71578617E+643006115","1.71578617E+643006115","-6.99653492E+643006120","-4.20768597E+643006109","","",""); 4593 mathtest(48,def,"-682286332.","-464.871699","-682286797","-682285867","3.17175606E+11","1467687.39","1467687","-182.709787","-1.6050843E-4108"); 4594 mathtest(49,def,"492088.428","653.72170","492742.150","491434.706","321688884","752.74911","752","489.70960","3.94658596E+3722"); 4595 mathtest(50,def,"74303782.5","1141.68058","74304924.2","74302640.8","8.48311855E+10","65082.812","65082","926.99244","4.94849869E+8988"); 4596 mathtest(51,def,"74.7794084E+119375329","-34799355.6","7.47794084E+119375330","7.47794084E+119375330","-2.60227522E+119375338","-2.14887337E+119375323","","",""); 4597 mathtest(52,def,"-9432.08369","33735.5058","24303.4221","-43167.5895","-318196114","-0.279589218","0","-9432.08369","2.309567E+134087"); 4598 mathtest(53,def,"4249198.78E-112433155","418673051.","418673051","-418673051","1.77902502E-112433140","1.01492054E-112433157","0","4.24919878E-112433149",""); 4599 mathtest(54,def,"-2960933.02","-207933.38","-3168866.40","-2752999.64","6.15676811E+11","14.2398158","14","-49865.70","-2.75680397E-1345624"); 4600 mathtest(55,def,"29317.7519E+945600035","1.43555750","2.93177519E+945600039","2.93177519E+945600039","4.20873186E+945600039","2.04225549E+945600039","","","2.93177519E+945600039"); 4601 mathtest(56,def,"-51.1693770","-638055.414","-638106.583","638004.245","32648898.0","0.0000801958198","0","-51.1693770","-3.48266075E-1090443"); 4602 mathtest(57,def,"-756343055.","-68.9248344E+217100975","-6.89248344E+217100976","6.89248344E+217100976","5.21308198E+217100985","1.09734475E-217100968","0","-756343055","-7.06265897E-63"); 4603 mathtest(58,def,"2538.80406E+694185197","-3386499.65","2.53880406E+694185200","2.53880406E+694185200","-8.59765906E+694185206","-7.49683839E+694185193","","",""); 4604 mathtest(59,def,"-54344.0672","-8086.45235","-62430.5196","-46257.6149","439450710","6.72038427","6","-5825.35310","3.62916861E-38289"); 4605 mathtest(60,def,"3.31600054","217481648","217481651","-217481645","721169262","1.5247266E-8","0","3.31600054","3.73134969E+113224119"); 4606 mathtest(61,def,"681832.671","320341.161E+629467560","3.20341161E+629467565","-3.20341161E+629467565","2.18419069E+629467571","2.12845789E-629467560","0","681832.671","3.16981139E+17"); 4607 mathtest(62,def,"832689481","348040024E-882122501","832689481","832689481","2.89809267E-882122484","2.3925107E+882122501","","","5.77363381E+26"); 4608 mathtest(63,def,"14.5512326E+257500811","60.9979577E-647314724","1.45512326E+257500812","1.45512326E+257500812","8.87595471E-389813911","2.38552784E+904815534","","",""); 4609 mathtest(64,def,"-901.278844","449461667.","449460766","-449462568","-4.05090292E+11","-0.00000200524074","0","-901.278844",""); 4610 mathtest(65,def,"-5.32627675","-738860216E-238273224","-5.32627675","-5.32627675","3.93537399E-238273215","7.20877459E+238273215","","","-0.00000822306838"); 4611 mathtest(66,def,"-505383463.","3.18756328","-505383460","-505383466","-1.61094177E+9","-158548527","-158548527","-0.23671144","-1.29081226E+26"); 4612 mathtest(67,def,"769241.44E-720927320","-145382631.","-145382631","145382631","-1.11834344E-720927306","-5.29115091E-720927323","0","7.6924144E-720927315",""); 4613 mathtest(68,def,"-6.45038910","56736.4411E+440937167","5.67364411E+440937171","-5.67364411E+440937171","-3.65972121E+440937172","-1.13690407E-440937171","0","-6.45038910","72030.3421"); 4614 mathtest(69,def,"58.4721075","-712186829","-712186771","712186887","-4.16430648E+10","-8.21022028E-8","0","58.4721075",""); 4615 mathtest(70,def,"8244.08357","245.302828E+652007959","2.45302828E+652007961","-2.45302828E+652007961","2.02229701E+652007965","3.36077804E-652007958","0","8244.08357","67964913.9"); 4616 mathtest(71,def,"45.5361397","-76579063.9","-76579018.4","76579109.4","-3.48711495E+9","-5.94629098E-7","0","45.5361397","3.98335374E-126995367"); 4617 mathtest(72,def,"594420.54E+685263039","-952420.179","5.94420540E+685263044","5.94420540E+685263044","-5.66138117E+685263050","-6.24115861E+685263038","","",""); 4618 mathtest(73,def,"-841310701.","9398110.4","-831912591","-850708811","-7.90673085E+15","-89.5191337","-89","-4878875.4","1.30001466E+83877722"); 4619 mathtest(74,def,"904392146E-140100276","168116093.","168116093","-168116093","1.52042874E-140100259","5.37956914E-140100276","0","9.04392146E-140100268",""); 4620 mathtest(75,def,"-907324792E+685539670","-15.6902171","-9.07324792E+685539678","-9.07324792E+685539678","1.42361230E+685539680","5.78274211E+685539677","","",""); 4621 mathtest(76,def,"987013606.","-26818.3572E+560907442","-2.68183572E+560907446","2.68183572E+560907446","-2.64700834E+560907455","-3.68036565E-560907438","0","987013606","1.0399934E-27"); 4622 mathtest(77,def,"-741317564","630.241530E-212782946","-741317564","-741317564","-4.67209116E-212782935","-1.1762436E+212782952","","","1.65968527E+53"); 4623 mathtest(78,def,"61867907.2","-139204670","-77336763","201072577","-8.61230161E+15","-0.444438446","0","61867907.2",""); 4624 mathtest(79,def,"-273.622743E+531282717","-4543.68684","-2.73622743E+531282719","-2.73622743E+531282719","1.24325606E+531282723","6.02204229E+531282715","","",""); 4625 mathtest(80,def,"-383588949.","-428640583.","-812229532","45051634","1.64421791E+17","0.89489648","0","-383588949",""); 4626 mathtest(81,def,"-56182.2686","32.7741649","-56149.4944","-56215.0428","-1841326.94","-1714.22426","-1714","-7.3499614","-5.45476402E+156"); 4627 mathtest(82,def,"-6366384.30","332014.980","-6034369.32","-6698399.28","-2.11373496E+12","-19.1749911","-19","-58099.680","-3.05392399E+2258994"); 4628 mathtest(83,def,"-1.27897702","-8213776.03E-686519123","-1.27897702","-1.27897702","1.05052308E-686519116","1.55711212E+686519116","","","0.139668371"); 4629 mathtest(84,def,"65.4059036","401162145E+884155506","4.01162145E+884155514","-4.01162145E+884155514","2.62383726E+884155516","1.63041066E-884155513","0","65.4059036","18300704.1"); 4630 mathtest(85,def,"-20630916.8","158987411.E-480500612","-20630916.8","-20630916.8","-3.28005605E-480500597","-1.29764468E+480500611","","","4.25634728E+14"); 4631 mathtest(86,def,"-4.72705853","-97626742.4","-97626747.1","97626737.7","461487325","4.84197097E-8","0","-4.72705853","2.92654449E-65858120"); 4632 mathtest(87,def,"8.43528169","-4573.45752","-4565.02224","4581.89280","-38578.4025","-0.00184439927","0","8.43528169","8.84248688E-4236"); 4633 mathtest(88,def,"1.91075189","-704247089.","-704247087","704247091","-1.34564146E+9","-2.71318394E-9","0","1.91075189","6.84547494E-198037309"); 4634 mathtest(89,def,"31997198E-551746308","326.892584","326.892584","-326.892584","1.04596467E-551746298","9.78829119E-551746304","0","3.1997198E-551746301",""); 4635 mathtest(90,def,"127589.213","84184304.","84311893.2","-84056714.8","1.07410091E+13","0.00151559385","0","127589.213","2.87917042E+429829394"); 4636 mathtest(91,def,"714494248","-7025063.59","707469185","721519312","-5.01936753E+15","-101.706446","-101","4962825.41","1.65018516E-62199908"); 4637 mathtest(92,def,"-52987680.2E+279533503","-42014114.8","-5.29876802E+279533510","-5.29876802E+279533510","2.22623048E+279533518","1.26118759E+279533503","","",""); 4638 mathtest(93,def,"-8795.0513","-225294.394E-884414238","-8795.05130","-8795.05130","1.98147575E-884414229","3.90380388E+884414236","","","1.2927759E-8"); 4639 mathtest(94,def,"83280.1394","161566354.","161649634","-161483074","1.34552685E+13","0.000515454718","0","83280.1394","5.30774809E+794993940"); 4640 mathtest(95,def,"112.877897","-9.96481666","102.913080","122.842714","-1124.80755","-11.3276441","-11","3.26491374","2.97790545E-21"); 4641 mathtest(96,def,"-572542.121E+847487397","433.843420","-5.72542121E+847487402","-5.72542121E+847487402","-2.48393632E+847487405","-1.3196976E+847487400","","",""); 4642 mathtest(97,def,"4709649.89","20949266.4","25658916.3","-16239616.5","9.86637102E+13","0.224812163","0","4709649.89","4.85293644E+139794213"); 4643 mathtest(98,def,"-9475.19322","-30885.2475E+584487341","-3.08852475E+584487345","3.08852475E+584487345","2.92643688E+584487349","3.06787026E-584487342","0","-9475.19322","-1.17553557E-12"); 4644 mathtest(99,def,"-213230447.","864.815822E+127783046","8.64815822E+127783048","-8.64815822E+127783048","-1.84405064E+127783057","-2.46561686E-127783041","0","-213230447","-9.11261361E+74"); 4645 mathtest(100,def,"-89.1168786E+403375873","6464.05744","-8.91168786E+403375874","-8.91168786E+403375874","-5.76056622E+403375878","-1.37865233E+403375871","","",""); 4646 mathtest(101,def,"61774.4958","-14000.7706","47773.7252","75775.2664","-864890545","-4.41222112","-4","5771.4134","7.59030407E-67077"); 4647 mathtest(102,def,"1.60731414","7.04330293E-427033419","1.60731414","1.60731414","1.13208004E-427033418","2.28204602E+427033418","","","27.7143921"); 4648 mathtest(103,def,"7955012.51","-230117662.","-222162650","238072675","-1.83058888E+15","-0.0345693261","0","7955012.51",""); 4649 mathtest(104,def,"4086661.08","1.77621994","4086662.86","4086659.30","7258808.90","2300762.98","2300762","1.73840572","1.67007988E+13"); 4650 mathtest(105,def,"-610.076931","-207.658306","-817.735237","-402.418625","126687.542","2.93788841","2","-194.760319","4.36518377E-580"); 4651 mathtest(106,def,"-98.6353697","-99253.3899E-716309653","-98.6353697","-98.6353697","9.78989481E-716309647","9.93773309E+716309649","","","1.14729007E-20"); 4652 mathtest(107,def,"-959923730","409.125542E-900295528","-959923730","-959923730","-3.92729316E-900295517","-2.3462816E+900295534","","","8.49076677E+35"); 4653 mathtest(108,def,"379965133","-8.15869657","379965125","379965141","-3.10002023E+9","-46571793.6","-46571793","5.19214999","2.30170697E-69"); 4654 mathtest(109,def,"833.646797","1389499.46E-443407251","833.646797","833.646797","1.15835177E-443407242","5.99961944E+443407247","","","833.646797"); 4655 mathtest(110,def,"2314933.4E-646489194","-7401538.17","-7401538.17","7401538.17","-1.71340679E-646489181","-3.12763826E-646489195","0","2.3149334E-646489188",""); 4656 mathtest(111,def,"808525347","-5959.74667E+58232168","-5.95974667E+58232171","5.95974667E+58232171","-4.81860624E+58232180","-1.35664382E-58232163","0","808525347","3.5796302E-54"); 4657 mathtest(112,def,"-17220490.6E+726428704","19.9855688","-1.72204906E+726428711","-1.72204906E+726428711","-3.44161300E+726428712","-8.61646259E+726428709","","",""); 4658 mathtest(113,def,"59015.9705","-72070405.4E+322957279","-7.20704054E+322957286","7.20704054E+322957286","-4.25330492E+322957291","-8.18865527E-322957283","0","59015.9705","4.01063488E-34"); 4659 mathtest(114,def,"16411470E+578192008","497470.005E-377473621","1.64114700E+578192015","1.64114700E+578192015","8.16421406E+200718399","3.29898684E+955665630","","",""); 4660 mathtest(115,def,"-107.353544E+609689808","-659.50136E-456711743","-1.07353544E+609689810","-1.07353544E+609689810","7.07998083E+152978069","","","",""); 4661 mathtest(116,def,"786.134163","-53.0292275E-664419768","786.134163","786.134163","-4.16880874E-664419764","-1.48245449E+664419769","","","3.33055532E-15"); 4662 mathtest(117,def,"23.5414714","5000786.91","5000810.45","-5000763.37","117725882","0.0000047075534","0","23.5414714","4.4895618E+6860247"); 4663 mathtest(118,def,"-69775.6113","561292120.","561222344","-561361896","-3.91645008E+13","-0.000124312473","0","-69775.6113",""); 4664 mathtest(119,def,"919043.871","-71606613.7","-70687569.8","72525657.6","-6.58096194E+13","-0.0128346227","0","919043.871","3.05862429E-427014317"); 4665 mathtest(120,def,"-27667.1915","-293455.107E-789181924","-27667.1915","-27667.1915","8.11907864E-789181915","9.42808315E+789181922","","","-4.72176938E-14"); 4666 mathtest(121,def,"-908603625.","-982.409273E+449441134","-9.82409273E+449441136","9.82409273E+449441136","8.92620627E+449441145","9.2487281E-449441129","0","-908603625","2.60768632E-90"); 4667 mathtest(122,def,"847.113351","5.71511268","852.828464","841.398238","4841.34825","148.223386","148","1.27667436","3.69529538E+17"); 4668 mathtest(123,def,"-992140475","3.82918218","-992140471","-992140479","-3.79908663E+9","-259099836","-259099836","-0.14787752","9.68930595E+35"); 4669 mathtest(124,def,"-12606437.5","268123145E+362798858","2.68123145E+362798866","-2.68123145E+362798866","-3.38007767E+362798873","-4.70173416E-362798860","0","-12606437.5","-2.00344362E+21"); 4670 mathtest(125,def,"3799470.64","-264.703992","3799205.94","3799735.34","-1.00573505E+9","-14353.6583","-14353","174.242824","2.3625466E-1744"); 4671 mathtest(126,def,"-8.11070247","-931284056.E-654288974","-8.11070247","-8.11070247","7.55336789E-654288965","8.70916067E+654288965","","","-6.58375662E-9"); 4672 mathtest(127,def,"-242660177.","-6.09832715E-943742415","-242660177","-242660177","1.47982115E-943742406","3.97912692E+943742422","","","4.89788901E-51"); 4673 mathtest(128,def,"76.1463803","-45.6758006E-636907996","76.1463803","76.1463803","-3.47804688E-636907993","-1.66710554E+636907996","","","3.90619287E-10"); 4674 mathtest(129,def,"761185.862","-70878470.9E+221214712","-7.08784709E+221214719","7.08784709E+221214719","-5.39516900E+221214725","-1.07393099E-221214714","0","761185.862","6.75406144E-42"); 4675 mathtest(130,def,"6203606.54","-195.92748E-833512061","6203606.54","6203606.54","-1.21545700E-833512052","-3.1662769E+833512065","","","2.59843292E-14"); 4676 mathtest(131,def,"-163274837.","95.0448550E+887876533","9.50448550E+887876534","-9.50448550E+887876534","-1.55184332E+887876543","-1.71787139E-887876527","0","-163274837","1.34645731E+82"); 4677 mathtest(132,def,"2.38638190","-807986179.","-807986177","807986181","-1.92816359E+9","-2.95349347E-9","0","2.38638190","1.19029305E-305208656"); 4678 mathtest(133,def,"-109022296E-811981158","7.19685680","7.19685680","-7.19685680","-7.84617852E-811981150","-1.51485988E-811981151","0","-1.09022296E-811981150",""); 4679 mathtest(134,def,"-559250.780E-273710421","-393780811.","-393780811","393780811","2.20222226E-273710407","1.42020831E-273710424","0","-5.59250780E-273710416",""); 4680 mathtest(135,def,"-88021.9966E+555334642","7599686.64E+818884053","7.59968664E+818884059","-7.59968664E+818884059","","-1.15823192E-263549413","0","-8.80219966E+555334646",""); 4681 mathtest(136,def,"194.317648E-197450009","-930.979064","-930.979064","930.979064","-1.80905662E-197450004","-2.08723972E-197450010","0","1.94317648E-197450007",""); 4682 mathtest(137,def,"9495479.65","7405697.96","16901177.6","2089781.69","7.03206543E+13","1.28218565","1","2089781.69","1.0135446E+51673383"); 4683 mathtest(138,def,"-1656.28925","-163050511E-682882380","-1656.28925","-1656.28925","2.70058809E-682882369","1.01581359E+682882375","","","3.64525265E-7"); 4684 mathtest(139,def,"95581.3784E+64262149","-99.2879365","9.55813784E+64262153","9.55813784E+64262153","-9.49007783E+64262155","-9.62668596E+64262151","","",""); 4685 mathtest(140,def,"643761.452","3.73446939","643765.186","643757.718","2404107.44","172383.647","172383","2.41514363","1.71751236E+23"); 4686 mathtest(141,def,"7960.49866E-129827423","3220.22850","3220.22850","-3220.22850","2.56346247E-129827416","2.47202913E-129827423","0","7.96049866E-129827420",""); 4687 mathtest(142,def,"-6356.64112E-707203818","1805054.98","1805054.98","-1805054.98","-1.14740867E-707203808","-3.52157756E-707203821","0","-6.35664112E-707203815",""); 4688 mathtest(143,def,"2.3904042","8476.52006","8478.91046","-8474.12966","20262.3092","0.000282003013","0","2.3904042","2.00251752E+3208"); 4689 mathtest(144,def,"-713298.658","-957.782729","-714256.441","-712340.875","683185135","744.739528","744","-708.307624","3.68122321E-5608"); 4690 mathtest(145,def,"607779233.E-820497365","-20.1188742E-857318323","6.07779233E-820497357","6.07779233E-820497357","","-3.02094057E+36820965","","",""); 4691 mathtest(146,def,"-205888251","-908.792922E+250680613","-9.08792922E+250680615","9.08792922E+250680615","1.87109785E+250680624","2.26551336E-250680608","0","-205888251","-1.5042358E-75"); 4692 mathtest(147,def,"51542399.1","-23212.2414","51519186.9","51565611.3","-1.19641461E+12","-2220.4835","-2220","11223.1920","1.71641348E-179015"); 4693 mathtest(148,def,"4.44287230","158923023","158923027","-158923019","706074697","2.79561275E-8","0","4.44287230","7.12573416E+102928693"); 4694 mathtest(149,def,"-79123682.6","-3.8571770","-79123686.5","-79123678.8","305194049","20513365.8","20513365","-2.9293950","2.55137345E-32"); 4695 mathtest(150,def,"-80.3324347E-569715030","883142.351","883142.351","-883142.351","-7.09449752E-569715023","-9.09620455E-569715035","0","-8.03324347E-569715029",""); 4696 mathtest(151,def,"13637.483","-52798.5631","-39161.0801","66436.0461","-720039507","-0.258292692","0","13637.483","1.47163791E-218310"); 4697 mathtest(152,def,"6.42934843E-276476458","84057440.0E-388039782","6.42934843E-276476458","6.42934843E-276476458","5.40434570E-664516232","7.64875593E+111563316","","",""); 4698 mathtest(153,def,"-5.64133087","-17401297.","-17401302.6","17401291.4","98166473.9","3.24190253E-7","0","-5.64133087","-1.25908916E-13075014"); 4699 mathtest(154,def,"95469.7057E+865733824","198.829749","9.54697057E+865733828","9.54697057E+865733828","1.89822176E+865733831","4.80158056E+865733826","","",""); 4700 mathtest(155,def,"-416466.209","-930153427","-930569893","929736961","3.87377472E+14","0.000447739262","0","-416466.209",""); 4701 mathtest(156,def,"-1541733.85","-1.99208708","-1541735.84","-1541731.86","3071268.08","773928.944","773928","-1.88034976","4.20708401E-13"); 4702 mathtest(157,def,"-39152691.8","-645131748.","-684284440","605979056","2.52586445E+16","0.0606894513","0","-39152691.8",""); 4703 mathtest(158,def,"113.939979","-58282550.4","-58282436.5","58282664.3","-6.64071257E+9","-0.0000019549587","0","113.939979","2.106557E-119868330"); 4704 mathtest(159,def,"-324971.736","-9517.15154","-334488.888","-315454.585","3.09280526E+9","34.1459033","34","-1388.58364","-5.82795263E-52457"); 4705 mathtest(160,def,"-76.9436744","-9548122.75E-273599728","-76.9436744","-76.9436744","7.34667648E-273599720","8.05851332E+273599722","","","1.37489895E-19"); 4706 mathtest(161,def,"-430393.282","-70.2551505","-430463.537","-430323.027","30237344.8","6126.14561","6126","-10.2300370","4.26006409E-395"); 4707 mathtest(162,def,"-3308051.90","-349433799.E+397813188","-3.49433799E+397813196","3.49433799E+397813196","1.15594514E+397813203","9.46689161E-397813191","0","-3308051.90","-2.76237768E-20"); 4708 mathtest(163,def,"23.1543212E-655822712","5848.20853","5848.20853","-5848.20853","1.35411299E-655822707","3.95921607E-655822715","0","2.31543212E-655822711",""); 4709 mathtest(164,def,"-174.261308E-82902077","-200096204.","-200096204","200096204","3.48690262E-82902067","8.70887626E-82902084","0","-1.74261308E-82902075",""); 4710 mathtest(165,def,"-50669105.2","9105789.01E+609889700","9.10578901E+609889706","-9.10578901E+609889706","-4.61382181E+609889714","-5.56449366E-609889700","0","-50669105.2","-2.20135008E+69"); 4711 mathtest(166,def,"424768856.","-971.71757","424767884","424769828","-4.12755361E+11","-437132.012","-437132","11.19076","2.72651473E-8387"); 4712 mathtest(167,def,"7181.2767","999117.918","1006299.19","-991936.641","7.17494223E+9","0.00718761677","0","7181.2767","3.09655124E+3852800"); 4713 mathtest(168,def,"8096417.07E-433694528","-68.4863363","-68.4863363","68.4863363","-5.54493942E-433694520","-1.18219451E-433694523","0","8.09641707E-433694522",""); 4714 mathtest(169,def,"1236287.5","-7119.97299E-176200498","1236287.50","1236287.50","-8.80233361E-176200489","-1.73636544E+176200500","","","2.26549784E-43"); 4715 mathtest(170,def,"-752995833E-654401067","-15.2736930E+803939983","-1.52736930E+803939984","1.52736930E+803939984","1.15010272E+149538926","","0","-7.52995833E-654401059",""); 4716 mathtest(171,def,"702992.459","-312.689474","702679.770","703305.148","-219818342","-2248.21274","-2248","66.521448","8.02493322E-1831"); 4717 mathtest(172,def,"-4414.38805","-17680.4630E-584364536","-4414.38805","-4414.38805","7.80484246E-584364529","2.49676044E+584364535","","","5.13167312E-8"); 4718 mathtest(173,def,"9.46350807","7826.65424","7836.11775","-7817.19073","74067.6056","0.00120913839","0","9.46350807","3.63271495E+7639"); 4719 mathtest(174,def,"2078153.7","-16934607.3E+233594439","-1.69346073E+233594446","1.69346073E+233594446","-3.51927168E+233594452","-1.2271638E-233594440","0","2078153.7","2.31549939E-13"); 4720 mathtest(175,def,"-9359.74629","7.07761788E+252457696","7.07761788E+252457696","-7.07761788E+252457696","-6.62447077E+252457700","-1.32244301E-252457693","0","-9359.74629","-6.29286677E+27"); 4721 mathtest(176,def,"66.2319284E+730468479","25.9391685E+221147044","6.62319284E+730468480","6.62319284E+730468480","1.71800115E+951615526","2.55335588E+509321435","","",""); 4722 mathtest(177,def,"317997088.E-90968742","-977426.461","-977426.461","977426.461","-3.10818768E-90968728","-3.2534119E-90968740","0","3.17997088E-90968734",""); 4723 mathtest(178,def,"227473386","-6759.61390","227466626","227480146","-1.53763226E+12","-33651.8312","-33651","5618.65110","1.40992627E-56493"); 4724 mathtest(179,def,"-392019.462","-245456.503","-637475.965","-146562.959","9.62237263E+10","1.59710359","1","-146562.959","-3.08656533E-1372917"); 4725 mathtest(180,def,"-3619556.28E+587673583","-3.45236972","-3.61955628E+587673589","-3.61955628E+587673589","1.24960465E+587673590","1.04842661E+587673589","","",""); 4726 mathtest(181,def,"-249.400704E-923930848","831102.919","831102.919","-831102.919","-2.07277653E-923930840","-3.00084019E-923930852","0","-2.49400704E-923930846",""); 4727 mathtest(182,def,"65234.2739E+154949914","-694581895","6.52342739E+154949918","6.52342739E+154949918","-4.53105456E+154949927","-9.39187652E+154949909","","",""); 4728 mathtest(183,def,"45.2316213","-88775083.4","-88775038.2","88775128.6","-4.01544095E+9","-5.09508069E-7","0","45.2316213","1.92314254E-146962015"); 4729 mathtest(184,def,"331100375.","442.343378","331100817","331099933","1.46460058E+11","748514.37","748514","163.759708","6.64011043E+3765"); 4730 mathtest(185,def,"81.8162765","5.61239515E+467372163","5.61239515E+467372163","-5.61239515E+467372163","4.59185273E+467372165","1.45777826E-467372162","0","81.8162765","2.99942677E+11"); 4731 mathtest(186,def,"-5738.13069E+789464078","33969715.0","-5.73813069E+789464081","-5.73813069E+789464081","-1.94922664E+789464089","-1.68919012E+789464074","","",""); 4732 mathtest(187,def,"-7413.03911","2.70630320E-254858264","-7413.03911","-7413.03911","-2.00619315E-254858260","-2.73917539E+254858267","","","-4.07369842E+11"); 4733 mathtest(188,def,"-417696.182","27400.6002","-390295.582","-445096.782","-1.14451261E+10","-15.2440523","-15","-6687.1790","-1.58020334E+154017"); 4734 mathtest(189,def,"68.8538735E+655647287","3198.17933E-132454826","6.88538735E+655647288","6.88538735E+655647288","2.20207035E+523192466","2.15290846E+788102111","","",""); 4735 mathtest(190,def,"-6817.04246","434420.439","427603.397","-441237.481","-2.96146258E+9","-0.0156922692","0","-6817.04246","5.94143518E+1665390"); 4736 mathtest(191,def,"8578.27511","647042.341E-490924334","8578.27511","8578.27511","5.55050721E-490924325","1.3257672E+490924332","","","3.98473846E+23"); 4737 mathtest(192,def,"4124.11615E+733109424","597385828E+375928745","4.12411615E+733109427","4.12411615E+733109427","","6.9036056E+357180673","","",""); 4738 mathtest(193,def,"102.714400","-919017.468","-918914.754","919120.182","-94396327.8","-0.000111765449","0","102.714400","4.04295689E-1848724"); 4739 mathtest(194,def,"-4614.33015E+996778733","-433.560812E+22860599","-4.61433015E+996778736","-4.61433015E+996778736","","1.06428672E+973918135","","",""); 4740 mathtest(195,def,"457455170.","3709230.48E+677010879","3.70923048E+677010885","-3.70923048E+677010885","1.69680666E+677010894","1.23328861E-677010877","0","457455170","4.37919376E+34"); 4741 mathtest(196,def,"-2522468.15","-48482043.5","-51004511.7","45959575.4","1.22294411E+14","0.0520289156","0","-2522468.15","1.42348178E-310373595"); 4742 mathtest(197,def,"-659811384","62777.6118","-659748606","-659874162","-4.14213829E+13","-10510.2976","-10510","-18683.9820","3.4393524E+553665"); 4743 mathtest(198,def,"4424.94176","-825848.20","-821423.258","830273.142","-3.65433019E+9","-0.00535805704","0","4424.94176","3.42152775E-3010966"); 4744 mathtest(199,def,"43.6441884","-6509.89663E-614169377","43.6441884","43.6441884","-2.84119155E-614169372","-6.70428286E+614169374","","","3.31524056E-12"); 4745 mathtest(200,def,"897.388381E-843864876","84195.1369","84195.1369","-84195.1369","7.55557376E-843864869","1.06584348E-843864878","0","8.97388381E-843864874",""); 4746 mathtest(201,def,"796199825","496.76834","796200322","796199328","3.95526865E+11","1602758.79","1602758","393.91828","6.42647264E+4423"); 4747 mathtest(202,def,"573583582","1598.69521","573585181","573581983","9.16985325E+11","358782.323","358782","517.16578","9.91156302E+14004"); 4748 mathtest(203,def,"-783144270.","6347.71496","-783137922","-783150618","-4.97117660E+12","-123374.202","-123374","-1284.52496","1.28110803E+56458"); 4749 mathtest(204,def,"26909234.7","52411.5081","26961646.2","26856823.2","1.41035357E+12","513.422255","513","22131.0447","9.75836528E+389415"); 4750 mathtest(205,def,"8.21915282","24859.7841E-843282959","8.21915282","8.21915282","2.04326365E-843282954","3.30620443E+843282955","","","67.5544731"); 4751 mathtest(206,def,"-688.387710","82783.5207E-831870858","-688.387710","-688.387710","-5.69871582E-831870851","-8.31551623E+831870855","","","5.04272012E+22"); 4752 mathtest(207,def,"-9792232.","-1749.01166","-9793981.01","-9790482.99","1.71267279E+10","5598.72311","5598","-1264.72732","-8.86985674E-12228"); 4753 mathtest(208,def,"-130.765600","8.67437427","-122.091226","-139.439974","-1134.30976","-15.0749317","-15","-0.64998595","-1.11799947E+19"); 4754 mathtest(209,def,"917.259102","-368640.426","-367723.167","369557.685","-338138786","-0.00248822169","0","917.259102","8.67104255E-1092094"); 4755 mathtest(210,def,"-4.9725631","-294563717.","-294563722","294563712","1.46473667E+9","1.6881112E-8","0","-4.9725631","-6.27962584E-205187284"); 4756 mathtest(211,def,"-60962887.2E-514249661","-243021.407","-243021.407","243021.407","1.48152866E-514249648","2.5085398E-514249659","0","-6.09628872E-514249654",""); 4757 mathtest(212,def,"-55389219.8","-3772200E+981866393","-3.77220000E+981866399","3.77220000E+981866399","2.08939215E+981866407","1.46835321E-981866392","0","-55389219.8","1.06242678E-31"); 4758 mathtest(213,def,"681.666010","626886700","626887382","-626886018","4.27327356E+11","0.00000108738311","0","681.666010",""); 4759 mathtest(214,def,"6.42652138","53465894.5","53465900.9","-53465888.1","343599714","1.2019852E-7","0","6.42652138","4.61155532E+43199157"); 4760 mathtest(215,def,"561546656","651408.476","562198064","560895248","3.65796251E+14","862.049968","862","32549.688","8.6052377E+5699419"); 4761 mathtest(216,def,"7845778.36E-79951139","9.45859047","9.45859047","-9.45859047","7.42100044E-79951132","8.29487056E-79951134","0","7.84577836E-79951133","1.12648216E-719560189"); 4762 mathtest(217,def,"54486.2112","10.7565078","54496.9677","54475.4547","586081.356","5065.41828","5065","4.4991930","1.25647168E+52"); 4763 mathtest(218,def,"16576482.5","-2217720.83","14358761.7","18794203.3","-3.67620105E+13","-7.47455779","-7","1052436.69","1.38259374E-16010820"); 4764 mathtest(219,def,"61.2793787E-392070111","6.22575651","6.22575651","-6.22575651","3.81510491E-392070109","9.84288072E-392070111","0","6.12793787E-392070110",""); 4765 mathtest(220,def,"5115136.39","-653674372.","-648559236","658789508","-3.34363357E+15","-0.00782520565","0","5115136.39",""); 4766 mathtest(221,def,"-7.84238366E-416477339","-37432758.9E+97369393","-3.74327589E+97369400","3.74327589E+97369400","2.93562057E-319107938","2.09505895E-513846739","0","-7.84238366E-416477339",""); 4767 mathtest(222,def,"-387781.3E+284108380","-218085.592","-3.87781300E+284108385","-3.87781300E+284108385","8.45695144E+284108390","1.77811517E+284108380","","",""); 4768 mathtest(223,def,"-5353.17736","3.39332346E+546685359","3.39332346E+546685359","-3.39332346E+546685359","-1.81650623E+546685363","-1.57756177E-546685356","0","-5353.17736","-1.53403369E+11"); 4769 mathtest(224,def,"-20837.2900E-168652772","-8236.78305E-712819173","-2.08372900E-168652768","-2.08372900E-168652768","1.71632237E-881471937","2.52978497E+544166401","","",""); 4770 mathtest(225,def,"-98573.8722E+829022366","309011.007","-9.85738722E+829022370","-9.85738722E+829022370","-3.04604115E+829022376","-3.18997932E+829022365","","",""); 4771 mathtest(226,def,"49730750.7","-5315.10636E-299586991","49730750.7","49730750.7","-2.64324229E-299586980","-9.35649211E+299586994","","","3.28756936E-39"); 4772 mathtest(227,def,"1539523.40","-962388.581","577134.82","2501911.98","-1.48161974E+12","-1.59969001","-1","577134.819","3.10144834E-5954673"); 4773 mathtest(228,def,"81596.2121","-37600.9653","43995.2468","119197.177","-3.06809634E+9","-2.17005631","-2","6394.2815","1.97878299E-184684"); 4774 mathtest(229,def,"590146199","-1425404.61","588720794","591571604","-8.41197113E+14","-414.020128","-414","28690.46","2.04650994E-12502170"); 4775 mathtest(230,def,"196.05543","505.936305","701.991735","-309.880875","99191.5598","0.387510104","0","196.05543","8.78437397E+1159"); 4776 mathtest(231,def,"77.8058449","-642.275274","-564.469429","720.081119","-49972.7704","-0.121140963","0","77.8058449","9.33582626E-1215"); 4777 mathtest(232,def,"1468.60684","10068.138","11536.7448","-8599.5312","14786136.3","0.145866777","0","1468.60684","2.54122484E+31884"); 4778 mathtest(233,def,"4.98774767E-387968632","4.41731439E-578812376","4.98774767E-387968632","4.98774767E-387968632","2.20324496E-966781007","1.12913577E+190843744","","",""); 4779 mathtest(234,def,"981.091059","-92238.9930","-91257.9020","93220.0841","-90494851.3","-0.0106364025","0","981.091059","5.29943342E-275953"); 4780 mathtest(235,def,"-3606.24992","8290224.70","8286618.45","-8293830.95","-2.98966222E+10","-0.000435000262","0","-3606.24992","-1.23747107E+29488793"); 4781 mathtest(236,def,"-8978571.35","92243.4796","-8886327.87","-9070814.83","-8.28214663E+11","-97.3355666","-97","-30953.8288","-4.95762813E+641384"); 4782 mathtest(237,def,"-61968.1992E+810060478","474294671.E+179263414","-6.19681992E+810060482","-6.19681992E+810060482","-2.93911867E+989323905","-1.30653374E+630797060","","",""); 4783 mathtest(238,def,"61298431.6E-754429041","-2584862.79","-2584862.79","2584862.79","-1.58448035E-754429027","-2.37143851E-754429040","0","6.12984316E-754429034",""); 4784 mathtest(239,def,"621039.064","-5351539.62","-4730500.56","5972578.68","-3.32351516E+12","-0.116048672","0","621039.064","2.41163312E-31002108"); 4785 mathtest(240,def,"-19.6007605","-57905696.","-57905715.6","57905676.4","1.13499568E+9","3.38494515E-7","0","-19.6007605","1.05663646E-74829963"); 4786 mathtest(241,def,"3626.13109E+687030346","189.896004","3.62613109E+687030349","3.62613109E+687030349","6.88587804E+687030351","1.90953523E+687030347","","",""); 4787 mathtest(242,def,"-249334.026","-7.54735834E-14137188","-249334.026","-249334.026","1.88181324E-14137182","3.30359332E+14137192","","","6.69495408E-44"); 4788 mathtest(243,def,"417613928.","-925213.216","416688715","418539141","-3.86381925E+14","-451.370474","-451","342767.584","8.38430085E-7976054"); 4789 mathtest(244,def,"23.8320309","-50074996.1","-50074972.3","50075019.9","-1.19338885E+9","-4.75926765E-7","0","23.8320309","5.81466387E-68961335"); 4790 mathtest(245,def,"49789677.7","-131827812E+156412534","-1.31827812E+156412542","1.31827812E+156412542","-6.56366427E+156412549","-3.77687204E-156412535","0","49789677.7","2.00844843E-8"); 4791 mathtest(246,def,"-8907163.61E-741867246","773651.288E-472033282","7.73651288E-472033277","-7.73651288E-472033277","","-1.15131504E-269833963","0","-8.90716361E-741867240",""); 4792 mathtest(247,def,"514021711.E+463536646","617441659.","5.14021711E+463536654","5.14021711E+463536654","3.17378418E+463536663","8.32502478E+463536645","","",""); 4793 mathtest(248,def,"998175750","2.39285478","998175752","998175748","2.38848961E+9","417148487","417148486","1.30513692","9.96354828E+17"); 4794 mathtest(249,def,"873575426.","647853.152E+497450781","6.47853152E+497450786","-6.47853152E+497450786","5.65948593E+497450795","1.3484158E-497450778","0","873575426","4.44429064E+53"); 4795 mathtest(250,def,"4352626.8","-130338048.E-744560911","4352626.80","4352626.80","-5.67312881E-744560897","-3.33949055E+744560909","","","2.29746322E-7"); 4796 mathtest(251,def,"437.286960","7.37560835","444.662568","429.911352","3225.25735","59.2882565","59","2.12606735","3.05749452E+18"); 4797 mathtest(252,def,"8498280.45E+220511522","588617612","8.49828045E+220511528","8.49828045E+220511528","5.00223754E+220511537","1.44376931E+220511520","","",""); 4798 mathtest(253,def,"-5320387.77","-7673237.46","-12993625.2","2352849.69","4.08245987E+13","0.693369363","0","-5320387.77","-1.30113745E-51609757"); 4799 mathtest(254,def,"587655375","-4.9748366","587655370","587655380","-2.92348947E+9","-118125563","-118125563","0.7919942","1.42687667E-44"); 4800 mathtest(255,def,"1266098.44","-2661.64904E-642601142","1266098.44","1266098.44","-3.36990970E-642601133","-4.75681963E+642601144","","","4.92717036E-19"); 4801 mathtest(256,def,"3.92737463E+482873483","-685.522747","3.92737463E+482873483","3.92737463E+482873483","-2.69230464E+482873486","-5.72902161E+482873480","","",""); 4802 mathtest(257,def,"22826494.1","986189474.","1.00901597E+9","-963362980","2.25112482E+16","0.0231461547","0","22826494.1",""); 4803 mathtest(258,def,"-647342.380","-498816386","-499463728","498169044","3.22904986E+14","0.00129775685","0","-647342.380",""); 4804 mathtest(259,def,"393092373.","-25.7226822","393092347","393092399","-1.01113902E+10","-15281935.6","-15281935","15.5939430","3.49252839E-224"); 4805 mathtest(260,def,"2.96253492","20.7444888","23.7070237","-17.7819539","61.4562725","0.142810698","0","2.96253492","8.03402246E+9"); 4806 mathtest(261,def,"53553.3750E+386955423","-732470876","5.35533750E+386955427","5.35533750E+386955427","-3.92262875E+386955436","-7.31133165E+386955418","","",""); 4807 mathtest(262,def,"-696451.406E-286535917","-73086090.8","-73086090.8","73086090.8","5.09009107E-286535904","9.52919219E-286535920","0","-6.96451406E-286535912",""); 4808 mathtest(263,def,"1551.29957","-580358622.E+117017265","-5.80358622E+117017273","5.80358622E+117017273","-9.00310081E+117017276","-2.67300168E-117017271","0","1551.29957","7.17506711E-20"); 4809 mathtest(264,def,"-205123006.E-213752799","-78638468.6","-78638468.6","78638468.6","1.61305591E-213752783","2.60843083E-213752799","0","-2.05123006E-213752791",""); 4810 mathtest(265,def,"77632.8073","-3378542.88E+677441319","-3.37854288E+677441325","3.37854288E+677441325","-2.62285768E+677441330","-2.29781921E-677441321","0","77632.8073","2.13729331E-15"); 4811 mathtest(266,def,"3068999.37","2.21006212","3069001.58","3068997.16","6782679.25","1388648.46","1388648","1.02718624","9.41875713E+12"); 4812 mathtest(267,def,"625524274.","55.2468624","625524329","625524219","3.45582535E+10","11322349.3","11322349","16.7522224","6.21482943E+483"); 4813 mathtest(268,def,"61269134.9","-845761303.","-784492168","907030438","-5.18190634E+16","-0.0724425848","0","61269134.9",""); 4814 mathtest(269,def,"-2840.12099","-2856.76731E-82743650","-2840.12099","-2840.12099","8.11356480E-82743644","9.94173022E+82743649","","","-4.36505254E-11"); 4815 mathtest(270,def,"8.9538781","-7.56603391","1.38784419","16.5199120","-67.7453453","-1.18343087","-1","1.38784419","2.42053061E-8"); 4816 mathtest(271,def,"-56233547.2","509752530","453518983","-565986077","-2.86651930E+16","-0.110315386","0","-56233547.2",""); 4817 mathtest(272,def,"-3167.47853E-854859497","-110852115","-110852115","110852115","3.51121694E-854859486","2.85739116E-854859502","0","-3.16747853E-854859494",""); 4818 mathtest(273,def,"-5652.52092","-632243244.","-632248897","632237592","3.57376816E+12","0.00000894042123","0","-5652.52092",""); 4819 mathtest(274,def,"-946.009928","820090.66E-589278015","-946.009928","-946.009928","-7.75813906E-589278007","-1.15354311E+589278012","","","6.41454053E+23"); 4820 mathtest(275,def,"-367.757758","-959.626016","-1327.38377","591.868258","352909.912","0.383230292","0","-367.757758","1.14982199E-2463"); 4821 mathtest(276,def,"809926721.E-744611554","-67.6560549","-67.6560549","67.6560549","-5.47964467E-744611544","-1.19712378E-744611547","0","8.09926721E-744611546",""); 4822 mathtest(277,def,"-1725.08555","75586.3031","73861.2176","-77311.3887","-130392839","-0.0228227269","0","-1725.08555","3.70540587E+244657"); 4823 mathtest(278,def,"2659.84191E+29314492","-74372.4551E+518196680","-7.43724551E+518196684","7.43724551E+518196684","-1.97818973E+547511180","-3.5763804E-488882190","0","2.65984191E+29314495","1.06171811E-205201468"); 4824 mathtest(279,def,"-91.1431113","12147507.0","12147415.9","-12147598.1","-1.10716158E+9","-0.00000750303015","0","-91.1431113","-1.52417006E+23805759"); 4825 mathtest(280,def,"-1136778.91E+697783878","-801552569.","-1.13677891E+697783884","-1.13677891E+697783884","9.11188056E+697783892","1.41822128E+697783875","","",""); 4826 mathtest(281,def,"73123773.0E+433334149","63.3548930","7.31237730E+433334156","7.31237730E+433334156","4.63274881E+433334158","1.15419298E+433334155","","",""); 4827 mathtest(282,def,"-9765484.8","7979.90802E-234029715","-9765484.80","-9765484.80","-7.79276705E-234029705","-1.22375907E+234029718","","","8.27085614E+55"); 4828 mathtest(283,def,"-695010288","-8.26582820","-695010296","-695010280","5.74483564E+9","84082353.4","84082353","-3.45024540","1.83683495E-71"); 4829 mathtest(284,def,"23975643.3E-155955264","-505547.692E+137258948","-5.05547692E+137258953","5.05547692E+137258953","-1.21208311E-18696303","-4.7425087E-293214211","0","2.39756433E-155955257","1.26225952E+779776283"); 4830 mathtest(285,def,"2862.95921","-32601248.6E-605861333","2862.95921","2862.95921","-9.33360449E-605861323","-8.78174712E+605861328","","","4.26142175E-11"); 4831 mathtest(286,def,"-13.133518E+246090516","-8.71269925E-945092108","-1.31335180E+246090517","-1.31335180E+246090517","1.14428392E-699001590","","","",""); 4832 mathtest(287,def,"-34671.2232","817710.762","783039.539","-852381.985","-2.83510323E+10","-0.0424003508","0","-34671.2232","-5.30788828E+3712382"); 4833 mathtest(288,def,"-22464769","62.4366060","-22464706.6","-22464831.4","-1.40262393E+9","-359801.252","-359801","-15.7245940","6.21042536E+455"); 4834 mathtest(289,def,"-9458.60887E-563051963","5676056.01","5676056.01","-5676056.01","-5.36875937E-563051953","-1.66640513E-563051966","0","-9.45860887E-563051960",""); 4835 mathtest(290,def,"-591.924123E-95331874","-134.596188","-134.596188","134.596188","7.96707305E-95331870","4.39777777E-95331874","0","-5.91924123E-95331872",""); 4836 mathtest(291,def,"-182566085.E+68870646","-960345993.","-1.82566085E+68870654","-1.82566085E+68870654","1.75326608E+68870663","1.9010449E+68870645","","",""); 4837 mathtest(292,def,"8232.54893","-99822004E+891979845","-9.98220040E+891979852","9.98220040E+891979852","-8.21789532E+891979856","-8.24722867E-891979850","0","8232.54893","6.99289156E-40"); 4838 mathtest(293,def,"-4336.94317","-819373.601E+563233430","-8.19373601E+563233435","8.19373601E+563233435","3.55357674E+563233439","5.29299841E-563233433","0","-4336.94317","7.98969405E-30"); 4839 mathtest(294,def,"-2.09044362E-876527908","-6515463.33","-6515463.33","6515463.33","1.36202087E-876527901","3.20843433E-876527915","0","-2.09044362E-876527908",""); 4840 mathtest(295,def,"-194343.344","1.95929977","-194341.385","-194345.303","-380776.869","-99190.2041","-99190","-0.39981370","3.77693354E+10"); 4841 mathtest(296,def,"-326002.927","4215.99030","-321786.937","-330218.917","-1.37442518E+9","-77.3253503","-77","-1371.67390","5.51875821E+23243"); 4842 mathtest(297,def,"-12037.8590E+876429044","314.81827","-1.20378590E+876429048","-1.20378590E+876429048","-3.78973794E+876429050","-3.82374854E+876429045","","",""); 4843 mathtest(298,def,"21036045.4E-162804809","-91.7149219","-91.7149219","91.7149219","-1.92931926E-162804800","-2.2936339E-162804804","0","2.10360454E-162804802",""); 4844 mathtest(299,def,"-947019.534","9916.29280","-937103.241","-956935.827","-9.39092299E+9","-95.5013686","-95","-4971.71800","3.76029022E+59261"); 4845 mathtest(300,def,"-5985.84136","-12.4090184E-12364204","-5985.84136","-5985.84136","7.42784156E-12364200","4.82378313E+12364206","","","-0.000167060893"); 4846 mathtest(301,def,"-85344379.4","-6783.08669E+218840215","-6.78308669E+218840218","6.78308669E+218840218","5.78898324E+218840226","1.25819385E-218840211","0","-85344379.4","-3.03232347E-56"); 4847 mathtest(302,def,"-94.1947070E-938257103","15003.240","15003.2400","-15003.2400","-1.41322580E-938257097","-6.27829102E-938257106","0","-9.41947070E-938257102",""); 4848 mathtest(303,def,"-4846233.6","-8289769.76","-13136003.4","3443536.16","4.01741607E+13","0.584604125","0","-4846233.6","4.25077524E-55420465"); 4849 mathtest(304,def,"67.9147198","-108373645.E+291715415","-1.08373645E+291715423","1.08373645E+291715423","-7.36016573E+291715424","-6.26671916E-291715422","0","67.9147198","0.0147243485"); 4850 mathtest(305,def,"1958.77994","5.57285137E+690137826","5.57285137E+690137826","-5.57285137E+690137826","1.09159895E+690137830","3.51486126E-690137824","0","1958.77994","5.64824968E+19"); 4851 mathtest(306,def,"22780314.3","8805279.83","31585594.1","13975034.5","2.00587042E+14","2.58711986","2","5169754.64","2.39132169E+64785373"); 4852 mathtest(307,def,"596745.184","197602423.","198199168","-197005678","1.17918294E+14","0.00301992848","0","596745.184",""); 4853 mathtest(308,def,"171.340497","-480349.924","-480178.584","480521.264","-82303394.7","-0.000356699332","0","171.340497","2.17914102E-1073035"); 4854 mathtest(309,def,"824.65555","-379287.530","-378462.875","380112.186","-312781567","-0.00217422268","0","824.65555","6.35829256E-1106108"); 4855 mathtest(310,def,"19.3164031","-9207644.24E+988115069","-9.20764424E+988115075","9.20764424E+988115075","-1.77858568E+988115077","-2.09786592E-988115075","0","19.3164031","2.67093711E-12"); 4856 mathtest(311,def,"-3123.77646E+177814265","973284435.E+383256112","9.73284435E+383256120","-9.73284435E+383256120","-3.04032301E+561070389","-3.20952062E-205441853","0","-3.12377646E+177814268",""); 4857 mathtest(312,def,"-850.123915E+662955309","6774849.81E-846576865","-8.50123915E+662955311","-8.50123915E+662955311","-5.75946184E-183621547","","","",""); 4858 mathtest(313,def,"-23349.7724","2921.35355","-20428.4189","-26271.1260","-68212940.5","-7.99279238","-7","-2900.29755","-5.6705546E+12759"); 4859 mathtest(314,def,"18886653.3","568707476.","587594129","-549820823","1.07409809E+16","0.0332097855","0","18886653.3",""); 4860 mathtest(315,def,"-90552818.0","-542.03563E-986606878","-90552818.0","-90552818.0","4.90828538E-986606868","1.67060638E+986606883","","","-1.64244241E-40"); 4861 mathtest(316,def,"41501126.1E+791838765","-69.6651675E+204268348","4.15011261E+791838772","4.15011261E+791838772","-2.89118290E+996107122","-5.95722763E+587570422","","",""); 4862 mathtest(317,def,"76783193.3E-271488154","3765.01829E-520346003","7.67831933E-271488147","7.67831933E-271488147","2.89090127E-791834146","2.03938434E+248857853","","",""); 4863 mathtest(318,def,"4192.9928","987822007E-146560989","4192.99280","4192.99280","4.14193056E-146560977","4.24468454E+146560983","","","1.67973653E+36"); 4864 mathtest(319,def,"-891845.629","48277955.","47386109.4","-49169800.6","-4.30564831E+13","-0.0184731443","0","-891845.629","-6.32964147E+287267817"); 4865 mathtest(320,def,"334.901176","-7609296.55E+447340228","-7.60929655E+447340234","7.60929655E+447340234","-2.54836236E+447340237","-4.40121073E-447340233","0","334.901176","6.31926575E-21"); 4866 mathtest(321,def,"4.49868636","-341880896E-447251873","4.49868636","4.49868636","-1.53801492E-447251864","-1.31586363E+447251865","","","0.010983553"); 4867 mathtest(322,def,"807615.58","-314286480","-313478865","315094096","-2.53822658E+14","-0.00256967968","0","807615.58",""); 4868 mathtest(323,def,"-37.7457954","53277.8129E-859225538","-37.7457954","-37.7457954","-2.01101343E-859225532","-7.08471188E+859225534","","","-76620134.1"); 4869 mathtest(324,def,"-28671081.","98.8819623","-28670982.1","-28671179.9","-2.83505275E+9","-289952.589","-289952","-58.2671904","-1.93625566E+738"); 4870 mathtest(325,def,"-89752.2106E-469496896","99.9879961","99.9879961","-99.9879961","-8.97414368E-469496890","-8.97629857E-469496894","0","-8.97522106E-469496892",""); 4871 mathtest(326,def,"-497983567E-13538052","39.4578742","39.4578742","-39.4578742","-1.96493729E-13538042","-1.26206385E-13538045","0","-4.97983567E-13538044","-1.55376543E-527983689"); 4872 mathtest(327,def,"845739221E-654202565","-33313.1551","-33313.1551","33313.1551","-2.81742418E-654202552","-2.53875449E-654202561","0","8.45739221E-654202557",""); 4873 mathtest(328,def,"742.332067E+537827843","-4532.70023E-855387414","7.42332067E+537827845","7.42332067E+537827845","-3.36476873E-317559565","","","",""); 4874 mathtest(329,def,"-893.48654","670389960","670389067","-670390853","-5.98984406E+11","-0.00000133278628","0","-893.48654",""); 4875 mathtest(330,def,"1.37697162","-915.737474E-351578724","1.37697162","1.37697162","-1.26094451E-351578721","-1.50367508E+351578721","","","0.0561920784"); 4876 mathtest(331,def,"-65.2839808E+550288403","-121389.306","-6.52839808E+550288404","-6.52839808E+550288404","7.92477712E+550288409","5.37806689E+550288399","","",""); 4877 mathtest(332,def,"-30346603.E+346067390","792661.544","-3.03466030E+346067397","-3.03466030E+346067397","-2.40545852E+346067403","-3.82844396E+346067391","","",""); 4878 mathtest(333,def,"-61170.7065","-453731131.","-453792302","453669960","2.77550538E+13","0.000134817081","0","-61170.7065",""); 4879 mathtest(334,def,"6569.51133","13.8706351E+399434914","1.38706351E+399434915","-1.38706351E+399434915","9.11232944E+399434918","4.73627291E-399434912","0","6569.51133","6569.51133"); 4880 mathtest(335,def,"300703925.","-3156736.8","297547188","303860662","-9.49243146E+14","-95.2578387","-95","813929.0","4.18609114E-26763256"); 4881 mathtest(336,def,"192138216E+353011592","-473.080633","1.92138216E+353011600","1.92138216E+353011600","-9.08968688E+353011602","-4.06142637E+353011597","","",""); 4882 mathtest(337,def,"8607.64794","-34740.3367","-26132.6888","43347.9846","-299032588","-0.247770999","0","8607.64794","1.29604519E-136698"); 4883 mathtest(338,def,"-67913.8241","-93815.4229","-161729.247","25901.5988","6.37136413E+9","0.723908948","0","-67913.8241","-6.96355203E-453311"); 4884 mathtest(339,def,"34.5559455","-998799398.","-998799364","998799433","-3.45144576E+10","-3.45974833E-8","0","34.5559455",""); 4885 mathtest(340,def,"387995.328","990199543.E-124623607","387995.328","387995.328","3.84192796E-124623593","3.91835495E+124623603","","","7.73152138E+55"); 4886 mathtest(341,def,"-471.09166E-83521919","-441222368","-441222368","441222368","2.07856178E-83521908","1.06769669E-83521925","0","-4.7109166E-83521917",""); 4887 mathtest(342,def,"-97834.3858","70779789.8E+502166065","7.07797898E+502166072","-7.07797898E+502166072","-6.92469726E+502166077","-1.38223617E-502166068","0","-97834.3858","-8.57907886E+34"); 4888 mathtest(343,def,"7732331.06","-952719.482E+115325505","-9.52719482E+115325510","9.52719482E+115325510","-7.36674244E+115325517","-8.11606271E-115325505","0","7732331.06","1.30886724E-69"); 4889 mathtest(344,def,"23.2745547","2.23194245E-221062592","23.2745547","23.2745547","5.19474666E-221062591","1.04279368E+221062593","","","541.704896"); 4890 mathtest(345,def,"671.083363E-218324205","-787150031","-787150031","787150031","-5.28243290E-218324194","-8.52548227E-218324212","0","6.71083363E-218324203",""); 4891 mathtest(346,def,"365167.80","-80263.6516","284904.148","445431.452","-2.93097011E+10","-4.54960362","-4","44113.1936","1.27052227E-446468"); 4892 mathtest(347,def,"-1.43297604E-65129780","56.598733E-135581942","-1.43297604E-65129780","-1.43297604E-65129780","-8.11046283E-200711721","-2.53181646E+70452160","","","8.65831881E-390778680"); 4893 mathtest(348,def,"416998859.","260.220323E-349285593","416998859","416998859","1.08511578E-349285582","1.60248383E+349285599","","","7.25111178E+25"); 4894 mathtest(349,def,"7267.17611E+862630607","4021.56861","7.26717611E+862630610","7.26717611E+862630610","2.92254473E+862630614","1.80705014E+862630607","","",""); 4895 mathtest(350,def,"12.2142434E+593908740","5.27236571E-396050748","1.22142434E+593908741","1.22142434E+593908741","6.43979581E+197857993","2.3166533E+989959488","","",""); 4896 mathtest(351,def,"-28.591932","-1.79153238E-817064576","-28.5919320","-28.5919320","5.12233720E-817064575","1.59594838E+817064577","","","0.00122324372"); 4897 mathtest(352,def,"590.849666","753424.306E+277232744","7.53424306E+277232749","-7.53424306E+277232749","4.45160500E+277232752","7.84219014E-277232748","0","590.849666","1.48530607E+22"); 4898 mathtest(353,def,"1.7270628","-1325026.67","-1325024.94","1325028.40","-2288404.27","-0.00000130341739","0","1.7270628","2.09260036E-314440"); 4899 mathtest(354,def,"33402118.","-5534.83745","33396583.2","33407652.8","-1.84875294E+11","-6034.8869","-6034","4908.82670","8.14473913E-41645"); 4900 mathtest(355,def,"-439842.506","-775110.807","-1214953.31","335268.301","3.40926680E+11","0.567457584","0","-439842.506","-1.84678472E-4374182"); 4901 mathtest(356,def,"-248664.779","-440890.44E+666433944","-4.40890440E+666433949","4.40890440E+666433949","1.09633924E+666433955","5.64005831E-666433945","0","-248664.779","2.61542877E-22"); 4902 mathtest(357,def,"-14161.9142","8306.49493","-5855.4193","-22468.4091","-117635869","-1.70492059","-1","-5855.41927","1.65573372E+34479"); 4903 mathtest(358,def,"-6417227.13","16679.8842","-6400547.25","-6433907.01","-1.07038605E+11","-384.728518","-384","-12151.5972","3.58767978E+113546"); 4904 mathtest(359,def,"514825024.","-25.0446345E-103809457","514825024","514825024","-1.28936046E-103809447","-2.05563002E+103809464","","","7.32860062E-27"); 4905 mathtest(360,def,"525948196","219450390","745398586","306497806","1.15419537E+17","2.39666102","2","87047416",""); 4906 mathtest(361,def,"-638509.181","45580189.0E+269212559","4.55801890E+269212566","-4.55801890E+269212566","-2.91033691E+269212572","-1.40084803E-269212561","0","-638509.181","-1.06129405E+29"); 4907 mathtest(362,def,"330590422","74.359928E+535377965","7.43599280E+535377966","-7.43599280E+535377966","2.45826800E+535377975","4.44581418E-535377959","0","330590422","4.31550742E+59"); 4908 mathtest(363,def,"-3.48593871E-940579904","-20265.9640E-322988987","-2.02659640E-322988983","2.02659640E-322988983","","1.72009519E-617590921","0","-3.48593871E-940579904",""); 4909 mathtest(364,def,"-328103480.","-721.949371E-923938665","-328103480","-328103480","2.36874101E-923938654","4.54468822E+923938670","","","-2.4430038E-60"); 4910 mathtest(365,def,"-1857.01448","19081578.1","19079721.1","-19083435.1","-3.54347668E+10","-0.0000973197537","0","-1857.01448","8.44397087E+62374153"); 4911 mathtest(366,def,"347.28720E+145930771","-62821.9906E-676564106","3.47287200E+145930773","3.47287200E+145930773","-2.18172732E-530633328","-5.52811518E+822494874","","","5.69990135E-875584642"); 4912 mathtest(367,def,"-643.211399E+441807003","-50733419.2","-6.43211399E+441807005","-6.43211399E+441807005","3.26323135E+441807013","1.26782584E+441806998","","",""); 4913 mathtest(368,def,"-53991661.4E-843339554","20718.7346","20718.7346","-20718.7346","-1.11863890E-843339542","-2.60593431E-843339551","0","-5.39916614E-843339547",""); 4914 mathtest(369,def,"-900181424","-105763982.","-1.00594541E+9","-794417442","9.52067719E+16","8.51122856","8","-54069568","1.32627061E-947045602"); 4915 mathtest(370,def,"94218.7462E+563233951","19262.6382E+765263890","1.92626382E+765263894","-1.92626382E+765263894","","4.89126906E-202029939","0","9.42187462E+563233955",""); 4916 mathtest(371,def,"28549.271E+921331828","-2150590.40","2.85492710E+921331832","2.85492710E+921331832","-6.13977881E+921331838","-1.32750853E+921331826","","",""); 4917 mathtest(372,def,"810.7080E+779625763","5957.94044","8.10708000E+779625765","8.10708000E+779625765","4.83014998E+779625769","1.36071854E+779625762","","",""); 4918 mathtest(373,def,"-23.7357549E+77116908","351.100649E+864348022","3.51100649E+864348024","-3.51100649E+864348024","-8.33363895E+941464933","-6.7603848E-787231116","0","-2.37357549E+77116909","3.17403853E+308467637"); 4919 mathtest(374,def,"40216102.2E+292724544","661.025962","4.02161022E+292724551","4.02161022E+292724551","2.65838876E+292724554","6.08389148E+292724548","","",""); 4920 mathtest(375,def,"22785024.3E+783719168","399.505989E+137478666","2.27850243E+783719175","2.27850243E+783719175","9.10275367E+921197843","5.70329981E+646240506","","",""); 4921 mathtest(376,def,"515.591819E+821371364","-692137914.E-149498690","5.15591819E+821371366","5.15591819E+821371366","-3.56860646E+671872685","-7.44926421E+970870047","","",""); 4922 mathtest(377,def,"-536883072E+477911251","624996.301","-5.36883072E+477911259","-5.36883072E+477911259","-3.35549934E+477911265","-8.59017999E+477911253","","",""); 4923 mathtest(378,def,"-399492.914E-334369192","5202119.87E+442442258","5.20211987E+442442264","-5.20211987E+442442264","-2.07821003E+108073078","-7.67942539E-776811452","0","-3.99492914E-334369187",""); 4924 mathtest(379,def,"762.071184","9851631.37","9852393.44","-9850869.30","7.50764438E+9","0.0000773548213","0","762.071184","4.02198436E+28392356"); 4925 mathtest(380,def,"5626.12471","72989818.3","72995444.4","-72984192.2","4.10649820E+11","0.0000770809524","0","5626.12471","1.79814757E+273727098"); 4926 mathtest(381,def,"-47207260.1","-2073.3152","-47209333.4","-47205186.8","9.78755299E+10","22768.9741","22768","-2019.6264","-6.02238319E-15909"); 4927 mathtest(382,def,"207.740860","-51.0390090","156.701851","258.779869","-10602.8876","-4.07023694","-4","3.5848240","6.40297515E-119"); 4928 mathtest(383,def,"-572.812464E-745934021","-182805872.E+604508681","-1.82805872E+604508689","1.82805872E+604508689","1.04713482E-141425329","","0","-5.72812464E-745934019",""); 4929 mathtest(384,def,"-6418504E+3531407","8459416.1","-6.41850400E+3531413","-6.41850400E+3531413","-5.42967961E+3531420","-7.58740784E+3531406","","",""); 4930 mathtest(385,def,"280689.531","-128212543","-127931854","128493233","-3.59879186E+13","-0.00218925173","0","280689.531","1.42173809E-698530938"); 4931 mathtest(386,def,"15.803551E-783422793","239108038E-489186308","2.39108038E-489186300","-2.39108038E-489186300","","6.60937672E-294236493","0","1.5803551E-783422792",""); 4932 mathtest(387,def,"26.515922","-9418242.96E-105481628","26.5159220","26.5159220","-2.49733396E-105481620","-2.81537885E+105481622","","","1.54326108E-13"); 4933 mathtest(388,def,"-88.1094557","-54029934.1","-54030022.2","54029846.0","4.76054809E+9","0.0000016307526","0","-88.1094557","5.05289826E-105089439"); 4934 mathtest(389,def,"6770.68602E-498420397","-6.11248908E-729616908","6.77068602E-498420394","6.77068602E-498420394","","-1.10768067E+231196514","","",""); 4935 mathtest(390,def,"-892973818.E-781904441","555201299.","555201299","-555201299","-4.95780224E-781904424","-1.60837847E-781904441","0","-8.92973818E-781904433",""); 4936 mathtest(391,def,"670175802E+135430680","27355195.4","6.70175802E+135430688","6.70175802E+135430688","1.83327900E+135430696","2.44990318E+135430681","","",""); 4937 mathtest(392,def,"-440950.26","205.477469E-677345561","-440950.260","-440950.260","-9.06053434E-677345554","-2.14597864E+677345564","","","1.94437132E+11"); 4938 mathtest(393,def,"-8.2335779","573665010E+742722075","5.73665010E+742722083","-5.73665010E+742722083","-4.72331555E+742722084","-1.43525886E-742722083","0","-8.2335779","311552.753"); 4939 mathtest(394,def,"452943.863","7022.23629","459966.099","445921.627","3.18067883E+9","64.5013703","64","3520.74044","5.54158976E+39716"); 4940 mathtest(395,def,"62874.1079","-52719654.1","-52656780.0","52782528.2","-3.31470122E+12","-0.0011926123","0","62874.1079","1.18819936E-252973775"); 4941 mathtest(396,def,"-7428.41741E+609772037","-46024819.3","-7.42841741E+609772040","-7.42841741E+609772040","3.41891569E+609772048","1.61400251E+609772033","","",""); 4942 mathtest(397,def,"2.27959297","41937.019","41939.2986","-41934.7394","95599.3337","0.0000543575348","0","2.27959297","2.89712423E+15007"); 4943 mathtest(398,def,"508692408E-671967782","8491989.20","8491989.20","-8491989.20","4.31981043E-671967767","5.99026207E-671967781","0","5.08692408E-671967774",""); 4944 mathtest(399,def,"940.533705E-379310421","-4.01176961E+464620037","-4.01176961E+464620037","4.01176961E+464620037","-3.77320453E+85309619","-2.34443599E-843930456","0","9.40533705E-379310419",""); 4945 mathtest(400,def,"97.0649652","-92.4485649E-151989098","97.0649652","97.0649652","-8.97351673E-151989095","-1.0499348E+151989098","","","1.30748728E-18"); 4946 mathtest(401,def,"297544.536E+360279473","8.80275007","2.97544536E+360279478","2.97544536E+360279478","2.61921019E+360279479","3.38013159E+360279477","","",""); 4947 mathtest(402,def,"-28861028.","82818.820E+138368758","8.28188200E+138368762","-8.28188200E+138368762","-2.39023628E+138368770","-3.48483932E-138368756","0","-28861028","4.81387013E+59"); 4948 mathtest(403,def,"36.2496238E+68828039","49243.00","3.62496238E+68828040","3.62496238E+68828040","1.78504022E+68828045","7.36137599E+68828035","","",""); 4949 mathtest(404,def,"22.447828E-476014683","-56067.5520","-56067.5520","56067.5520","-1.25859476E-476014677","-4.00371109E-476014687","0","2.2447828E-476014682",""); 4950 mathtest(405,def,"282688.791E+75011952","5.99789051","2.82688791E+75011957","2.82688791E+75011957","1.69553642E+75011958","4.7131369E+75011956","","","5.10330507E+450071744"); 4951 mathtest(406,def,"-981.860310E-737387002","-994046289","-994046289","994046289","9.76014597E-737386991","9.87741035E-737387009","0","-9.81860310E-737387000",""); 4952 mathtest(407,def,"-702.91210","-6444903.55","-6445606.46","6444200.64","4.53020069E+9","0.000109064797","0","-702.91210","1.70866703E-18348004"); 4953 mathtest(408,def,"972456720E-17536823","16371.2590","16371.2590","-16371.2590","1.59203408E-17536810","5.94002404E-17536819","0","9.72456720E-17536815",""); 4954 mathtest(409,def,"71471.2045","-74303278.4","-74231807.2","74374749.6","-5.31054481E+12","-0.00096188494","0","71471.2045","2.14535374E-360677853"); 4955 mathtest(410,def,"643.103951E+439708441","788251925.","6.43103951E+439708443","6.43103951E+439708443","5.06927927E+439708452","8.15860933E+439708434","","",""); 4956 mathtest(411,def,"4.30838663","-7.43110827","-3.12272164","11.7394949","-32.0160875","-0.579777131","0","4.30838663","0.0000362908645"); 4957 mathtest(412,def,"823.678025","-513.581840E-324453141","823.678025","823.678025","-4.23026076E-324453136","-1.60379118E+324453141","","","2.63762228E-15"); 4958 mathtest(413,def,"4461.81162","3.22081680","4465.03244","4458.59080","14370.6778","1385.30438","1385","0.98035200","8.8824688E+10"); 4959 mathtest(414,def,"-4458527.10","-99072605","-103531132","94614077.9","4.41717894E+14","0.0450026231","0","-4458527.10","-6.23928099E-658752715"); 4960 mathtest(415,def,"-577964618","487424368.","-90540250","-1.06538899E+9","-2.81714039E+17","-1.18575241","-1","-90540250",""); 4961 mathtest(416,def,"-867.036184","-57.1768608","-924.213045","-809.859323","49574.4072","15.1641096","15","-9.3832720","-3.40312837E-168"); 4962 mathtest(417,def,"771871921E-330504770","5.34285236","5.34285236","-5.34285236","4.12399771E-330504761","1.44468136E-330504762","0","7.71871921E-330504762",""); 4963 mathtest(418,def,"-338683.062E-728777518","166441931","166441931","-166441931","-5.63710628E-728777505","-2.03484218E-728777521","0","-3.38683062E-728777513",""); 4964 mathtest(419,def,"-512568743","-416376887.E-965945295","-512568743","-512568743","2.13421778E-965945278","1.23102112E+965945295","","","1.44874358E-35"); 4965 mathtest(420,def,"7447181.99","5318438.52","12765620.5","2128743.47","3.96073796E+13","1.40025723","1","2128743.47","1.21634782E+36548270"); 4966 mathtest(421,def,"54789.8207","93165435.2","93220225.0","-93110645.4","5.10451749E+12","0.000588091716","0","54789.8207","3.80769825E+441483035"); 4967 mathtest(422,def,"41488.5960","146.797094","41635.3931","41341.7989","6090405.33","282.625459","282","91.815492","6.84738153E+678"); 4968 mathtest(423,def,"785741.663E+56754529","-461.531732","7.85741663E+56754534","7.85741663E+56754534","-3.62644711E+56754537","-1.70246509E+56754532","","",""); 4969 mathtest(424,def,"-4.95436786","-3132.4233","-3137.37767","3127.46893","15519.1773","0.0015816406","0","-4.95436786","1.98062422E-2177"); 4970 mathtest(425,def,"77321.8478E+404626874","82.4797688","7.73218478E+404626878","7.73218478E+404626878","6.37748813E+404626880","9.3746441E+404626876","","",""); 4971 mathtest(426,def,"-7.99307725","-29153.7273","-29161.7204","29145.7342","233027.994","0.000274169994","0","-7.99307725","1.88688028E-26318"); 4972 mathtest(427,def,"-61.6337401E+474999517","5254.87092","-6.16337401E+474999518","-6.16337401E+474999518","-3.23877349E+474999522","-1.1728878E+474999515","","",""); 4973 mathtest(428,def,"-16.4043088","35.0064812","18.6021724","-51.4107900","-574.257128","-0.468607762","0","-16.4043088","-3.33831843E+42"); 4974 mathtest(429,def,"-8.41156520","-56508958.9","-56508967.3","56508950.5","475328792","1.48853657E-7","0","-8.41156520","-8.86365458E-52263827"); 4975 mathtest(430,def,"-360165.79E+503559835","-196688.515","-3.60165790E+503559840","-3.60165790E+503559840","7.08404744E+503559845","1.83114805E+503559835","","",""); 4976 mathtest(431,def,"-653236480.E+565648495","-930.445274","-6.53236480E+565648503","-6.53236480E+565648503","6.07800796E+565648506","7.02068674E+565648500","","",""); 4977 mathtest(432,def,"-3.73342903","855.029289","851.295860","-858.762718","-3192.19117","-0.00436643408","0","-3.73342903","-1.41988961E+489"); 4978 mathtest(433,def,"-5.14890532E+562048011","10847127.8E-390918910","-5.14890532E+562048011","-5.14890532E+562048011","-5.58508340E+171129108","-4.74679142E+952966914","","","-5.14890532E+562048011"); 4979 mathtest(434,def,"653311907","-810.036965E+744537823","-8.10036965E+744537825","8.10036965E+744537825","-5.29206794E+744537834","-8.06521104E-744537818","0","653311907","3.01325171E-71"); 4980 mathtest(435,def,"-1.31557907","98.9139300E-579281802","-1.31557907","-1.31557907","-1.30129096E-579281800","-1.33002406E+579281800","","","15.529932"); 4981 mathtest(436,def,"-875192389","-72071565.6","-947263955","-803120823","6.30764857E+16","12.1433797","12","-10333601.8","1.25564408E-644471405"); 4982 mathtest(437,def,"-72838078.8","-391.398423","-72838470.2","-72837687.4","2.85087092E+10","186097.017","186097","-6.474969","-6.574057E-3075"); 4983 mathtest(438,def,"29186560.9","-79.7419988","29186481.2","29186640.6","-2.32739470E+9","-366012.407","-366012","32.4352144","6.10050869E-598"); 4984 mathtest(439,def,"-329801660E-730249465","-6489.9256","-6489.92560","6489.92560","2.14038824E-730249453","5.08174793E-730249461","0","-3.29801660E-730249457",""); 4985 mathtest(440,def,"91.8429117E+103164883","7131455.16","9.18429117E+103164884","9.18429117E+103164884","6.54973607E+103164891","1.28785654E+103164878","","",""); 4986 mathtest(441,def,"3943866.38E+150855113","-31927007.3","3.94386638E+150855119","3.94386638E+150855119","-1.25915851E+150855127","-1.23527594E+150855112","","",""); 4987 mathtest(442,def,"-7002.0468E-795962156","-5937891.05","-5937891.05","5937891.05","4.15773910E-795962146","1.17921443E-795962159","0","-7.0020468E-795962153",""); 4988 mathtest(443,def,"696504605.","54506.4617","696559111","696450099","3.79640016E+13","12778.386","12778","21037.3974","2.6008532E+481992"); 4989 mathtest(444,def,"-5115.76467","690.960979E+815126701","6.90960979E+815126703","-6.90960979E+815126703","-3.53479376E+815126707","-7.4038402E-815126701","0","-5115.76467","-9.17009655E+25"); 4990 mathtest(445,def,"-261.279392","-613.079357","-874.358749","351.799965","160185.002","0.426175484","0","-261.279392","-2.06318841E-1482"); 4991 mathtest(446,def,"-591407763","-80145822.8","-671553586","-511261940","4.73988618E+16","7.37914644","7","-30387003.4","-2.79334522E-703030105"); 4992 mathtest(447,def,"615630407","-69.4661869","615630338","615630476","-4.27654969E+10","-8862303.15","-8862303","10.4375693","3.44283102E-607"); 4993 mathtest(448,def,"1078757.50","27402569.0E-713742082","1078757.50","1078757.50","2.95607268E-713742069","3.93670207E+713742080","","","1.25536924E+18"); 4994 mathtest(449,def,"-4865.60358E-401116515","66952.5315","66952.5315","-66952.5315","-3.25764477E-401116507","-7.26724363E-401116517","0","-4.86560358E-401116512",""); 4995 mathtest(450,def,"-87805.3921E-934896690","-1875.14745","-1875.14745","1875.14745","1.64648057E-934896682","4.68258601E-934896689","0","-8.78053921E-934896686",""); 4996 mathtest(451,def,"-232540609.E+602702520","68.0834223","-2.32540609E+602702528","-2.32540609E+602702528","-1.58321605E+602702530","-3.41552468E+602702526","","",""); 4997 mathtest(452,def,"-320610803.","-863871235.","-1.18448204E+9","543260432","2.76966450E+17","0.37113263","0","-320610803",""); 4998 mathtest(453,def,"-303956364E+278139979","229537.920E+479603725","2.29537920E+479603730","-2.29537920E+479603730","-6.97695116E+757743717","-1.3242098E-201463743","0","-3.03956364E+278139987","9.23894712E+556279974"); 4999 mathtest(454,def,"-439.747348","74.9494457E-353117582","-439.747348","-439.747348","-3.29588200E-353117578","-5.86725284E+353117582","","","-3.17996693E+18"); 5000 mathtest(455,def,"-89702231.9","1.28993993","-89702230.6","-89702233.2","-115710491","-69539852.1","-69539852","-0.07890964","-89702231.9"); 5001 mathtest(456,def,"-5856939.14","-6743375.34","-12600314.5","886436.20","3.94955390E+13","0.868547107","0","-5856939.14","-3.29213248E-45636942"); 5002 mathtest(457,def,"733317.669E+100381349","-13832.6792E+174055607","-1.38326792E+174055611","1.38326792E+174055611","-1.01437481E+274436966","-5.30134227E-73674257","0","7.33317669E+100381354","1.36366549E-100381355"); 5003 mathtest(458,def,"87.4798787E-80124704","108497.32","108497.320","-108497.320","9.49133239E-80124698","8.06286079E-80124708","0","8.74798787E-80124703",""); 5004 mathtest(459,def,"-694562052","310681.319E+549445264","3.10681319E+549445269","-3.10681319E+549445269","-2.15787454E+549445278","-2.23560932E-549445261","0","-694562052","-3.35068155E+26"); 5005 mathtest(460,def,"-9744135.85","1797016.04","-7947119.81","-11541151.9","-1.75103684E+13","-5.42239782","-5","-759055.65","3.83848006E+12558883"); 5006 mathtest(461,def,"3625.87308","-50.2208536E+658627487","-5.02208536E+658627488","5.02208536E+658627488","-1.82094441E+658627492","-7.21985554E-658627486","0","3625.87308","1.5956477E-18"); 5007 mathtest(462,def,"365347.52","-3655414.47","-3290066.95","4020761.99","-1.33549661E+12","-0.099946948","0","365347.52","1.02663257E-20333994"); 5008 mathtest(463,def,"-19706333.6E-816923050","-383858032.","-383858032","383858032","7.56443443E-816923035","5.1337557E-816923052","0","-1.97063336E-816923043",""); 5009 mathtest(464,def,"-86346.2616","-98.8063785","-86445.0680","-86247.4552","8531561.41","873.893598","873","-88.2931695","-2.05064086E-489"); 5010 mathtest(465,def,"-445588.160E-496592215","328.822976","328.822976","-328.822976","-1.46519625E-496592207","-1.35510044E-496592212","0","-4.45588160E-496592210",""); 5011 mathtest(466,def,"-9709213.71","-34.6690137","-9709248.38","-9709179.04","336608863","280054.512","280054","-17.7472602","-2.80903974E-245"); 5012 mathtest(467,def,"742395536.","-43533.6889","742352002","742439070","-3.23192163E+13","-17053.3569","-17053","15539.1883","5.7622734E-386175"); 5013 mathtest(468,def,"-878849193.","-5842982.47E-972537342","-878849193","-878849193","5.13510043E-972537327","1.50411061E+972537344","","","2.17027042E-54"); 5014 mathtest(469,def,"-78014142.1","-624658.522","-78638800.6","-77389483.6","4.87321987E+13","124.890863","124","-556485.372","-7.86063865E-4929918"); 5015 mathtest(470,def,"857039.371","454.379672","857493.751","856584.991","389421268","1886.17454","1886","79.309608","3.82253101E+2693"); 5016 mathtest(471,def,"166534010.","-173.012236","166533837","166534183","-2.88124214E+10","-962556.255","-962556","44.164784","4.78620664E-1423"); 5017 mathtest(472,def,"-810.879063","43776.610","42965.7309","-44587.4891","-35497536.5","-0.0185231123","0","-810.879063","-2.34758691E+127345"); 5018 mathtest(473,def,"-327.127935","93458944","93458616.9","-93459271.1","-3.05730314E+10","-0.00000350023145","0","-327.127935","2.29323021E+235022854"); 5019 mathtest(474,def,"539295218.","-9587941.10E-309643098","539295218","539295218","-5.17073079E-309643083","-5.62472394E+309643099","","","4.80545269E-88"); 5020 mathtest(475,def,"-3862702.65","879616.733","-2983085.92","-4742319.38","-3.39769789E+12","-4.3913474","-4","-344235.718","-3.50650167E+5793941"); 5021 mathtest(476,def,"-8.25290500","992.091584E+256070257","9.92091584E+256070259","-9.92091584E+256070259","-8.18763759E+256070260","-8.31869268E-256070260","0","-8.25290500","1.46577888E+9"); 5022 mathtest(477,def,"546875205.","447.52857E+557357101","4.47528570E+557357103","-4.47528570E+557357103","2.44742278E+557357112","1.22198948E-557357095","0","546875205","8.94443542E+34"); 5023 mathtest(478,def,"177623437","-7779116.14","169844321","185402553","-1.38175335E+15","-22.83337","-22","6482881.92","2.90085309E-64173820"); 5024 mathtest(479,def,"377204735.","13768.1401","377218503","377190967","5.19340764E+12","27396.9274","27396","12768.8204","2.06065297E+118082"); 5025 mathtest(480,def,"-2435.49239","-11732.0640E-23331504","-2435.49239","-2435.49239","2.85733526E-23331497","2.07592832E+23331503","","","-0.00041059459"); 5026 mathtest(481,def,"-6128465.14E-137123294","-5742264.27","-5742264.27","5742264.27","3.51912664E-137123281","1.06725585E-137123294","0","-6.12846514E-137123288",""); 5027 mathtest(482,def,"-2898065.44","-5.11638105","-2898070.56","-2898060.32","14827607.1","566428.773","566428","-3.95461060","-4.89169151E-33"); 5028 mathtest(483,def,"1851395.31E+594383160","-550301.475","1.85139531E+594383166","1.85139531E+594383166","-1.01882557E+594383172","-3.36432918E+594383160","","",""); 5029 mathtest(484,def,"536412589.E+379583977","899.601161","5.36412589E+379583985","5.36412589E+379583985","4.82557388E+379583988","5.96278231E+379583982","","",""); 5030 mathtest(485,def,"185.85297","867419480.","867419666","-867419294","1.61212487E+11","2.14259622E-7","0","185.85297",""); 5031 mathtest(486,def,"-5.26631053","-3815941.35E+183291763","-3.81594135E+183291769","3.81594135E+183291769","2.00959321E+183291770","1.38008162E-183291769","0","-5.26631053","0.00130009218"); 5032 mathtest(487,def,"-8.11587021E-245942806","4553.06753E+943412048","4.55306753E+943412051","-4.55306753E+943412051","-3.69521051E+697469246","","0","-8.11587021E-245942806",""); 5033 mathtest(488,def,"-405765.352","854963231","854557466","-855368996","-3.46914456E+14","-0.000474599769","0","-405765.352",""); 5034 mathtest(489,def,"-159.609757","-43356.7567","-43516.3665","43197.1470","6920161.40","0.00368131219","0","-159.609757","-8.95397849E-95519"); 5035 mathtest(490,def,"-564240.241E-501316672","-557.781977","-557.781977","557.781977","3.14723037E-501316664","1.01157847E-501316669","0","-5.64240241E-501316667",""); 5036 mathtest(491,def,"318847.270","582107878.E+399633412","5.82107878E+399633420","-5.82107878E+399633420","1.85603508E+399633426","5.47746014E-399633416","0","318847.270","1.0507423E+33"); 5037 mathtest(492,def,"-4426.59663","95.1096765","-4331.48695","-4521.70631","-421012.173","-46.5420217","-46","-51.5515110","-2.38037379E+346"); 5038 mathtest(493,def,"6037.28310","578264.105","584301.388","-572226.822","3.49114411E+9","0.010440356","0","6037.28310","3.57279483E+2186324"); 5039 mathtest(494,def,"-66.9556692","-53.8519404","-120.807610","-13.1037288","3605.69271","1.24332881","1","-13.1037288","2.55554086E-99"); 5040 mathtest(495,def,"-92486.0222","-59935.8544","-152421.877","-32550.1678","5.54322876E+9","1.5430834","1","-32550.1678","1.83152656E-297647"); 5041 mathtest(496,def,"852136219.E+917787351","9246221.91","8.52136219E+917787359","8.52136219E+917787359","7.87904058E+917787366","9.21604767E+917787352","","",""); 5042 mathtest(497,def,"-2120096.16E-269253718","9437.00514","9437.00514","-9437.00514","-2.00073584E-269253708","-2.24657731E-269253716","0","-2.12009616E-269253712",""); 5043 mathtest(498,def,"-524653.169E-865784226","228054.698","228054.698","-228054.698","-1.19649620E-865784215","-2.30055848E-865784226","0","-5.24653169E-865784221",""); 5044 mathtest(499,def,"-288193133","-312268737.","-600461870","24075604","8.99937057E+16","0.922901011","0","-288193133",""); 5045 mathtest(500,def,"-373484759E-113589964","844101958E-852538240","-3.73484759E-113589956","-3.73484759E-113589956","-3.15259216E-966128187","-4.42464036E+738948275","","","3.78602147E-908719644"); 5046 } 5047 5048 /* mathtest -- general arithmetic test routine 5049 Arg1 is test number 5050 Arg2 is MathContext 5051 Arg3 is left hand side (LHS) 5052 Arg4 is right hand side (RHS) 5053 Arg5 is the expected result for add 5054 Arg6 is the expected result for subtract 5055 Arg7 is the expected result for multiply 5056 Arg8 is the expected result for divide 5057 Arg9 is the expected result for integerDivide 5058 Arg10 is the expected result for remainder 5059 Arg11 is the expected result for power 5060 5061 For power RHS, 0 is added to the number, any exponent is removed and 5062 the number is then rounded to an integer, using format(rhs+0,,0) 5063 5064 If an error should result for an operation, the 'expected result' is 5065 an empty string. 5066 */ 5067 5068 private void mathtest(int test, android.icu.math.MathContext mc, 5069 java.lang.String slhs, java.lang.String srhs, java.lang.String add, 5070 java.lang.String sub, java.lang.String mul, java.lang.String div, 5071 java.lang.String idv, java.lang.String rem, java.lang.String pow) { 5072 android.icu.math.BigDecimal lhs; 5073 android.icu.math.BigDecimal rhs; 5074 java.lang.String res = null; 5075 java.lang.String sn = null; 5076 int e = 0; 5077 5078 lhs = new android.icu.math.BigDecimal(slhs); 5079 rhs = new android.icu.math.BigDecimal(srhs); 5080 5081 try { 5082 res = lhs.add(rhs, mc).toString(); 5083 } catch (java.lang.ArithmeticException $137) { 5084 res = ""; 5085 } 5086 mathtestcheck(test, lhs, rhs, "add", res, add); 5087 5088 try { 5089 res = lhs.subtract(rhs, mc).toString(); 5090 } catch (java.lang.ArithmeticException $138) { 5091 res = ""; 5092 } 5093 mathtestcheck(test, lhs, rhs, "sub", res, sub); 5094 5095 try { 5096 res = lhs.multiply(rhs, mc).toString(); 5097 } catch (java.lang.ArithmeticException $139) { 5098 res = ""; 5099 } 5100 mathtestcheck(test, lhs, rhs, "mul", res, mul); 5101 5102 try { 5103 res = lhs.divide(rhs, mc).toString(); 5104 } catch (java.lang.ArithmeticException $140) { 5105 res = ""; 5106 } 5107 mathtestcheck(test, lhs, rhs, "div", res, div); 5108 5109 try { 5110 res = lhs.divideInteger(rhs, mc).toString(); 5111 } catch (java.lang.ArithmeticException $141) { 5112 res = ""; 5113 } 5114 mathtestcheck(test, lhs, rhs, "idv", res, idv); 5115 5116 try { 5117 res = lhs.remainder(rhs, mc).toString(); 5118 } catch (java.lang.ArithmeticException $142) { 5119 res = ""; 5120 } 5121 mathtestcheck(test, lhs, rhs, "rem", res, rem); 5122 5123 try { 5124 // prepare an integer from the rhs 5125 // in Rexx: 5126 // n=rhs+0 5127 // e=pos('E', n) 5128 // if e>0 then n=left(n,e-1) 5129 // n=format(n,,0) 5130 5131 sn = rhs.plus(mc).toString(); 5132 e = sn.indexOf("E", 0); 5133 if (e > 0) 5134 sn = sn.substring(0, e); 5135 sn = (new android.icu.math.BigDecimal(sn)).format(-1, 0); 5136 5137 res = lhs.pow(new android.icu.math.BigDecimal(sn), mc).toString(); 5138 } catch (java.lang.ArithmeticException $143) { 5139 res = ""; 5140 } 5141 mathtestcheck(test, lhs, rhs, "pow", res, pow); 5142 return; 5143 } 5144 5145 /* mathtestcheck -- check for general mathtest error 5146 Arg1 is test number 5147 Arg2 is left hand side (LHS) 5148 Arg3 is right hand side (RHS) 5149 Arg4 is the operation 5150 Arg5 is the actual result 5151 Arg6 is the expected result 5152 Show error message if a problem, otherwise return quietly 5153 */ 5154 5155 private void mathtestcheck(int test, android.icu.math.BigDecimal lhs, 5156 android.icu.math.BigDecimal rhs, java.lang.String op, 5157 java.lang.String got, java.lang.String want) { 5158 boolean flag; 5159 java.lang.String testnum; 5160 5161 flag = want.equals(got); 5162 5163 if ((!flag)) 5164 say(">" + test + ">" + " " + lhs.toString() + " " + op + " " 5165 + rhs.toString() + " " + "=" + " " + want + " " + "[got" 5166 + " " + got + "]"); 5167 5168 testnum = "gen" 5169 + right((new android.icu.math.BigDecimal(test + 1000)) 5170 .toString(), 3); 5171 5172 TestFmwk.assertTrue(testnum, flag); 5173 return; 5174 } 5175 5176 /* ------------------------------------------------------------------ */ 5177 /* Support routines and minor classes follow */ 5178 /* ------------------------------------------------------------------ */ 5179 5180 /* ----------------------------------------------------------------- */ 5181 /* Method called to summarise pending tests */ 5182 /* ----------------------------------------------------------------- */ 5183 /* Arg1 is section name */ 5184 5185 // private void summary(java.lang.String section) { 5186 // int bad; 5187 // int count; 5188 // int i = 0; 5189 // Test item = null; 5190 // bad = 0; 5191 // count = Tests.size(); 5192 // { 5193 // int $144 = count; 5194 // i = 0; 5195 // for (; $144 > 0; $144--, i++) { 5196 // item = (Test) (Tests.get(i)); 5197 // if ((!item.ok)) 5198 // { 5199 // bad++; 5200 // errln("Failed:" + " " + item.name); 5201 // } 5202 // } 5203 // }/*i*/ 5204 // totalcount = totalcount + count; 5205 // Tests = new java.util.ArrayList(100); // reinitialize 5206 // if (bad == 0) 5207 // say("OK" + " " + left(section, 14) + " " 5208 // + right("[" + count + " " + "tests]", 12)); 5209 // else 5210 // throw new DiagException(section + " " + "[failed" + " " + bad + " " 5211 // + "of" + " " + count + " " + "tests]", bad); 5212 // } 5213 5214 /* ----------------------------------------------------------------- */ 5215 /* right - Utility to do a 'right' on a Java String */ 5216 /* ----------------------------------------------------------------- */ 5217 /* Arg1 is string to right-justify */ 5218 /* Arg2 is desired length */ 5219 5220 private static java.lang.String right(java.lang.String s, int len) { 5221 int slen; 5222 slen = s.length(); 5223 if (slen == len) 5224 return s; // length just right 5225 if (slen > len) 5226 return s.substring(slen - len); // truncate on left 5227 // too short 5228 return (new java.lang.String(new char[len - slen])) 5229 .replace('\000', ' ').concat(s); 5230 } 5231 5232 /* ----------------------------------------------------------------- */ 5233 /* say - Utility to do a display */ 5234 /* ----------------------------------------------------------------- */ 5235 /* Arg1 is string to display, omitted if none */ 5236 /* [null or omitted gives blank line] */ 5237 // this version doesn't heed continuation final character 5238 private void say(java.lang.String s) { 5239 if (s == null) 5240 s = " "; 5241 logln(s); 5242 } 5243 5244 } 5245
