1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html#License 3 /* 4 ******************************************************************************* 5 * Copyright (C) 2000-2015, International Business Machines Corporation and 6 * others. All Rights Reserved. 7 ******************************************************************************* 8 */ 9 /* Generated from 'DiagBigDecimal.nrx' 27 Mar 2000 22:38:44 [v1.162] */ 10 /* Options: Binary Comments Crossref Format Java Logo Trace1 Verbose3 */ 11 /* The generated code has been manually modified. */ 12 package com.ibm.icu.dev.test.bigdec; 13 14 import java.math.BigInteger; 15 16 import org.junit.Test; 17 import org.junit.runner.RunWith; 18 import org.junit.runners.JUnit4; 19 20 import com.ibm.icu.dev.test.TestFmwk; 21 import com.ibm.icu.dev.test.TestUtil; 22 import com.ibm.icu.dev.test.TestUtil.JavaVendor; 23 import com.ibm.icu.math.BigDecimal; 24 25 /* ------------------------------------------------------------------ */ 26 /* Decimal diagnostic tests mfc */ 27 /* Copyright (c) IBM Corporation 1996-2010. All Rights Reserved. */ 28 /* ------------------------------------------------------------------ */ 29 /* DiagBigDecimal */ 30 /* */ 31 /* A class that tests the BigDecimal and MathContext classes. */ 32 /* */ 33 /* The tests here are derived from or cover the same paths as: */ 34 /* -- ANSI X3-274 testcases */ 35 /* -- Java JCK testcases */ 36 /* -- NetRexx testcases */ 37 /* -- VM/CMS S/370 REXX implementation testcases [1981+] */ 38 /* -- IBM Vienna Laboratory Rexx compiler testcases [1988+] */ 39 /* -- New testcases */ 40 /* */ 41 /* The authoritative sources for how the underlying technology */ 42 /* (arithmetic) should work are: */ 43 /* -- for digits=0 (fixed point): java.math.BigDecimal */ 44 /* -- for digits>0 (floating point): ANSI X3.274-1996 + errata */ 45 /* */ 46 /* ------------------------------------------------------------------ */ 47 /* Change list */ 48 /* 1997.09.05 Initial implementation, from DiagRexx [NetRexx tests] */ 49 /* 1998.05.02 0.07 changes (e.g., compareTo) */ 50 /* 1998.06.06 Rounding modes and format additions */ 51 /* 1998.06.25 Rename from DiagDecimal; make stand-alone [add */ 52 /* DiagException as a Minor class] */ 53 /* 1998.06.27 Start adding testcases for DIGITS=0/FORM=PLAIN cases */ 54 /* Reorganize for faster trace compilation */ 55 /* 1998.06.28 new: valueof, scale, movePointX, unscaledValue, etc. */ 56 /* 1998.07.07 Scaled divide */ 57 /* 1998.07.08 setScale */ 58 /* 1998.07.15 new scaffolding (Minor Test class) -- see diagabs */ 59 /* 1998.12.14 add toBigDecimal and BigDecimal(java.math.BigDecimal) */ 60 /* 1999.02.04 number preparation rounds instead of digits+1 trunc */ 61 /* 1999.02.09 format method now only has two signatures */ 62 /* 1999.02.27 no longer use Rexx class or RexxIO class */ 63 /* 1999.03.05 add MathContext tests */ 64 /* 1999.03.05 update for 0.96 [no null settings, etc.] */ 65 /* drop sundry constructors; no blanks; char[] gets ints */ 66 /* drop sundry converters, add Exact converters */ 67 /* 1999.05.27 additional tests for scaled arithmetic */ 68 /* 1999.06.29 additional tests for exponent overflows */ 69 /* 1999.07.03 add 'continue' option */ 70 /* 1999.07.10 additional tests for scaled arithmetic */ 71 /* 1999.07.18 randomly-generated tests added for base operators */ 72 /* 1999.10.28 weird intValueExact bad cases */ 73 /* 1999.12.21 multiplication fast path failure and edge cases */ 74 /* 2000.01.01 copyright update */ 75 /* 2000.03.26 cosmetic updates; add extra format() testcases */ 76 /* 2000.03.27 1.00 move to com.ibm.icu.math package; open source release; */ 77 /* change to javadoc comments */ 78 /* ------------------------------------------------------------------ */ 79 80 // note BINARY for conversions checking 81 82 /** 83 * The <code>DiagBigDecimal</code> class forms a standalone test suite for the 84 * <code>com.ibm.icu.math.BigDecimal</code> and 85 * <code>com.ibm.icu.math.MathContext</code> classes (or, by changing the 86 * <code>package</code> statement, other classes of the same names and 87 * definition in other packages). It may also be used as a constructed object to 88 * embed the tests in an external test harness. 89 * <p> 90 * The tests are collected into <i>groups</i>, each corresponding to a tested 91 * method or a more general grouping. By default, when run from the static 92 * {@link #main(java.lang.String[])} method, the run will end if any test fails 93 * in a group. The <code>continue</code> argument may be specified to force 94 * the tests to run to completion. 95 * 96 * @see com.ibm.icu.math.BigDecimal 97 * @see com.ibm.icu.math.MathContext 98 * @version 1.00 2000.03.27 99 * @author Mike Cowlishaw 100 */ 101 102 @RunWith(JUnit4.class) 103 public class DiagBigDecimalTest extends TestFmwk { 104 private static final com.ibm.icu.math.BigDecimal zero = com.ibm.icu.math.BigDecimal.ZERO; 105 private static final com.ibm.icu.math.BigDecimal one = com.ibm.icu.math.BigDecimal.ONE; 106 private static final com.ibm.icu.math.BigDecimal two = new com.ibm.icu.math.BigDecimal(2); 107 private static final com.ibm.icu.math.BigDecimal ten = com.ibm.icu.math.BigDecimal.TEN; 108 private static final com.ibm.icu.math.BigDecimal tenlong = new com.ibm.icu.math.BigDecimal((long) 1234554321); // 10-digiter 109 110 /* Some context objects -- [some of these are checked later] */ 111 private static final com.ibm.icu.math.MathContext mcdef = com.ibm.icu.math.MathContext.DEFAULT; 112 private static final com.ibm.icu.math.MathContext mc3 = new com.ibm.icu.math.MathContext(3); 113 private static final com.ibm.icu.math.MathContext mc6 = new com.ibm.icu.math.MathContext(6); 114 private static final com.ibm.icu.math.MathContext mc9 = new com.ibm.icu.math.MathContext(9); 115 private static final com.ibm.icu.math.MathContext mc50 = new com.ibm.icu.math.MathContext(50); 116 private static final com.ibm.icu.math.MathContext mcs = new com.ibm.icu.math.MathContext(9, com.ibm.icu.math.MathContext.SCIENTIFIC); 117 private static final com.ibm.icu.math.MathContext mce = new com.ibm.icu.math.MathContext(9, com.ibm.icu.math.MathContext.ENGINEERING); 118 private static final com.ibm.icu.math.MathContext mcld = new com.ibm.icu.math.MathContext(9, com.ibm.icu.math.MathContext.SCIENTIFIC, true); // lost digits 119 private static final com.ibm.icu.math.MathContext mcld0 = new com.ibm.icu.math.MathContext(0, com.ibm.icu.math.MathContext.SCIENTIFIC, true); // lost digits, digits=0 120 private static final com.ibm.icu.math.MathContext mcfd = new com.ibm.icu.math.MathContext(0, com.ibm.icu.math.MathContext.PLAIN); // fixed decimal style 121 122 /* boundary primitive values */ 123 private static final byte bmin = -128; 124 private static final byte bmax = 127; 125 private static final byte bzer = 0; 126 private static final byte bneg = -1; 127 private static final byte bpos = 1; 128 private static final int imin = -2147483648; 129 private static final int imax = 2147483647; 130 private static final int izer = 0; 131 private static final int ineg = -1; 132 private static final int ipos = 1; 133 private static final long lmin = -9223372036854775808L; 134 private static final long lmax = 9223372036854775807L; 135 private static final long lzer = 0; 136 private static final long lneg = -1; 137 private static final long lpos = 1; 138 private static final short smin = -32768; 139 private static final short smax = 32767; 140 private static final short szer = (short) 0; 141 private static final short sneg = (short) (-1); 142 private static final short spos = (short) 1; 143 144 /** 145 * Constructs a <code>DiagBigDecimal</code> test suite. 146 * <p> 147 * Invoke its {@link #diagrun} method to run the tests. 148 */ 149 150 public DiagBigDecimalTest() { 151 super(); 152 } 153 154 static final boolean isJDK15OrLater = 155 TestUtil.getJavaVendor() == JavaVendor.Android || 156 TestUtil.getJavaVersion() >= 5; 157 158 159 /*--------------------------------------------------------------------*/ 160 /* Diagnostic group methods */ 161 /*--------------------------------------------------------------------*/ 162 163 /** Test constructors (and {@link #toString()} for equalities). */ 164 @Test 165 public void diagconstructors() { 166 boolean flag = false; 167 java.lang.String num; 168 java.math.BigInteger bip; 169 java.math.BigInteger biz; 170 java.math.BigInteger bin; 171 com.ibm.icu.math.BigDecimal bda; 172 com.ibm.icu.math.BigDecimal bdb; 173 com.ibm.icu.math.BigDecimal bmc; 174 com.ibm.icu.math.BigDecimal bmd; 175 com.ibm.icu.math.BigDecimal bme; 176 java.lang.RuntimeException e = null; 177 char ca[]; 178 double dzer; 179 double dpos; 180 double dneg; 181 double dpos5; 182 double dneg5; 183 double dmin; 184 double dmax; 185 double d; 186 java.lang.String badstrings[]; 187 int i = 0; 188 189 // constants [statically-called constructors] 190 TestFmwk.assertTrue("con001", (com.ibm.icu.math.BigDecimal.ZERO.toString()).equals("0")); 191 TestFmwk.assertTrue("con002", (com.ibm.icu.math.BigDecimal.ONE.toString()).equals("1")); 192 TestFmwk.assertTrue("con003", (com.ibm.icu.math.BigDecimal.TEN.toString()).equals("10")); 193 TestFmwk.assertTrue("con004", (com.ibm.icu.math.BigDecimal.ZERO.intValueExact()) == 0); 194 TestFmwk.assertTrue("con005", (com.ibm.icu.math.BigDecimal.ONE.intValueExact()) == 1); 195 TestFmwk.assertTrue("con006", (com.ibm.icu.math.BigDecimal.TEN.intValueExact()) == 10); 196 197 // [java.math.] BigDecimal 198 TestFmwk.assertTrue("cbd001", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal("0"))).toString()).equals("0")); 199 TestFmwk.assertTrue("cbd002", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal("1"))).toString()).equals("1")); 200 TestFmwk.assertTrue("cbd003", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal("10"))).toString()).equals("10")); 201 TestFmwk.assertTrue("cbd004", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal("1000"))).toString()).equals("1000")); 202 TestFmwk.assertTrue("cbd005", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal("10.0"))).toString()).equals("10.0")); 203 TestFmwk.assertTrue("cbd006", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal("10.1"))).toString()).equals("10.1")); 204 TestFmwk.assertTrue("cbd007", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal("-1.1"))).toString()).equals("-1.1")); 205 TestFmwk.assertTrue("cbd008", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal("-9.0"))).toString()).equals("-9.0")); 206 TestFmwk.assertTrue("cbd009", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal("0.9"))).toString()).equals("0.9")); 207 208 num = "123456789.123456789"; 209 TestFmwk.assertTrue("cbd010", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal(num))).toString()).equals(num)); 210 num = "123456789.000000000"; 211 TestFmwk.assertTrue("cbd011", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal(num))).toString()).equals(num)); 212 num = "123456789000000000"; 213 TestFmwk.assertTrue("cbd012", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal(num))).toString()).equals(num)); 214 num = "0.00000123456789"; 215 TestFmwk.assertTrue("cbd013", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal(num))).toString()).equals(num)); 216 num = "0.000000123456789"; 217 218 // ignore format change issues with 1.5 219 if (!isJDK15OrLater) 220 TestFmwk.assertTrue("cbd014", ((new com.ibm.icu.math.BigDecimal(new java.math.BigDecimal(num))).toString()).equals(num)); 221 222 try { 223 new com.ibm.icu.math.BigDecimal((java.math.BigDecimal) null); 224 flag = false; 225 } catch (java.lang.NullPointerException $3) { 226 flag = true; 227 }/* checknull */ 228 TestFmwk.assertTrue("cbi015", flag); 229 230 // BigInteger 231 bip = new BigInteger("987654321987654321987654321"); // biggie +ve 232 biz = new BigInteger("0"); // biggie 0 233 bin = new BigInteger("-12345678998765432112345678"); // biggie -ve 234 TestFmwk.assertTrue("cbi001", ((new com.ibm.icu.math.BigDecimal(bip)).toString()).equals(bip.toString())); 235 TestFmwk.assertTrue("cbi002", ((new com.ibm.icu.math.BigDecimal(biz)).toString()).equals("0")); 236 TestFmwk.assertTrue("cbi003", ((new com.ibm.icu.math.BigDecimal(bin)).toString()).equals(bin.toString())); 237 try { 238 new com.ibm.icu.math.BigDecimal((java.math.BigInteger) null); 239 flag = false; 240 } catch (java.lang.NullPointerException $4) { 241 flag = true; 242 }/* checknull */ 243 TestFmwk.assertTrue("cbi004", flag); 244 245 // BigInteger with scale 246 bip = new BigInteger("123456789"); // bigish 247 bda = new com.ibm.icu.math.BigDecimal(bip); 248 bdb = new com.ibm.icu.math.BigDecimal(bip, 5); 249 bmc = new com.ibm.icu.math.BigDecimal(bip, 15); 250 TestFmwk.assertTrue("cbs001", (bda.toString()).equals("123456789")); 251 TestFmwk.assertTrue("cbs002", (bdb.toString()).equals("1234.56789")); 252 TestFmwk.assertTrue("cbs003", (bmc.toString()).equals("0.000000123456789")); 253 bip = new BigInteger("123456789123456789123456789"); // biggie 254 bda = new com.ibm.icu.math.BigDecimal(bip); 255 bdb = new com.ibm.icu.math.BigDecimal(bip, 7); 256 bmc = new com.ibm.icu.math.BigDecimal(bip, 13); 257 bmd = new com.ibm.icu.math.BigDecimal(bip, 19); 258 bme = new com.ibm.icu.math.BigDecimal(bip, 29); 259 TestFmwk.assertTrue("cbs011", (bda.toString()).equals("123456789123456789123456789")); 260 TestFmwk.assertTrue("cbs012", (bdb.toString()).equals("12345678912345678912.3456789")); 261 TestFmwk.assertTrue("cbs013", (bmc.toString()).equals("12345678912345.6789123456789")); 262 TestFmwk.assertTrue("cbs014", (bmd.toString()).equals("12345678.9123456789123456789")); 263 TestFmwk.assertTrue("cbs015", (bme.toString()).equals("0.00123456789123456789123456789")); 264 try { 265 new com.ibm.icu.math.BigDecimal((java.math.BigInteger) null, 1); 266 flag = false; 267 } catch (java.lang.NullPointerException $5) { 268 flag = true; 269 }/* checknull */ 270 TestFmwk.assertTrue("cbs004", flag); 271 try { 272 new com.ibm.icu.math.BigDecimal(bip, -8); 273 flag = false; 274 } catch (java.lang.RuntimeException $6) { 275 e = $6; 276 flag = (e.getMessage()).equals("Negative scale: -8"); 277 }/* checkscale */ 278 TestFmwk.assertTrue("cbs005", flag); 279 280 // char[] 281 // We just test it's there 282 // Functionality is tested by BigDecimal(String). 283 ca = ("123.45").toCharArray(); 284 TestFmwk.assertTrue("cca001", ((new com.ibm.icu.math.BigDecimal(ca)).toString()).equals("123.45")); 285 try { 286 new com.ibm.icu.math.BigDecimal((char[]) null); 287 flag = false; 288 } catch (java.lang.NullPointerException $7) { 289 flag = true; 290 }/* checknull */ 291 TestFmwk.assertTrue("cca010", flag); 292 293 // char[],int,int 294 // We just test it's there, and that offsets work. 295 // Functionality is tested by BigDecimal(String). 296 ca = ("123.45").toCharArray(); 297 TestFmwk.assertTrue("cca101", ((new com.ibm.icu.math.BigDecimal(ca, 0, 6)).toString()).equals("123.45")); 298 TestFmwk.assertTrue("cca102", ((new com.ibm.icu.math.BigDecimal(ca, 1, 5)).toString()).equals("23.45")); 299 TestFmwk.assertTrue("cca103", ((new com.ibm.icu.math.BigDecimal(ca, 2, 4)).toString()).equals("3.45")); 300 TestFmwk.assertTrue("cca104", ((new com.ibm.icu.math.BigDecimal(ca, 3, 3)).toString()).equals("0.45")); 301 TestFmwk.assertTrue("cca105", ((new com.ibm.icu.math.BigDecimal(ca, 4, 2)).toString()).equals("45")); 302 TestFmwk.assertTrue("cca106", ((new com.ibm.icu.math.BigDecimal(ca, 5, 1)).toString()).equals("5")); 303 304 TestFmwk.assertTrue("cca110", ((new com.ibm.icu.math.BigDecimal(ca, 0, 1)).toString()).equals("1")); 305 TestFmwk.assertTrue("cca111", ((new com.ibm.icu.math.BigDecimal(ca, 1, 1)).toString()).equals("2")); 306 TestFmwk.assertTrue("cca112", ((new com.ibm.icu.math.BigDecimal(ca, 2, 1)).toString()).equals("3")); 307 TestFmwk.assertTrue("cca113", ((new com.ibm.icu.math.BigDecimal(ca, 4, 1)).toString()).equals("4")); 308 309 TestFmwk.assertTrue("cca120", ((new com.ibm.icu.math.BigDecimal(ca, 0, 2)).toString()).equals("12")); 310 TestFmwk.assertTrue("cca121", ((new com.ibm.icu.math.BigDecimal(ca, 1, 2)).toString()).equals("23")); 311 TestFmwk.assertTrue("cca122", ((new com.ibm.icu.math.BigDecimal(ca, 2, 2)).toString()).equals("3")); 312 TestFmwk.assertTrue("cca123", ((new com.ibm.icu.math.BigDecimal(ca, 3, 2)).toString()).equals("0.4")); 313 314 TestFmwk.assertTrue("cca130", ((new com.ibm.icu.math.BigDecimal(ca, 0, 3)).toString()).equals("123")); 315 TestFmwk.assertTrue("cca131", ((new com.ibm.icu.math.BigDecimal(ca, 1, 3)).toString()).equals("23")); 316 TestFmwk.assertTrue("cca132", ((new com.ibm.icu.math.BigDecimal(ca, 2, 3)).toString()).equals("3.4")); 317 318 TestFmwk.assertTrue("cca140", ((new com.ibm.icu.math.BigDecimal(ca, 0, 4)).toString()).equals("123")); 319 TestFmwk.assertTrue("cca141", ((new com.ibm.icu.math.BigDecimal(ca, 1, 4)).toString()).equals("23.4")); 320 321 TestFmwk.assertTrue("cca150", ((new com.ibm.icu.math.BigDecimal(ca, 0, 5)).toString()).equals("123.4")); 322 323 // a couple of oddies 324 ca = ("x23.4x").toCharArray(); 325 TestFmwk.assertTrue("cca160", ((new com.ibm.icu.math.BigDecimal(ca, 1, 4)).toString()).equals("23.4")); 326 TestFmwk.assertTrue("cca161", ((new com.ibm.icu.math.BigDecimal(ca, 1, 1)).toString()).equals("2")); 327 TestFmwk.assertTrue("cca162", ((new com.ibm.icu.math.BigDecimal(ca, 4, 1)).toString()).equals("4")); 328 329 ca = ("0123456789.9876543210").toCharArray(); 330 TestFmwk.assertTrue("cca163", ((new com.ibm.icu.math.BigDecimal(ca, 0, 21)).toString()).equals("123456789.9876543210")); 331 TestFmwk.assertTrue("cca164", ((new com.ibm.icu.math.BigDecimal(ca, 1, 20)).toString()).equals("123456789.9876543210")); 332 TestFmwk.assertTrue("cca165", ((new com.ibm.icu.math.BigDecimal(ca, 2, 19)).toString()).equals("23456789.9876543210")); 333 TestFmwk.assertTrue("cca166", ((new com.ibm.icu.math.BigDecimal(ca, 2, 18)).toString()).equals("23456789.987654321")); 334 TestFmwk.assertTrue("cca167", ((new com.ibm.icu.math.BigDecimal(ca, 2, 17)).toString()).equals("23456789.98765432")); 335 TestFmwk.assertTrue("cca168", ((new com.ibm.icu.math.BigDecimal(ca, 2, 16)).toString()).equals("23456789.9876543")); 336 337 try { 338 new com.ibm.icu.math.BigDecimal((char[]) null, 0, 1); 339 flag = false; 340 } catch (java.lang.NullPointerException $8) { 341 flag = true; 342 }/* checknull */ 343 TestFmwk.assertTrue("cca200", flag); 344 345 try { 346 new com.ibm.icu.math.BigDecimal("123".toCharArray(), 0, 0); 347 flag = false; 348 } catch (java.lang.NumberFormatException $9) { 349 flag = true; 350 }/* checklen */ 351 TestFmwk.assertTrue("cca201", flag); 352 353 try { 354 new com.ibm.icu.math.BigDecimal("123".toCharArray(), 2, 4); 355 flag = false; 356 } catch (java.lang.RuntimeException $10) { // anything OK 357 flag = true; 358 }/* checkbound */ 359 TestFmwk.assertTrue("cca202", flag); 360 try { 361 new com.ibm.icu.math.BigDecimal("123".toCharArray(), -1, 2); 362 flag = false; 363 } catch (java.lang.RuntimeException $11) { // anything OK 364 flag = true; 365 }/* checkbound2 */ 366 TestFmwk.assertTrue("cca203", flag); 367 try { 368 new com.ibm.icu.math.BigDecimal("123".toCharArray(), 1, -2); 369 flag = false; 370 } catch (java.lang.RuntimeException $12) { // anything OK 371 flag = true; 372 }/* checkbound3 */ 373 TestFmwk.assertTrue("cca204", flag); 374 375 // double [deprecated] 376 // Note that many of these differ from the valueOf(double) results. 377 dzer = 0; 378 dpos = 1; 379 dpos = dpos / (10); 380 dneg = -dpos; 381 TestFmwk.assertTrue("cdo001", ((new com.ibm.icu.math.BigDecimal(dneg)).toString()).equals("-0.1000000000000000055511151231257827021181583404541015625")); 382 383 TestFmwk.assertTrue("cdo002", ((new com.ibm.icu.math.BigDecimal(dzer)).toString()).equals("0")); // NB, not '0.0' 384 TestFmwk.assertTrue("cdo003", ((new com.ibm.icu.math.BigDecimal(dpos)).toString()).equals("0.1000000000000000055511151231257827021181583404541015625")); 385 386 dpos5 = 0.5D; 387 dneg5 = -dpos5; 388 TestFmwk.assertTrue("cdo004", ((new com.ibm.icu.math.BigDecimal(dneg5)).toString()).equals("-0.5")); 389 TestFmwk.assertTrue("cdo005", ((new com.ibm.icu.math.BigDecimal(dpos5)).toString()).equals("0.5")); 390 dmin = java.lang.Double.MIN_VALUE; 391 dmax = java.lang.Double.MAX_VALUE; 392 if (!isJDK15OrLater) // for some reason we format using scientific 393 // notation on 1.5 after 30 decimals or so 394 TestFmwk.assertTrue("cdo006", ((new com.ibm.icu.math.BigDecimal(dmin)).toString()).equals("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004940656458412465441765687928682213723650598026143247644255856825006755072702087518652998363616359923797965646954457177309266567103559397963987747960107818781263007131903114045278458171678489821036887186360569987307230500063874091535649843873124733972731696151400317153853980741262385655911710266585566867681870395603106249319452715914924553293054565444011274801297099995419319894090804165633245247571478690147267801593552386115501348035264934720193790268107107491703332226844753335720832431936092382893458368060106011506169809753078342277318329247904982524730776375927247874656084778203734469699533647017972677717585125660551199131504891101451037862738167250955837389733598993664809941164205702637090279242767544565229087538682506419718265533447265625")); 395 396 TestFmwk.assertTrue("cdo007", ((new com.ibm.icu.math.BigDecimal(dmax)).toString()).equals("179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368")); 397 398 // nasties 399 d = 9; 400 d = d / (10); 401 TestFmwk.assertTrue("cdo010", ((new com.ibm.icu.math.BigDecimal(d)).toString()).equals("0.90000000000000002220446049250313080847263336181640625")); 402 403 d = d / (10); 404 TestFmwk.assertTrue("cdo011", ((new com.ibm.icu.math.BigDecimal(d)).toString()).equals("0.0899999999999999966693309261245303787291049957275390625")); 405 406 d = d / (10); 407 TestFmwk.assertTrue("cdo012", ((new com.ibm.icu.math.BigDecimal(d)).toString()).equals("0.00899999999999999931998839741709161899052560329437255859375")); 408 409 d = d / (10); 410 TestFmwk.assertTrue("cdo013", ((new com.ibm.icu.math.BigDecimal(d)).toString()).equals("0.00089999999999999997536692664112933925935067236423492431640625")); 411 412 d = d / (10); 413 TestFmwk.assertTrue("cdo014", ((new com.ibm.icu.math.BigDecimal(d)).toString()).equals("0.00008999999999999999211568180168541175589780323207378387451171875")); 414 415 d = d / (10); 416 TestFmwk.assertTrue("cdo015", ((new com.ibm.icu.math.BigDecimal(d)).toString()).equals("0.00000899999999999999853394182236510090433512232266366481781005859375")); 417 418 d = d / (10); 419 if (!isJDK15OrLater) 420 TestFmwk.assertTrue("cdo016", ((new com.ibm.icu.math.BigDecimal(d)).toString()).equals("0.000000899999999999999853394182236510090433512232266366481781005859375")); 421 422 d = d / (10); 423 if (!isJDK15OrLater) 424 TestFmwk.assertTrue("cdo017", ((new com.ibm.icu.math.BigDecimal(d)).toString()).equals("0.0000000899999999999999853394182236510090433512232266366481781005859375")); 425 426 d = d / (10); 427 if (!isJDK15OrLater) 428 TestFmwk.assertTrue("cdo018", ((new com.ibm.icu.math.BigDecimal(d)).toString()).equals("0.000000008999999999999997872197332322678764437995369007694534957408905029296875")); 429 430 try { 431 new com.ibm.icu.math.BigDecimal( 432 java.lang.Double.POSITIVE_INFINITY); 433 flag = false; 434 } catch (java.lang.NumberFormatException $13) { 435 flag = true; 436 }/* checkpin */ 437 TestFmwk.assertTrue("cdo101", flag); 438 try { 439 new com.ibm.icu.math.BigDecimal( 440 java.lang.Double.NEGATIVE_INFINITY); 441 flag = false; 442 } catch (java.lang.NumberFormatException $14) { 443 flag = true; 444 }/* checknin */ 445 TestFmwk.assertTrue("cdo102", flag); 446 try { 447 new com.ibm.icu.math.BigDecimal(java.lang.Double.NaN); 448 flag = false; 449 } catch (java.lang.NumberFormatException $15) { 450 flag = true; 451 }/* checknan */ 452 TestFmwk.assertTrue("cdo103", flag); 453 454 // int 455 TestFmwk.assertTrue("cin001", ((new com.ibm.icu.math.BigDecimal(imin)).toString()).equals("-2147483648")); 456 TestFmwk.assertTrue("cin002", ((new com.ibm.icu.math.BigDecimal(imax)).toString()).equals("2147483647")); 457 TestFmwk.assertTrue("cin003", ((new com.ibm.icu.math.BigDecimal(ineg)).toString()).equals("-1")); 458 TestFmwk.assertTrue("cin004", ((new com.ibm.icu.math.BigDecimal(izer)).toString()).equals("0")); 459 TestFmwk.assertTrue("cin005", ((new com.ibm.icu.math.BigDecimal(ipos)).toString()).equals("1")); 460 TestFmwk.assertTrue("cin006", ((new com.ibm.icu.math.BigDecimal(10)).toString()).equals("10")); 461 TestFmwk.assertTrue("cin007", ((new com.ibm.icu.math.BigDecimal(9)).toString()).equals("9")); 462 TestFmwk.assertTrue("cin008", ((new com.ibm.icu.math.BigDecimal(5)).toString()).equals("5")); 463 TestFmwk.assertTrue("cin009", ((new com.ibm.icu.math.BigDecimal(2)).toString()).equals("2")); 464 TestFmwk.assertTrue("cin010", ((new com.ibm.icu.math.BigDecimal(-2)).toString()).equals("-2")); 465 TestFmwk.assertTrue("cin011", ((new com.ibm.icu.math.BigDecimal(-5)).toString()).equals("-5")); 466 TestFmwk.assertTrue("cin012", ((new com.ibm.icu.math.BigDecimal(-9)).toString()).equals("-9")); 467 TestFmwk.assertTrue("cin013", ((new com.ibm.icu.math.BigDecimal(-10)).toString()).equals("-10")); 468 TestFmwk.assertTrue("cin014", ((new com.ibm.icu.math.BigDecimal(-11)).toString()).equals("-11")); 469 TestFmwk.assertTrue("cin015", ((new com.ibm.icu.math.BigDecimal(-99)).toString()).equals("-99")); 470 TestFmwk.assertTrue("cin016", ((new com.ibm.icu.math.BigDecimal(-100)).toString()).equals("-100")); 471 TestFmwk.assertTrue("cin017", ((new com.ibm.icu.math.BigDecimal(-999)).toString()).equals("-999")); 472 TestFmwk.assertTrue("cin018", ((new com.ibm.icu.math.BigDecimal(-1000)).toString()).equals("-1000")); 473 474 TestFmwk.assertTrue("cin019", ((new com.ibm.icu.math.BigDecimal(11)).toString()).equals("11")); 475 TestFmwk.assertTrue("cin020", ((new com.ibm.icu.math.BigDecimal(99)).toString()).equals("99")); 476 TestFmwk.assertTrue("cin021", ((new com.ibm.icu.math.BigDecimal(100)).toString()).equals("100")); 477 TestFmwk.assertTrue("cin022", ((new com.ibm.icu.math.BigDecimal(999)).toString()).equals("999")); 478 TestFmwk.assertTrue("cin023", ((new com.ibm.icu.math.BigDecimal(1000)).toString()).equals("1000")); 479 480 // long 481 TestFmwk.assertTrue("clo001", ((new com.ibm.icu.math.BigDecimal(lmin)).toString()).equals("-9223372036854775808")); 482 TestFmwk.assertTrue("clo002", ((new com.ibm.icu.math.BigDecimal(lmax)).toString()).equals("9223372036854775807")); 483 TestFmwk.assertTrue("clo003", ((new com.ibm.icu.math.BigDecimal(lneg)).toString()).equals("-1")); 484 TestFmwk.assertTrue("clo004", ((new com.ibm.icu.math.BigDecimal(lzer)).toString()).equals("0")); 485 TestFmwk.assertTrue("clo005", ((new com.ibm.icu.math.BigDecimal(lpos)).toString()).equals("1")); 486 487 // String [many more examples are elsewhere] 488 // strings without E cannot generate E in result 489 TestFmwk.assertTrue("cst001", ((new com.ibm.icu.math.BigDecimal("12")).toString()).equals("12")); 490 TestFmwk.assertTrue("cst002", ((new com.ibm.icu.math.BigDecimal("-76")).toString()).equals("-76")); 491 TestFmwk.assertTrue("cst003", ((new com.ibm.icu.math.BigDecimal("12.76")).toString()).equals("12.76")); 492 TestFmwk.assertTrue("cst004", ((new com.ibm.icu.math.BigDecimal("+12.76")).toString()).equals("12.76")); 493 TestFmwk.assertTrue("cst005", ((new com.ibm.icu.math.BigDecimal("012.76")).toString()).equals("12.76")); 494 TestFmwk.assertTrue("cst006", ((new com.ibm.icu.math.BigDecimal("+0.003")).toString()).equals("0.003")); 495 TestFmwk.assertTrue("cst007", ((new com.ibm.icu.math.BigDecimal("17.")).toString()).equals("17")); 496 TestFmwk.assertTrue("cst008", ((new com.ibm.icu.math.BigDecimal(".5")).toString()).equals("0.5")); 497 TestFmwk.assertTrue("cst009", ((new com.ibm.icu.math.BigDecimal("044")).toString()).equals("44")); 498 TestFmwk.assertTrue("cst010", ((new com.ibm.icu.math.BigDecimal("0044")).toString()).equals("44")); 499 TestFmwk.assertTrue("cst011", ((new com.ibm.icu.math.BigDecimal("0.0005")).toString()).equals("0.0005")); 500 TestFmwk.assertTrue("cst012", ((new com.ibm.icu.math.BigDecimal("00.00005")).toString()).equals("0.00005")); 501 TestFmwk.assertTrue("cst013", ((new com.ibm.icu.math.BigDecimal("0.000005")).toString()).equals("0.000005")); 502 TestFmwk.assertTrue("cst014", ((new com.ibm.icu.math.BigDecimal("0.0000005")).toString()).equals("0.0000005")); // \NR 503 TestFmwk.assertTrue("cst015", ((new com.ibm.icu.math.BigDecimal("0.00000005")).toString()).equals("0.00000005")); // \NR 504 TestFmwk.assertTrue("cst016", ((new com.ibm.icu.math.BigDecimal("12345678.876543210")).toString()).equals("12345678.876543210")); 505 TestFmwk.assertTrue("cst017", ((new com.ibm.icu.math.BigDecimal("2345678.876543210")).toString()).equals("2345678.876543210")); 506 TestFmwk.assertTrue("cst018", ((new com.ibm.icu.math.BigDecimal("345678.876543210")).toString()).equals("345678.876543210")); 507 TestFmwk.assertTrue("cst019", ((new com.ibm.icu.math.BigDecimal("0345678.87654321")).toString()).equals("345678.87654321")); 508 TestFmwk.assertTrue("cst020", ((new com.ibm.icu.math.BigDecimal("345678.8765432")).toString()).equals("345678.8765432")); 509 TestFmwk.assertTrue("cst021", ((new com.ibm.icu.math.BigDecimal("+345678.8765432")).toString()).equals("345678.8765432")); 510 TestFmwk.assertTrue("cst022", ((new com.ibm.icu.math.BigDecimal("+0345678.8765432")).toString()).equals("345678.8765432")); 511 TestFmwk.assertTrue("cst023", ((new com.ibm.icu.math.BigDecimal("+00345678.8765432")).toString()).equals("345678.8765432")); 512 TestFmwk.assertTrue("cst024", ((new com.ibm.icu.math.BigDecimal("-345678.8765432")).toString()).equals("-345678.8765432")); 513 TestFmwk.assertTrue("cst025", ((new com.ibm.icu.math.BigDecimal("-0345678.8765432")).toString()).equals("-345678.8765432")); 514 TestFmwk.assertTrue("cst026", ((new com.ibm.icu.math.BigDecimal("-00345678.8765432")).toString()).equals("-345678.8765432")); 515 516 // exotics -- 517 TestFmwk.assertTrue("cst035", ((new com.ibm.icu.math.BigDecimal("\u0e57.\u0e50")).toString()).equals("7.0")); 518 TestFmwk.assertTrue("cst036", ((new com.ibm.icu.math.BigDecimal("\u0b66.\u0b67")).toString()).equals("0.1")); 519 TestFmwk.assertTrue("cst037", ((new com.ibm.icu.math.BigDecimal("\u0b66\u0b66")).toString()).equals("0")); 520 TestFmwk.assertTrue("cst038", ((new com.ibm.icu.math.BigDecimal("\u0b6a\u0b66")).toString()).equals("40")); 521 522 // strings with E 523 TestFmwk.assertTrue("cst040", ((new com.ibm.icu.math.BigDecimal("1E+9")).toString()).equals("1E+9")); 524 TestFmwk.assertTrue("cst041", ((new com.ibm.icu.math.BigDecimal("1e+09")).toString()).equals("1E+9")); 525 TestFmwk.assertTrue("cst042", ((new com.ibm.icu.math.BigDecimal("1E+90")).toString()).equals("1E+90")); 526 TestFmwk.assertTrue("cst043", ((new com.ibm.icu.math.BigDecimal("+1E+009")).toString()).equals("1E+9")); 527 TestFmwk.assertTrue("cst044", ((new com.ibm.icu.math.BigDecimal("0E+9")).toString()).equals("0")); 528 TestFmwk.assertTrue("cst045", ((new com.ibm.icu.math.BigDecimal("1E+9")).toString()).equals("1E+9")); 529 TestFmwk.assertTrue("cst046", ((new com.ibm.icu.math.BigDecimal("1E+09")).toString()).equals("1E+9")); 530 TestFmwk.assertTrue("cst047", ((new com.ibm.icu.math.BigDecimal("1e+90")).toString()).equals("1E+90")); 531 TestFmwk.assertTrue("cst048", ((new com.ibm.icu.math.BigDecimal("1E+009")).toString()).equals("1E+9")); 532 TestFmwk.assertTrue("cst049", ((new com.ibm.icu.math.BigDecimal("0E+9")).toString()).equals("0")); 533 TestFmwk.assertTrue("cst050", ((new com.ibm.icu.math.BigDecimal("1E9")).toString()).equals("1E+9")); 534 TestFmwk.assertTrue("cst051", ((new com.ibm.icu.math.BigDecimal("1e09")).toString()).equals("1E+9")); 535 TestFmwk.assertTrue("cst052", ((new com.ibm.icu.math.BigDecimal("1E90")).toString()).equals("1E+90")); 536 TestFmwk.assertTrue("cst053", ((new com.ibm.icu.math.BigDecimal("1E009")).toString()).equals("1E+9")); 537 TestFmwk.assertTrue("cst054", ((new com.ibm.icu.math.BigDecimal("0E9")).toString()).equals("0")); 538 TestFmwk.assertTrue("cst055", ((new com.ibm.icu.math.BigDecimal("0.000e+0")).toString()).equals("0")); 539 TestFmwk.assertTrue("cst056", ((new com.ibm.icu.math.BigDecimal("0.000E-1")).toString()).equals("0")); 540 TestFmwk.assertTrue("cst057", ((new com.ibm.icu.math.BigDecimal("4E+9")).toString()).equals("4E+9")); 541 TestFmwk.assertTrue("cst058", ((new com.ibm.icu.math.BigDecimal("44E+9")).toString()).equals("4.4E+10")); 542 TestFmwk.assertTrue("cst059", ((new com.ibm.icu.math.BigDecimal("0.73e-7")).toString()).equals("7.3E-8")); 543 TestFmwk.assertTrue("cst060", ((new com.ibm.icu.math.BigDecimal("00E+9")).toString()).equals("0")); 544 TestFmwk.assertTrue("cst061", ((new com.ibm.icu.math.BigDecimal("00E-9")).toString()).equals("0")); 545 TestFmwk.assertTrue("cst062", ((new com.ibm.icu.math.BigDecimal("10E+9")).toString()).equals("1.0E+10")); 546 TestFmwk.assertTrue("cst063", ((new com.ibm.icu.math.BigDecimal("10E+09")).toString()).equals("1.0E+10")); 547 TestFmwk.assertTrue("cst064", ((new com.ibm.icu.math.BigDecimal("10e+90")).toString()).equals("1.0E+91")); 548 TestFmwk.assertTrue("cst065", ((new com.ibm.icu.math.BigDecimal("10E+009")).toString()).equals("1.0E+10")); 549 TestFmwk.assertTrue("cst066", ((new com.ibm.icu.math.BigDecimal("100e+9")).toString()).equals("1.00E+11")); 550 TestFmwk.assertTrue("cst067", ((new com.ibm.icu.math.BigDecimal("100e+09")).toString()).equals("1.00E+11")); 551 TestFmwk.assertTrue("cst068", ((new com.ibm.icu.math.BigDecimal("100E+90")).toString()).equals("1.00E+92")); 552 TestFmwk.assertTrue("cst069", ((new com.ibm.icu.math.BigDecimal("100e+009")).toString()).equals("1.00E+11")); 553 554 TestFmwk.assertTrue("cst070", ((new com.ibm.icu.math.BigDecimal("1.265")).toString()).equals("1.265")); 555 TestFmwk.assertTrue("cst071", ((new com.ibm.icu.math.BigDecimal("1.265E-20")).toString()).equals("1.265E-20")); 556 TestFmwk.assertTrue("cst072", ((new com.ibm.icu.math.BigDecimal("1.265E-8")).toString()).equals("1.265E-8")); 557 TestFmwk.assertTrue("cst073", ((new com.ibm.icu.math.BigDecimal("1.265E-4")).toString()).equals("1.265E-4")); 558 TestFmwk.assertTrue("cst074", ((new com.ibm.icu.math.BigDecimal("1.265E-3")).toString()).equals("1.265E-3")); 559 TestFmwk.assertTrue("cst075", ((new com.ibm.icu.math.BigDecimal("1.265E-2")).toString()).equals("1.265E-2")); 560 TestFmwk.assertTrue("cst076", ((new com.ibm.icu.math.BigDecimal("1.265E-1")).toString()).equals("1.265E-1")); 561 TestFmwk.assertTrue("cst077", ((new com.ibm.icu.math.BigDecimal("1.265E-0")).toString()).equals("1.265")); 562 TestFmwk.assertTrue("cst078", ((new com.ibm.icu.math.BigDecimal("1.265E+1")).toString()).equals("1.265E+1")); 563 TestFmwk.assertTrue("cst079", ((new com.ibm.icu.math.BigDecimal("1.265E+2")).toString()).equals("1.265E+2")); 564 TestFmwk.assertTrue("cst080", ((new com.ibm.icu.math.BigDecimal("1.265E+3")).toString()).equals("1.265E+3")); 565 TestFmwk.assertTrue("cst081", ((new com.ibm.icu.math.BigDecimal("1.265E+4")).toString()).equals("1.265E+4")); 566 TestFmwk.assertTrue("cst082", ((new com.ibm.icu.math.BigDecimal("1.265E+8")).toString()).equals("1.265E+8")); 567 TestFmwk.assertTrue("cst083", ((new com.ibm.icu.math.BigDecimal("1.265E+20")).toString()).equals("1.265E+20")); 568 569 TestFmwk.assertTrue("cst090", ((new com.ibm.icu.math.BigDecimal("12.65")).toString()).equals("12.65")); 570 TestFmwk.assertTrue("cst091", ((new com.ibm.icu.math.BigDecimal("12.65E-20")).toString()).equals("1.265E-19")); 571 TestFmwk.assertTrue("cst092", ((new com.ibm.icu.math.BigDecimal("12.65E-8")).toString()).equals("1.265E-7")); 572 TestFmwk.assertTrue("cst093", ((new com.ibm.icu.math.BigDecimal("12.65E-4")).toString()).equals("1.265E-3")); 573 TestFmwk.assertTrue("cst094", ((new com.ibm.icu.math.BigDecimal("12.65E-3")).toString()).equals("1.265E-2")); 574 TestFmwk.assertTrue("cst095", ((new com.ibm.icu.math.BigDecimal("12.65E-2")).toString()).equals("1.265E-1")); 575 TestFmwk.assertTrue("cst096", ((new com.ibm.icu.math.BigDecimal("12.65E-1")).toString()).equals("1.265")); 576 TestFmwk.assertTrue("cst097", ((new com.ibm.icu.math.BigDecimal("12.65E-0")).toString()).equals("1.265E+1")); 577 TestFmwk.assertTrue("cst098", ((new com.ibm.icu.math.BigDecimal("12.65E+1")).toString()).equals("1.265E+2")); 578 TestFmwk.assertTrue("cst099", ((new com.ibm.icu.math.BigDecimal("12.65E+2")).toString()).equals("1.265E+3")); 579 TestFmwk.assertTrue("cst100", ((new com.ibm.icu.math.BigDecimal("12.65E+3")).toString()).equals("1.265E+4")); 580 TestFmwk.assertTrue("cst101", ((new com.ibm.icu.math.BigDecimal("12.65E+4")).toString()).equals("1.265E+5")); 581 TestFmwk.assertTrue("cst102", ((new com.ibm.icu.math.BigDecimal("12.65E+8")).toString()).equals("1.265E+9")); 582 TestFmwk.assertTrue("cst103", ((new com.ibm.icu.math.BigDecimal("12.65E+20")).toString()).equals("1.265E+21")); 583 584 TestFmwk.assertTrue("cst110", ((new com.ibm.icu.math.BigDecimal("126.5")).toString()).equals("126.5")); 585 TestFmwk.assertTrue("cst111", ((new com.ibm.icu.math.BigDecimal("126.5E-20")).toString()).equals("1.265E-18")); 586 TestFmwk.assertTrue("cst112", ((new com.ibm.icu.math.BigDecimal("126.5E-8")).toString()).equals("1.265E-6")); 587 TestFmwk.assertTrue("cst113", ((new com.ibm.icu.math.BigDecimal("126.5E-4")).toString()).equals("1.265E-2")); 588 TestFmwk.assertTrue("cst114", ((new com.ibm.icu.math.BigDecimal("126.5E-3")).toString()).equals("1.265E-1")); 589 TestFmwk.assertTrue("cst115", ((new com.ibm.icu.math.BigDecimal("126.5E-2")).toString()).equals("1.265")); 590 TestFmwk.assertTrue("cst116", ((new com.ibm.icu.math.BigDecimal("126.5E-1")).toString()).equals("1.265E+1")); 591 TestFmwk.assertTrue("cst117", ((new com.ibm.icu.math.BigDecimal("126.5E-0")).toString()).equals("1.265E+2")); 592 TestFmwk.assertTrue("cst118", ((new com.ibm.icu.math.BigDecimal("126.5E+1")).toString()).equals("1.265E+3")); 593 TestFmwk.assertTrue("cst119", ((new com.ibm.icu.math.BigDecimal("126.5E+2")).toString()).equals("1.265E+4")); 594 TestFmwk.assertTrue("cst120", ((new com.ibm.icu.math.BigDecimal("126.5E+3")).toString()).equals("1.265E+5")); 595 TestFmwk.assertTrue("cst121", ((new com.ibm.icu.math.BigDecimal("126.5E+4")).toString()).equals("1.265E+6")); 596 TestFmwk.assertTrue("cst122", ((new com.ibm.icu.math.BigDecimal("126.5E+8")).toString()).equals("1.265E+10")); 597 TestFmwk.assertTrue("cst123", ((new com.ibm.icu.math.BigDecimal("126.5E+20")).toString()).equals("1.265E+22")); 598 599 TestFmwk.assertTrue("cst130", ((new com.ibm.icu.math.BigDecimal("1265")).toString()).equals("1265")); 600 TestFmwk.assertTrue("cst131", ((new com.ibm.icu.math.BigDecimal("1265E-20")).toString()).equals("1.265E-17")); 601 TestFmwk.assertTrue("cst132", ((new com.ibm.icu.math.BigDecimal("1265E-8")).toString()).equals("1.265E-5")); 602 TestFmwk.assertTrue("cst133", ((new com.ibm.icu.math.BigDecimal("1265E-4")).toString()).equals("1.265E-1")); 603 TestFmwk.assertTrue("cst134", ((new com.ibm.icu.math.BigDecimal("1265E-3")).toString()).equals("1.265")); 604 TestFmwk.assertTrue("cst135", ((new com.ibm.icu.math.BigDecimal("1265E-2")).toString()).equals("1.265E+1")); 605 TestFmwk.assertTrue("cst136", ((new com.ibm.icu.math.BigDecimal("1265E-1")).toString()).equals("1.265E+2")); 606 TestFmwk.assertTrue("cst137", ((new com.ibm.icu.math.BigDecimal("1265E-0")).toString()).equals("1.265E+3")); 607 TestFmwk.assertTrue("cst138", ((new com.ibm.icu.math.BigDecimal("1265E+1")).toString()).equals("1.265E+4")); 608 TestFmwk.assertTrue("cst139", ((new com.ibm.icu.math.BigDecimal("1265E+2")).toString()).equals("1.265E+5")); 609 TestFmwk.assertTrue("cst140", ((new com.ibm.icu.math.BigDecimal("1265E+3")).toString()).equals("1.265E+6")); 610 TestFmwk.assertTrue("cst141", ((new com.ibm.icu.math.BigDecimal("1265E+4")).toString()).equals("1.265E+7")); 611 TestFmwk.assertTrue("cst142", ((new com.ibm.icu.math.BigDecimal("1265E+8")).toString()).equals("1.265E+11")); 612 TestFmwk.assertTrue("cst143", ((new com.ibm.icu.math.BigDecimal("1265E+20")).toString()).equals("1.265E+23")); 613 614 TestFmwk.assertTrue("cst150", ((new com.ibm.icu.math.BigDecimal("0.1265")).toString()).equals("0.1265")); 615 TestFmwk.assertTrue("cst151", ((new com.ibm.icu.math.BigDecimal("0.1265E-20")).toString()).equals("1.265E-21")); 616 TestFmwk.assertTrue("cst152", ((new com.ibm.icu.math.BigDecimal("0.1265E-8")).toString()).equals("1.265E-9")); 617 TestFmwk.assertTrue("cst153", ((new com.ibm.icu.math.BigDecimal("0.1265E-4")).toString()).equals("1.265E-5")); 618 TestFmwk.assertTrue("cst154", ((new com.ibm.icu.math.BigDecimal("0.1265E-3")).toString()).equals("1.265E-4")); 619 TestFmwk.assertTrue("cst155", ((new com.ibm.icu.math.BigDecimal("0.1265E-2")).toString()).equals("1.265E-3")); 620 TestFmwk.assertTrue("cst156", ((new com.ibm.icu.math.BigDecimal("0.1265E-1")).toString()).equals("1.265E-2")); 621 TestFmwk.assertTrue("cst157", ((new com.ibm.icu.math.BigDecimal("0.1265E-0")).toString()).equals("1.265E-1")); 622 TestFmwk.assertTrue("cst158", ((new com.ibm.icu.math.BigDecimal("0.1265E+1")).toString()).equals("1.265")); 623 TestFmwk.assertTrue("cst159", ((new com.ibm.icu.math.BigDecimal("0.1265E+2")).toString()).equals("1.265E+1")); 624 TestFmwk.assertTrue("cst160", ((new com.ibm.icu.math.BigDecimal("0.1265E+3")).toString()).equals("1.265E+2")); 625 TestFmwk.assertTrue("cst161", ((new com.ibm.icu.math.BigDecimal("0.1265E+4")).toString()).equals("1.265E+3")); 626 TestFmwk.assertTrue("cst162", ((new com.ibm.icu.math.BigDecimal("0.1265E+8")).toString()).equals("1.265E+7")); 627 TestFmwk.assertTrue("cst163", ((new com.ibm.icu.math.BigDecimal("0.1265E+20")).toString()).equals("1.265E+19")); 628 629 TestFmwk.assertTrue("cst170", ((new com.ibm.icu.math.BigDecimal("0.09e999999999")).toString()).equals("9E+999999997")); 630 TestFmwk.assertTrue("cst171", ((new com.ibm.icu.math.BigDecimal("0.9e999999999")).toString()).equals("9E+999999998")); 631 TestFmwk.assertTrue("cst172", ((new com.ibm.icu.math.BigDecimal("9e999999999")).toString()).equals("9E+999999999")); 632 TestFmwk.assertTrue("cst173", ((new com.ibm.icu.math.BigDecimal("9.9e999999999")).toString()).equals("9.9E+999999999")); 633 TestFmwk.assertTrue("cst174", ((new com.ibm.icu.math.BigDecimal("9.99e999999999")).toString()).equals("9.99E+999999999")); 634 TestFmwk.assertTrue("cst175", ((new com.ibm.icu.math.BigDecimal("9.99e-999999999")).toString()).equals("9.99E-999999999")); 635 TestFmwk.assertTrue("cst176", ((new com.ibm.icu.math.BigDecimal("9.9e-999999999")).toString()).equals("9.9E-999999999")); 636 TestFmwk.assertTrue("cst177", ((new com.ibm.icu.math.BigDecimal("9e-999999999")).toString()).equals("9E-999999999")); 637 TestFmwk.assertTrue("cst179", ((new com.ibm.icu.math.BigDecimal("99e-999999999")).toString()).equals("9.9E-999999998")); 638 TestFmwk.assertTrue("cst180", ((new com.ibm.icu.math.BigDecimal("999e-999999999")).toString()).equals("9.99E-999999997")); 639 640 // baddies -- 641 badstrings = new java.lang.String[] { "1..2", ".", "..", "++1", "--1", 642 "-+1", "+-1", "12e", "12e++", "12f4", " +1", "+ 1", "12 ", 643 " + 1", " - 1 ", "x", "-1-", "12-", "3+", "", "1e-", 644 "7e1000000000", "", "e100", "\u0e5a", "\u0b65", "99e999999999", 645 "999e999999999", "0.9e-999999999", "0.09e-999999999", 646 "0.1e1000000000", "10e-1000000000", "0.9e9999999999", 647 "99e-9999999999", "111e9999999999", 648 "1111e-9999999999" + " " + "111e*123", "111e123-", "111e+12+", 649 "111e1-3-", "111e1*23", "111e1e+3", "1e1.0", "1e123e", "ten", 650 "ONE", "1e.1", "1e1.", "1ee", "e+1" }; // 200-203 651 // 204-207 652 // 208-211 653 // 211-214 654 // 215-219 655 // 220-222 656 // 223-224 657 // 225-226 658 // 227-228 659 // 229-230 660 // 231-232 661 // 233-234 662 // 235-237 663 // 238-240 664 // 241-244 665 // 245-248 666 667 // watch out for commas on continuation lines 668 669 { 670 int $16 = badstrings.length; 671 i = 0; 672 for (; $16 > 0; $16--, i++) { 673 try { 674 new com.ibm.icu.math.BigDecimal(badstrings[i]); 675 say(">>> cst"+(200+i)+":"+" "+badstrings[i]+" "+(new com.ibm.icu.math.BigDecimal(badstrings[i])).toString()); 676 flag = false; 677 } catch (java.lang.NumberFormatException $17) { 678 flag = true; 679 } 680 TestFmwk.assertTrue("cst" + (200 + i), flag); 681 } 682 }/* i */ 683 684 try { 685 new com.ibm.icu.math.BigDecimal((java.lang.String) null); 686 flag = false; 687 } catch (java.lang.NullPointerException $18) { 688 flag = true; 689 }/* checknull */ 690 TestFmwk.assertTrue("cst301", flag); 691 692 return; 693 } 694 695 /** Mutation tests (checks that contents of constant objects are unchanged). */ 696 697 @Test 698 public void diagmutation() { 699 /* ---------------------------------------------------------------- */ 700 /* Final tests -- check constants haven't mutated */ 701 /* -- also that MC objects haven't mutated */ 702 /* ---------------------------------------------------------------- */ 703 TestFmwk.assertTrue("cuc001", (com.ibm.icu.math.BigDecimal.ZERO.toString()).equals("0")); 704 TestFmwk.assertTrue("cuc002", (com.ibm.icu.math.BigDecimal.ONE.toString()).equals("1")); 705 TestFmwk.assertTrue("cuc003", (com.ibm.icu.math.BigDecimal.TEN.toString()).equals("10")); 706 707 @SuppressWarnings("unused") 708 int constantVal; // workaround for "Comparing identical expressions" warnings 709 TestFmwk.assertTrue("cuc010", com.ibm.icu.math.BigDecimal.ROUND_CEILING == (constantVal = com.ibm.icu.math.MathContext.ROUND_CEILING)); 710 TestFmwk.assertTrue("cuc011", com.ibm.icu.math.BigDecimal.ROUND_DOWN == (constantVal = com.ibm.icu.math.MathContext.ROUND_DOWN)); 711 TestFmwk.assertTrue("cuc012", com.ibm.icu.math.BigDecimal.ROUND_FLOOR == (constantVal = com.ibm.icu.math.MathContext.ROUND_FLOOR)); 712 TestFmwk.assertTrue("cuc013", com.ibm.icu.math.BigDecimal.ROUND_HALF_DOWN == (constantVal = com.ibm.icu.math.MathContext.ROUND_HALF_DOWN)); 713 TestFmwk.assertTrue("cuc014", com.ibm.icu.math.BigDecimal.ROUND_HALF_EVEN == (constantVal = com.ibm.icu.math.MathContext.ROUND_HALF_EVEN)); 714 TestFmwk.assertTrue("cuc015", com.ibm.icu.math.BigDecimal.ROUND_HALF_UP == (constantVal = com.ibm.icu.math.MathContext.ROUND_HALF_UP)); 715 TestFmwk.assertTrue("cuc016", com.ibm.icu.math.BigDecimal.ROUND_UNNECESSARY == (constantVal = com.ibm.icu.math.MathContext.ROUND_UNNECESSARY)); 716 TestFmwk.assertTrue("cuc017", com.ibm.icu.math.BigDecimal.ROUND_UP == (constantVal = com.ibm.icu.math.MathContext.ROUND_UP)); 717 718 TestFmwk.assertTrue("cuc020", (com.ibm.icu.math.MathContext.DEFAULT.getDigits()) == 9); 719 TestFmwk.assertTrue("cuc021", (com.ibm.icu.math.MathContext.DEFAULT.getForm()) == com.ibm.icu.math.MathContext.SCIENTIFIC); 720 TestFmwk.assertTrue("cuc022", (com.ibm.icu.math.MathContext.DEFAULT.getLostDigits() ? 1 : 0) == 0); 721 TestFmwk.assertTrue("cuc023", (com.ibm.icu.math.MathContext.DEFAULT.getRoundingMode()) == com.ibm.icu.math.MathContext.ROUND_HALF_UP); 722 723 // mc9 =MathContext(9) 724 // mcld =MathContext(9, SCIENTIFIC, 1) 725 // mcfd =MathContext(0, PLAIN) 726 TestFmwk.assertTrue("cuc030", (mc9.getDigits()) == 9); 727 TestFmwk.assertTrue("cuc031", (mc9.getForm()) == com.ibm.icu.math.MathContext.SCIENTIFIC); 728 TestFmwk.assertTrue("cuc032", (mc9.getLostDigits() ? 1 : 0) == 0); 729 TestFmwk.assertTrue("cuc033", (mc9.getRoundingMode()) == com.ibm.icu.math.MathContext.ROUND_HALF_UP); 730 TestFmwk.assertTrue("cuc034", (mcld.getDigits()) == 9); 731 TestFmwk.assertTrue("cuc035", (mcld.getForm()) == com.ibm.icu.math.MathContext.SCIENTIFIC); 732 TestFmwk.assertTrue("cuc036", (mcld.getLostDigits() ? 1 : 0) == 1); 733 TestFmwk.assertTrue("cuc037", (mcld.getRoundingMode()) == com.ibm.icu.math.MathContext.ROUND_HALF_UP); 734 TestFmwk.assertTrue("cuc038", (mcfd.getDigits()) == 0); 735 TestFmwk.assertTrue("cuc039", (mcfd.getForm()) == com.ibm.icu.math.MathContext.PLAIN); 736 TestFmwk.assertTrue("cuc040", (mcfd.getLostDigits() ? 1 : 0) == 0); 737 TestFmwk.assertTrue("cuc041", (mcfd.getRoundingMode()) == com.ibm.icu.math.MathContext.ROUND_HALF_UP); 738 739 } 740 741 742 /* ----------------------------------------------------------------- */ 743 /* Operator test methods */ 744 /* ----------------------------------------------------------------- */ 745 // The use of context in these tests are primarily to show that they 746 // are correctly passed to the methods, except that we check that 747 // each method checks for lostDigits. 748 749 /** Test the {@link com.ibm.icu.math.BigDecimal#abs} method. */ 750 751 @Test 752 public void diagabs() { 753 boolean flag = false; 754 java.lang.ArithmeticException ae = null; 755 756 // most of the function of this is tested by add 757 TestFmwk.assertTrue("abs001", ((new com.ibm.icu.math.BigDecimal("2")).abs().toString()).equals("2")); 758 TestFmwk.assertTrue("abs002", ((new com.ibm.icu.math.BigDecimal("-2")).abs().toString()).equals("2")); 759 TestFmwk.assertTrue("abs003", ((new com.ibm.icu.math.BigDecimal("+0.000")).abs().toString()).equals("0.000")); 760 TestFmwk.assertTrue("abs004", ((new com.ibm.icu.math.BigDecimal("00.000")).abs().toString()).equals("0.000")); 761 TestFmwk.assertTrue("abs005", ((new com.ibm.icu.math.BigDecimal("-0.000")).abs().toString()).equals("0.000")); 762 TestFmwk.assertTrue("abs006", ((new com.ibm.icu.math.BigDecimal("+0.000")).abs(mcdef).toString()).equals("0")); 763 TestFmwk.assertTrue("abs007", ((new com.ibm.icu.math.BigDecimal("00.000")).abs(mcdef).toString()).equals("0")); 764 TestFmwk.assertTrue("abs008", ((new com.ibm.icu.math.BigDecimal("-0.000")).abs(mcdef).toString()).equals("0")); 765 TestFmwk.assertTrue("abs009", ((new com.ibm.icu.math.BigDecimal("-2000000")).abs().toString()).equals("2000000")); 766 TestFmwk.assertTrue("abs010", ((new com.ibm.icu.math.BigDecimal("-2000000")).abs(mcdef).toString()).equals("2000000")); 767 TestFmwk.assertTrue("abs011", ((new com.ibm.icu.math.BigDecimal("-2000000")).abs(mc6).toString()).equals("2.00000E+6")); 768 TestFmwk.assertTrue("abs012", ((new com.ibm.icu.math.BigDecimal("2000000")).abs(mc6).toString()).equals("2.00000E+6")); 769 TestFmwk.assertTrue("abs013", ((new com.ibm.icu.math.BigDecimal("0.2")).abs().toString()).equals("0.2")); 770 TestFmwk.assertTrue("abs014", ((new com.ibm.icu.math.BigDecimal("-0.2")).abs().toString()).equals("0.2")); 771 TestFmwk.assertTrue("abs015", ((new com.ibm.icu.math.BigDecimal("0.01")).abs().toString()).equals("0.01")); 772 TestFmwk.assertTrue("abs016", ((new com.ibm.icu.math.BigDecimal("-0.01")).abs().toString()).equals("0.01")); 773 try { 774 tenlong.abs(mcld); 775 flag = false; 776 } catch (java.lang.ArithmeticException $19) { 777 ae = $19; 778 flag = (ae.getMessage()).equals("Too many digits:" + " " 779 + tenlong.toString()); 780 }/* checkdigits */ 781 TestFmwk.assertTrue("abs020", flag); 782 // check lostdigits not raised if digits=0 [monadic method] 783 try { 784 tenlong.abs(mcld0); 785 flag = true; 786 } catch (java.lang.ArithmeticException $20) { 787 ae = $20; 788 flag = false; 789 }/* checkdigits */ 790 TestFmwk.assertTrue("abs021", flag); 791 try { 792 com.ibm.icu.math.BigDecimal.TEN 793 .abs((com.ibm.icu.math.MathContext) null); 794 flag = false; 795 } catch (java.lang.NullPointerException $21) { 796 flag = true; 797 }/* checknull */ 798 TestFmwk.assertTrue("abs022", flag); 799 800 } 801 802 /* ----------------------------------------------------------------- */ 803 804 /** Test the {@link com.ibm.icu.math.BigDecimal#add} method. */ 805 806 @Test 807 public void diagadd() { 808 boolean flag = false; 809 com.ibm.icu.math.BigDecimal alhs; 810 com.ibm.icu.math.BigDecimal arhs; 811 java.lang.ArithmeticException ae = null; 812 813 // [first group are 'quick confidence check'] 814 TestFmwk.assertTrue("add001", ((new com.ibm.icu.math.BigDecimal(2)).add(new com.ibm.icu.math.BigDecimal(3),mcdef).toString()).equals("5")); 815 TestFmwk.assertTrue("add003", ((new com.ibm.icu.math.BigDecimal("5.75")).add(new com.ibm.icu.math.BigDecimal("3.3"),mcdef).toString()).equals("9.05")); 816 TestFmwk.assertTrue("add004", ((new com.ibm.icu.math.BigDecimal("5")).add(new com.ibm.icu.math.BigDecimal("-3"),mcdef).toString()).equals("2")); 817 TestFmwk.assertTrue("add005", ((new com.ibm.icu.math.BigDecimal("-5")).add(new com.ibm.icu.math.BigDecimal("-3"),mcdef).toString()).equals("-8")); 818 TestFmwk.assertTrue("add006", ((new com.ibm.icu.math.BigDecimal("-7")).add(new com.ibm.icu.math.BigDecimal("2.5"),mcdef).toString()).equals("-4.5")); 819 TestFmwk.assertTrue("add007", ((new com.ibm.icu.math.BigDecimal("0.7")).add(new com.ibm.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("1.0")); 820 TestFmwk.assertTrue("add008", ((new com.ibm.icu.math.BigDecimal("1.25")).add(new com.ibm.icu.math.BigDecimal("1.25"),mcdef).toString()).equals("2.50")); 821 TestFmwk.assertTrue("add009", ((new com.ibm.icu.math.BigDecimal("1.23456789")).add(new com.ibm.icu.math.BigDecimal("1.00000000"),mcdef).toString()).equals("2.23456789")); 822 823 TestFmwk.assertTrue("add010", ((new com.ibm.icu.math.BigDecimal("1.23456789")).add(new com.ibm.icu.math.BigDecimal("1.00000011"),mcdef).toString()).equals("2.23456800")); 824 825 826 TestFmwk.assertTrue("add011", ((new com.ibm.icu.math.BigDecimal("0.4444444444")).add(new com.ibm.icu.math.BigDecimal("0.5555555555"),mcdef).toString()).equals("1.00000000")); 827 828 TestFmwk.assertTrue("add012", ((new com.ibm.icu.math.BigDecimal("0.4444444440")).add(new com.ibm.icu.math.BigDecimal("0.5555555555"),mcdef).toString()).equals("1.00000000")); 829 830 TestFmwk.assertTrue("add013", ((new com.ibm.icu.math.BigDecimal("0.4444444444")).add(new com.ibm.icu.math.BigDecimal("0.5555555550"),mcdef).toString()).equals("0.999999999")); 831 832 TestFmwk.assertTrue("add014", ((new com.ibm.icu.math.BigDecimal("0.4444444444999")).add(new com.ibm.icu.math.BigDecimal("0"),mcdef).toString()).equals("0.444444444")); 833 834 TestFmwk.assertTrue("add015", ((new com.ibm.icu.math.BigDecimal("0.4444444445000")).add(new com.ibm.icu.math.BigDecimal("0"),mcdef).toString()).equals("0.444444445")); 835 836 837 TestFmwk.assertTrue("add016", ((new com.ibm.icu.math.BigDecimal("70")).add(new com.ibm.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("1.00000000E+13")); 838 839 TestFmwk.assertTrue("add017", ((new com.ibm.icu.math.BigDecimal("700")).add(new com.ibm.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("1.00000000E+13")); 840 841 TestFmwk.assertTrue("add018", ((new com.ibm.icu.math.BigDecimal("7000")).add(new com.ibm.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("1.00000000E+13")); 842 843 TestFmwk.assertTrue("add019", ((new com.ibm.icu.math.BigDecimal("70000")).add(new com.ibm.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("1.00000001E+13")); 844 845 TestFmwk.assertTrue("add020", ((new com.ibm.icu.math.BigDecimal("700000")).add(new com.ibm.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("1.00000007E+13")); 846 847 848 // [Now the same group with fixed arithmetic] 849 TestFmwk.assertTrue("add030", ((new com.ibm.icu.math.BigDecimal(2)).add(new com.ibm.icu.math.BigDecimal(3)).toString()).equals("5")); 850 TestFmwk.assertTrue("add031", ((new com.ibm.icu.math.BigDecimal("5.75")).add(new com.ibm.icu.math.BigDecimal("3.3")).toString()).equals("9.05")); 851 TestFmwk.assertTrue("add032", ((new com.ibm.icu.math.BigDecimal("5")).add(new com.ibm.icu.math.BigDecimal("-3")).toString()).equals("2")); 852 TestFmwk.assertTrue("add033", ((new com.ibm.icu.math.BigDecimal("-5")).add(new com.ibm.icu.math.BigDecimal("-3")).toString()).equals("-8")); 853 TestFmwk.assertTrue("add034", ((new com.ibm.icu.math.BigDecimal("-7")).add(new com.ibm.icu.math.BigDecimal("2.5")).toString()).equals("-4.5")); 854 TestFmwk.assertTrue("add035", ((new com.ibm.icu.math.BigDecimal("0.7")).add(new com.ibm.icu.math.BigDecimal("0.3")).toString()).equals("1.0")); 855 TestFmwk.assertTrue("add036", ((new com.ibm.icu.math.BigDecimal("1.25")).add(new com.ibm.icu.math.BigDecimal("1.25")).toString()).equals("2.50")); 856 TestFmwk.assertTrue("add037", ((new com.ibm.icu.math.BigDecimal("1.23456789")).add(new com.ibm.icu.math.BigDecimal("1.00000000")).toString()).equals("2.23456789")); 857 858 TestFmwk.assertTrue("add038", ((new com.ibm.icu.math.BigDecimal("1.23456789")).add(new com.ibm.icu.math.BigDecimal("1.00000011")).toString()).equals("2.23456800")); 859 860 861 TestFmwk.assertTrue("add039", ((new com.ibm.icu.math.BigDecimal("0.4444444444")).add(new com.ibm.icu.math.BigDecimal("0.5555555555")).toString()).equals("0.9999999999")); 862 863 TestFmwk.assertTrue("add040", ((new com.ibm.icu.math.BigDecimal("0.4444444440")).add(new com.ibm.icu.math.BigDecimal("0.5555555555")).toString()).equals("0.9999999995")); 864 865 TestFmwk.assertTrue("add041", ((new com.ibm.icu.math.BigDecimal("0.4444444444")).add(new com.ibm.icu.math.BigDecimal("0.5555555550")).toString()).equals("0.9999999994")); 866 867 TestFmwk.assertTrue("add042", ((new com.ibm.icu.math.BigDecimal("0.4444444444999")).add(new com.ibm.icu.math.BigDecimal("0")).toString()).equals("0.4444444444999")); 868 869 TestFmwk.assertTrue("add043", ((new com.ibm.icu.math.BigDecimal("0.4444444445000")).add(new com.ibm.icu.math.BigDecimal("0")).toString()).equals("0.4444444445000")); 870 871 872 TestFmwk.assertTrue("add044", ((new com.ibm.icu.math.BigDecimal("70")).add(new com.ibm.icu.math.BigDecimal("10000e+9")).toString()).equals("10000000000070")); 873 874 TestFmwk.assertTrue("add045", ((new com.ibm.icu.math.BigDecimal("700")).add(new com.ibm.icu.math.BigDecimal("10000e+9")).toString()).equals("10000000000700")); 875 876 TestFmwk.assertTrue("add046", ((new com.ibm.icu.math.BigDecimal("7000")).add(new com.ibm.icu.math.BigDecimal("10000e+9")).toString()).equals("10000000007000")); 877 878 TestFmwk.assertTrue("add047", ((new com.ibm.icu.math.BigDecimal("70000")).add(new com.ibm.icu.math.BigDecimal("10000e+9")).toString()).equals("10000000070000")); 879 880 TestFmwk.assertTrue("add048", ((new com.ibm.icu.math.BigDecimal("700000")).add(new com.ibm.icu.math.BigDecimal("10000e+9")).toString()).equals("10000000700000")); 881 882 883 // symmetry: 884 TestFmwk.assertTrue("add049", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("70"),mcdef).toString()).equals("1.00000000E+13")); 885 886 TestFmwk.assertTrue("add050", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("700"),mcdef).toString()).equals("1.00000000E+13")); 887 888 TestFmwk.assertTrue("add051", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("7000"),mcdef).toString()).equals("1.00000000E+13")); 889 890 TestFmwk.assertTrue("add052", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("70000"),mcdef).toString()).equals("1.00000001E+13")); 891 892 TestFmwk.assertTrue("add053", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("700000"),mcdef).toString()).equals("1.00000007E+13")); 893 894 895 TestFmwk.assertTrue("add054", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("70")).toString()).equals("10000000000070")); 896 897 TestFmwk.assertTrue("add055", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("700")).toString()).equals("10000000000700")); 898 899 TestFmwk.assertTrue("add056", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("7000")).toString()).equals("10000000007000")); 900 901 TestFmwk.assertTrue("add057", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("70000")).toString()).equals("10000000070000")); 902 903 TestFmwk.assertTrue("add058", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("700000")).toString()).equals("10000000700000")); 904 905 // some rounding effects 906 TestFmwk.assertTrue("add059", ((new com.ibm.icu.math.BigDecimal("0.9998")).add(new com.ibm.icu.math.BigDecimal("0.0000")).toString()).equals("0.9998")); 907 908 TestFmwk.assertTrue("add060", ((new com.ibm.icu.math.BigDecimal("0.9998")).add(new com.ibm.icu.math.BigDecimal("0.0001")).toString()).equals("0.9999")); 909 910 TestFmwk.assertTrue("add061", ((new com.ibm.icu.math.BigDecimal("0.9998")).add(new com.ibm.icu.math.BigDecimal("0.0002")).toString()).equals("1.0000")); 911 912 TestFmwk.assertTrue("add062", ((new com.ibm.icu.math.BigDecimal("0.9998")).add(new com.ibm.icu.math.BigDecimal("0.0003")).toString()).equals("1.0001")); 913 914 915 // MC 916 TestFmwk.assertTrue("add070", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("70000"),mcfd).toString()).equals("10000000070000")); 917 918 TestFmwk.assertTrue("add071", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("70000"),mcdef).toString()).equals("1.00000001E+13")); 919 920 TestFmwk.assertTrue("add072", ((new com.ibm.icu.math.BigDecimal("10000e+9")).add(new com.ibm.icu.math.BigDecimal("70000"),mc6).toString()).equals("1.00000E+13")); 921 922 923 // zero preservation 924 TestFmwk.assertTrue("add080", (com.ibm.icu.math.BigDecimal.ONE.add(new com.ibm.icu.math.BigDecimal("0.0001"),mc6).toString()).equals("1.0001")); 925 926 TestFmwk.assertTrue("add081", (com.ibm.icu.math.BigDecimal.ONE.add(new com.ibm.icu.math.BigDecimal("0.00001"),mc6).toString()).equals("1.00001")); 927 928 TestFmwk.assertTrue("add082", (com.ibm.icu.math.BigDecimal.ONE.add(new com.ibm.icu.math.BigDecimal("0.000001"),mc6).toString()).equals("1.00000")); 929 930 TestFmwk.assertTrue("add083", (com.ibm.icu.math.BigDecimal.ONE.add(new com.ibm.icu.math.BigDecimal("0.0000001"),mc6).toString()).equals("1.00000")); 931 932 TestFmwk.assertTrue("add084", (com.ibm.icu.math.BigDecimal.ONE.add(new com.ibm.icu.math.BigDecimal("0.00000001"),mc6).toString()).equals("1.00000")); 933 934 935 // more fixed, LHS swaps 936 TestFmwk.assertTrue("add090", ((new com.ibm.icu.math.BigDecimal("-56267E-10")).add(zero).toString()).equals("-0.0000056267")); 937 TestFmwk.assertTrue("add091", ((new com.ibm.icu.math.BigDecimal("-56267E-6")).add(zero).toString()).equals("-0.056267")); 938 TestFmwk.assertTrue("add092", ((new com.ibm.icu.math.BigDecimal("-56267E-5")).add(zero).toString()).equals("-0.56267")); 939 TestFmwk.assertTrue("add093", ((new com.ibm.icu.math.BigDecimal("-56267E-4")).add(zero).toString()).equals("-5.6267")); 940 TestFmwk.assertTrue("add094", ((new com.ibm.icu.math.BigDecimal("-56267E-3")).add(zero).toString()).equals("-56.267")); 941 TestFmwk.assertTrue("add095", ((new com.ibm.icu.math.BigDecimal("-56267E-2")).add(zero).toString()).equals("-562.67")); 942 TestFmwk.assertTrue("add096", ((new com.ibm.icu.math.BigDecimal("-56267E-1")).add(zero).toString()).equals("-5626.7")); 943 TestFmwk.assertTrue("add097", ((new com.ibm.icu.math.BigDecimal("-56267E-0")).add(zero).toString()).equals("-56267")); 944 TestFmwk.assertTrue("add098", ((new com.ibm.icu.math.BigDecimal("-5E-10")).add(zero).toString()).equals("-0.0000000005")); 945 TestFmwk.assertTrue("add099", ((new com.ibm.icu.math.BigDecimal("-5E-5")).add(zero).toString()).equals("-0.00005")); 946 TestFmwk.assertTrue("add100", ((new com.ibm.icu.math.BigDecimal("-5E-1")).add(zero).toString()).equals("-0.5")); 947 TestFmwk.assertTrue("add101", ((new com.ibm.icu.math.BigDecimal("-5E-10")).add(zero).toString()).equals("-0.0000000005")); 948 TestFmwk.assertTrue("add102", ((new com.ibm.icu.math.BigDecimal("-5E-5")).add(zero).toString()).equals("-0.00005")); 949 TestFmwk.assertTrue("add103", ((new com.ibm.icu.math.BigDecimal("-5E-1")).add(zero).toString()).equals("-0.5")); 950 TestFmwk.assertTrue("add104", ((new com.ibm.icu.math.BigDecimal("-5E10")).add(zero).toString()).equals("-50000000000")); 951 TestFmwk.assertTrue("add105", ((new com.ibm.icu.math.BigDecimal("-5E5")).add(zero).toString()).equals("-500000")); 952 TestFmwk.assertTrue("add106", ((new com.ibm.icu.math.BigDecimal("-5E1")).add(zero).toString()).equals("-50")); 953 TestFmwk.assertTrue("add107", ((new com.ibm.icu.math.BigDecimal("-5E0")).add(zero).toString()).equals("-5")); 954 955 // more fixed, RHS swaps 956 TestFmwk.assertTrue("add108", (zero.add(new com.ibm.icu.math.BigDecimal("-56267E-10")).toString()).equals("-0.0000056267")); 957 TestFmwk.assertTrue("add109", (zero.add(new com.ibm.icu.math.BigDecimal("-56267E-6")).toString()).equals("-0.056267")); 958 TestFmwk.assertTrue("add110", (zero.add(new com.ibm.icu.math.BigDecimal("-56267E-5")).toString()).equals("-0.56267")); 959 TestFmwk.assertTrue("add111", (zero.add(new com.ibm.icu.math.BigDecimal("-56267E-4")).toString()).equals("-5.6267")); 960 TestFmwk.assertTrue("add112", (zero.add(new com.ibm.icu.math.BigDecimal("-56267E-3")).toString()).equals("-56.267")); 961 TestFmwk.assertTrue("add113", (zero.add(new com.ibm.icu.math.BigDecimal("-56267E-2")).toString()).equals("-562.67")); 962 TestFmwk.assertTrue("add114", (zero.add(new com.ibm.icu.math.BigDecimal("-56267E-1")).toString()).equals("-5626.7")); 963 TestFmwk.assertTrue("add115", (zero.add(new com.ibm.icu.math.BigDecimal("-56267E-0")).toString()).equals("-56267")); 964 TestFmwk.assertTrue("add116", (zero.add(new com.ibm.icu.math.BigDecimal("-5E-10")).toString()).equals("-0.0000000005")); 965 TestFmwk.assertTrue("add117", (zero.add(new com.ibm.icu.math.BigDecimal("-5E-5")).toString()).equals("-0.00005")); 966 TestFmwk.assertTrue("add118", (zero.add(new com.ibm.icu.math.BigDecimal("-5E-1")).toString()).equals("-0.5")); 967 TestFmwk.assertTrue("add129", (zero.add(new com.ibm.icu.math.BigDecimal("-5E-10")).toString()).equals("-0.0000000005")); 968 TestFmwk.assertTrue("add130", (zero.add(new com.ibm.icu.math.BigDecimal("-5E-5")).toString()).equals("-0.00005")); 969 TestFmwk.assertTrue("add131", (zero.add(new com.ibm.icu.math.BigDecimal("-5E-1")).toString()).equals("-0.5")); 970 TestFmwk.assertTrue("add132", (zero.add(new com.ibm.icu.math.BigDecimal("-5E10")).toString()).equals("-50000000000")); 971 TestFmwk.assertTrue("add133", (zero.add(new com.ibm.icu.math.BigDecimal("-5E5")).toString()).equals("-500000")); 972 TestFmwk.assertTrue("add134", (zero.add(new com.ibm.icu.math.BigDecimal("-5E1")).toString()).equals("-50")); 973 TestFmwk.assertTrue("add135", (zero.add(new com.ibm.icu.math.BigDecimal("-5E0")).toString()).equals("-5")); 974 975 // [some of the next group are really constructor tests] 976 TestFmwk.assertTrue("add140", ((new com.ibm.icu.math.BigDecimal("00.0")).add(new com.ibm.icu.math.BigDecimal("0.00"),mcdef).toString()).equals("0")); 977 TestFmwk.assertTrue("add141", ((new com.ibm.icu.math.BigDecimal("0.00")).add(new com.ibm.icu.math.BigDecimal("00.0"),mcdef).toString()).equals("0")); 978 TestFmwk.assertTrue("add142", ((new com.ibm.icu.math.BigDecimal("3")).add(new com.ibm.icu.math.BigDecimal(".3"),mcdef).toString()).equals("3.3")); 979 TestFmwk.assertTrue("add143", ((new com.ibm.icu.math.BigDecimal("3.")).add(new com.ibm.icu.math.BigDecimal(".3"),mcdef).toString()).equals("3.3")); 980 TestFmwk.assertTrue("add144", ((new com.ibm.icu.math.BigDecimal("3.0")).add(new com.ibm.icu.math.BigDecimal(".3"),mcdef).toString()).equals("3.3")); 981 TestFmwk.assertTrue("add145", ((new com.ibm.icu.math.BigDecimal("3.00")).add(new com.ibm.icu.math.BigDecimal(".3"),mcdef).toString()).equals("3.30")); 982 TestFmwk.assertTrue("add146", ((new com.ibm.icu.math.BigDecimal("3")).add(new com.ibm.icu.math.BigDecimal("3"),mcdef).toString()).equals("6")); 983 TestFmwk.assertTrue("add147", ((new com.ibm.icu.math.BigDecimal("3")).add(new com.ibm.icu.math.BigDecimal("+3"),mcdef).toString()).equals("6")); 984 TestFmwk.assertTrue("add148", ((new com.ibm.icu.math.BigDecimal("3")).add(new com.ibm.icu.math.BigDecimal("-3"),mcdef).toString()).equals("0")); 985 TestFmwk.assertTrue("add149", ((new com.ibm.icu.math.BigDecimal("0.03")).add(new com.ibm.icu.math.BigDecimal("-0.03"),mcdef).toString()).equals("0")); 986 987 TestFmwk.assertTrue("add150", ((new com.ibm.icu.math.BigDecimal("00.0")).add(new com.ibm.icu.math.BigDecimal("0.00")).toString()).equals("0.00")); 988 TestFmwk.assertTrue("add151", ((new com.ibm.icu.math.BigDecimal("0.00")).add(new com.ibm.icu.math.BigDecimal("00.0")).toString()).equals("0.00")); 989 TestFmwk.assertTrue("add152", ((new com.ibm.icu.math.BigDecimal("3")).add(new com.ibm.icu.math.BigDecimal(".3")).toString()).equals("3.3")); 990 TestFmwk.assertTrue("add153", ((new com.ibm.icu.math.BigDecimal("3.")).add(new com.ibm.icu.math.BigDecimal(".3")).toString()).equals("3.3")); 991 TestFmwk.assertTrue("add154", ((new com.ibm.icu.math.BigDecimal("3.0")).add(new com.ibm.icu.math.BigDecimal(".3")).toString()).equals("3.3")); 992 TestFmwk.assertTrue("add155", ((new com.ibm.icu.math.BigDecimal("3.00")).add(new com.ibm.icu.math.BigDecimal(".3")).toString()).equals("3.30")); 993 TestFmwk.assertTrue("add156", ((new com.ibm.icu.math.BigDecimal("3")).add(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("6")); 994 TestFmwk.assertTrue("add157", ((new com.ibm.icu.math.BigDecimal("3")).add(new com.ibm.icu.math.BigDecimal("+3")).toString()).equals("6")); 995 TestFmwk.assertTrue("add158", ((new com.ibm.icu.math.BigDecimal("3")).add(new com.ibm.icu.math.BigDecimal("-3")).toString()).equals("0")); 996 TestFmwk.assertTrue("add159", ((new com.ibm.icu.math.BigDecimal("0.3")).add(new com.ibm.icu.math.BigDecimal("-0.3")).toString()).equals("0.0")); 997 TestFmwk.assertTrue("add160", ((new com.ibm.icu.math.BigDecimal("0.03")).add(new com.ibm.icu.math.BigDecimal("-0.03")).toString()).equals("0.00")); 998 TestFmwk.assertTrue("add161", ((new com.ibm.icu.math.BigDecimal("7E+12")).add(new com.ibm.icu.math.BigDecimal("-1"),mcfd).toString()).equals("6999999999999")); 999 1000 TestFmwk.assertTrue("add162", ((new com.ibm.icu.math.BigDecimal("7E+12")).add(new com.ibm.icu.math.BigDecimal("1.11"),mcfd).toString()).equals("7000000000001.11")); 1001 1002 TestFmwk.assertTrue("add163", ((new com.ibm.icu.math.BigDecimal("1.11")).add(new com.ibm.icu.math.BigDecimal("7E+12"),mcfd).toString()).equals("7000000000001.11")); 1003 1004 1005 // input preparation tests 1006 alhs=new com.ibm.icu.math.BigDecimal("12345678900000"); 1007 arhs=new com.ibm.icu.math.BigDecimal("9999999999999"); 1008 TestFmwk.assertTrue("add170", (alhs.add(arhs,mc3).toString()).equals("2.23E+13")); 1009 TestFmwk.assertTrue("add171", (arhs.add(alhs,mc3).toString()).equals("2.23E+13")); 1010 TestFmwk.assertTrue("add172", ((new com.ibm.icu.math.BigDecimal("12E+3")).add(new com.ibm.icu.math.BigDecimal("3456"),mc3).toString()).equals("1.55E+4")); 1011 // next was 1.54E+4 under old [truncate to digits+1] rules 1012 TestFmwk.assertTrue("add173", ((new com.ibm.icu.math.BigDecimal("12E+3")).add(new com.ibm.icu.math.BigDecimal("3446"),mc3).toString()).equals("1.55E+4")); 1013 TestFmwk.assertTrue("add174", ((new com.ibm.icu.math.BigDecimal("12E+3")).add(new com.ibm.icu.math.BigDecimal("3454"),mc3).toString()).equals("1.55E+4")); 1014 TestFmwk.assertTrue("add175", ((new com.ibm.icu.math.BigDecimal("12E+3")).add(new com.ibm.icu.math.BigDecimal("3444"),mc3).toString()).equals("1.54E+4")); 1015 1016 TestFmwk.assertTrue("add176", ((new com.ibm.icu.math.BigDecimal("3456")).add(new com.ibm.icu.math.BigDecimal("12E+3"),mc3).toString()).equals("1.55E+4")); 1017 // next was 1.54E+4 under old [truncate to digits+1] rules 1018 TestFmwk.assertTrue("add177", ((new com.ibm.icu.math.BigDecimal("3446")).add(new com.ibm.icu.math.BigDecimal("12E+3"),mc3).toString()).equals("1.55E+4")); 1019 TestFmwk.assertTrue("add178", ((new com.ibm.icu.math.BigDecimal("3454")).add(new com.ibm.icu.math.BigDecimal("12E+3"),mc3).toString()).equals("1.55E+4")); 1020 TestFmwk.assertTrue("add179", ((new com.ibm.icu.math.BigDecimal("3444")).add(new com.ibm.icu.math.BigDecimal("12E+3"),mc3).toString()).equals("1.54E+4")); 1021 1022 try { 1023 ten.add((com.ibm.icu.math.BigDecimal) null); 1024 flag = false; 1025 } catch (java.lang.NullPointerException $22) { 1026 flag = true; 1027 }/* checknull */ 1028 TestFmwk.assertTrue("add200", flag); 1029 try { 1030 ten.add(ten, (com.ibm.icu.math.MathContext) null); 1031 flag = false; 1032 } catch (java.lang.NullPointerException $23) { 1033 flag = true; 1034 }/* checknull2 */ 1035 TestFmwk.assertTrue("add201", flag); 1036 1037 try { 1038 tenlong.add(com.ibm.icu.math.BigDecimal.ZERO, mcld); 1039 flag = false; 1040 } catch (java.lang.ArithmeticException $24) { 1041 ae = $24; 1042 flag = (ae.getMessage()).equals("Too many digits:" + " " 1043 + tenlong.toString()); 1044 }/* checkdigits */ 1045 TestFmwk.assertTrue("add202", flag); 1046 try { 1047 com.ibm.icu.math.BigDecimal.ZERO.add(tenlong, mcld); 1048 flag = false; 1049 } catch (java.lang.ArithmeticException $25) { 1050 ae = $25; 1051 flag = (ae.getMessage()).equals("Too many digits:" + " " 1052 + tenlong.toString()); 1053 }/* checkdigits */ 1054 TestFmwk.assertTrue("add203", flag); 1055 1056 // check lostdigits not raised if digits=0 [dyadic method] 1057 try { 1058 tenlong.add(com.ibm.icu.math.BigDecimal.ZERO, mcld0); 1059 flag = true; 1060 } catch (java.lang.ArithmeticException $26) { 1061 ae = $26; 1062 flag = false; 1063 }/* checkdigits */ 1064 TestFmwk.assertTrue("add204", flag); 1065 try { 1066 com.ibm.icu.math.BigDecimal.ZERO.add(tenlong, mcld0); 1067 flag = true; 1068 } catch (java.lang.ArithmeticException $27) { 1069 ae = $27; 1070 flag = false; 1071 }/* checkdigits */ 1072 TestFmwk.assertTrue("add205", flag); 1073 1074 } 1075 1076 /* ----------------------------------------------------------------- */ 1077 /** 1078 * Test the {@link com.ibm.icu.math.BigDecimal#compareTo(BigDecimal)} 1079 * method. 1080 */ 1081 1082 @Test 1083 public void diagcompareto() { 1084 boolean flag = false; 1085 java.lang.ArithmeticException ae = null; 1086 // we assume add/subtract test function; this just 1087 // tests existence, exceptions, and possible results 1088 1089 TestFmwk.assertTrue("cpt001", ((new com.ibm.icu.math.BigDecimal("5")).compareTo(new com.ibm.icu.math.BigDecimal("2")))==1); 1090 TestFmwk.assertTrue("cpt002", ((new com.ibm.icu.math.BigDecimal("5")).compareTo(new com.ibm.icu.math.BigDecimal("5")))==0); 1091 TestFmwk.assertTrue("cpt003", ((new com.ibm.icu.math.BigDecimal("5")).compareTo(new com.ibm.icu.math.BigDecimal("5.00")))==0); 1092 TestFmwk.assertTrue("cpt004", ((new com.ibm.icu.math.BigDecimal("0.5")).compareTo(new com.ibm.icu.math.BigDecimal("0.5")))==0); 1093 TestFmwk.assertTrue("cpt005", ((new com.ibm.icu.math.BigDecimal("2")).compareTo(new com.ibm.icu.math.BigDecimal("5")))==(-1)); 1094 TestFmwk.assertTrue("cpt006", ((new com.ibm.icu.math.BigDecimal("2")).compareTo(new com.ibm.icu.math.BigDecimal("5"),mcdef))==(-1)); 1095 TestFmwk.assertTrue("cpt007", ((new com.ibm.icu.math.BigDecimal("2")).compareTo(new com.ibm.icu.math.BigDecimal("5"),mc6))==(-1)); 1096 TestFmwk.assertTrue("cpt008", ((new com.ibm.icu.math.BigDecimal("2")).compareTo(new com.ibm.icu.math.BigDecimal("5"),mcfd))==(-1)); 1097 try { 1098 ten.compareTo((com.ibm.icu.math.BigDecimal) null); 1099 flag = false; 1100 } catch (java.lang.NullPointerException $28) { 1101 flag = true; 1102 }/* checknull */ 1103 TestFmwk.assertTrue("cpt100", flag); 1104 try { 1105 ten.compareTo(ten, (com.ibm.icu.math.MathContext) null); 1106 flag = false; 1107 } catch (java.lang.NullPointerException $29) { 1108 flag = true; 1109 }/* checknull2 */ 1110 TestFmwk.assertTrue("cpt101", flag); 1111 1112 try { 1113 tenlong.compareTo(com.ibm.icu.math.BigDecimal.ONE, mcld); 1114 flag = false; 1115 } catch (java.lang.ArithmeticException $30) { 1116 ae = $30; 1117 flag = (ae.getMessage()).equals("Too many digits:" + " " 1118 + tenlong.toString()); 1119 }/* checkdigits */ 1120 TestFmwk.assertTrue("cpt102", flag); 1121 try { 1122 com.ibm.icu.math.BigDecimal.ONE.compareTo(tenlong, mcld); 1123 flag = false; 1124 } catch (java.lang.ArithmeticException $31) { 1125 ae = $31; 1126 flag = (ae.getMessage()).equals("Too many digits:" + " " 1127 + tenlong.toString()); 1128 }/* checkdigits */ 1129 TestFmwk.assertTrue("cpt103", flag); 1130 1131 } 1132 1133 /* ----------------------------------------------------------------- */ 1134 1135 /** Test the {@link com.ibm.icu.math.BigDecimal#divide} method. */ 1136 1137 @Test 1138 public void diagdivide() { 1139 boolean flag = false; 1140 com.ibm.icu.math.MathContext rmcd; 1141 int rhu; 1142 int rd; 1143 int ru; 1144 java.lang.RuntimeException e = null; 1145 java.lang.ArithmeticException ae = null; 1146 1147 TestFmwk.assertTrue("div301", ((new com.ibm.icu.math.BigDecimal("1")).divide(new com.ibm.icu.math.BigDecimal("3"),mcdef).toString()).equals("0.333333333")); 1148 TestFmwk.assertTrue("div302", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),mcdef).toString()).equals("0.666666667")); 1149 TestFmwk.assertTrue("div303", ((new com.ibm.icu.math.BigDecimal("2.4")).divide(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("2.4")); 1150 TestFmwk.assertTrue("div304", ((new com.ibm.icu.math.BigDecimal("2.4")).divide(new com.ibm.icu.math.BigDecimal("-1"),mcdef).toString()).equals("-2.4")); 1151 TestFmwk.assertTrue("div305", ((new com.ibm.icu.math.BigDecimal("-2.4")).divide(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("-2.4")); 1152 TestFmwk.assertTrue("div306", ((new com.ibm.icu.math.BigDecimal("-2.4")).divide(new com.ibm.icu.math.BigDecimal("-1"),mcdef).toString()).equals("2.4")); 1153 TestFmwk.assertTrue("div307", ((new com.ibm.icu.math.BigDecimal("2.40")).divide(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("2.4")); 1154 TestFmwk.assertTrue("div308", ((new com.ibm.icu.math.BigDecimal("2.400")).divide(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("2.4")); 1155 TestFmwk.assertTrue("div309", ((new com.ibm.icu.math.BigDecimal("2.4")).divide(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("1.2")); 1156 TestFmwk.assertTrue("div310", ((new com.ibm.icu.math.BigDecimal("2.400")).divide(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("1.2")); 1157 TestFmwk.assertTrue("div311", ((new com.ibm.icu.math.BigDecimal("2.")).divide(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("1")); 1158 TestFmwk.assertTrue("div312", ((new com.ibm.icu.math.BigDecimal("20")).divide(new com.ibm.icu.math.BigDecimal("20"),mcdef).toString()).equals("1")); 1159 TestFmwk.assertTrue("div313", ((new com.ibm.icu.math.BigDecimal("187")).divide(new com.ibm.icu.math.BigDecimal("187"),mcdef).toString()).equals("1")); 1160 TestFmwk.assertTrue("div314", ((new com.ibm.icu.math.BigDecimal("5")).divide(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("2.5")); 1161 TestFmwk.assertTrue("div315", ((new com.ibm.icu.math.BigDecimal("5")).divide(new com.ibm.icu.math.BigDecimal("2.0"),mcdef).toString()).equals("2.5")); 1162 TestFmwk.assertTrue("div316", ((new com.ibm.icu.math.BigDecimal("5")).divide(new com.ibm.icu.math.BigDecimal("2.000"),mcdef).toString()).equals("2.5")); 1163 TestFmwk.assertTrue("div317", ((new com.ibm.icu.math.BigDecimal("5")).divide(new com.ibm.icu.math.BigDecimal("0.200"),mcdef).toString()).equals("25")); 1164 TestFmwk.assertTrue("div318", ((new com.ibm.icu.math.BigDecimal("999999999")).divide(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("999999999")); 1165 TestFmwk.assertTrue("div319", ((new com.ibm.icu.math.BigDecimal("999999999.4")).divide(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("999999999")); 1166 TestFmwk.assertTrue("div320", ((new com.ibm.icu.math.BigDecimal("999999999.5")).divide(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("1E+9")); 1167 TestFmwk.assertTrue("div321", ((new com.ibm.icu.math.BigDecimal("999999999.9")).divide(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("1E+9")); 1168 TestFmwk.assertTrue("div322", ((new com.ibm.icu.math.BigDecimal("999999999.999")).divide(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("1E+9")); 1169 TestFmwk.assertTrue("div323", ((new com.ibm.icu.math.BigDecimal("0.0000E-50")).divide(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("0")); 1170 // MC 1171 TestFmwk.assertTrue("div325", ((new com.ibm.icu.math.BigDecimal("999999999")).divide(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("999999999")); 1172 TestFmwk.assertTrue("div326", ((new com.ibm.icu.math.BigDecimal("999999999")).divide(new com.ibm.icu.math.BigDecimal("1"),mc6).toString()).equals("1E+9")); 1173 TestFmwk.assertTrue("div327", ((new com.ibm.icu.math.BigDecimal("9999999")).divide(new com.ibm.icu.math.BigDecimal("1"),mc6).toString()).equals("1E+7")); 1174 TestFmwk.assertTrue("div328", ((new com.ibm.icu.math.BigDecimal("999999")).divide(new com.ibm.icu.math.BigDecimal("1"),mc6).toString()).equals("999999")); 1175 1176 // check rounding explicitly [note: digits+1 truncation] 1177 rmcd=new com.ibm.icu.math.MathContext(2,com.ibm.icu.math.MathContext.SCIENTIFIC,false,com.ibm.icu.math.MathContext.ROUND_CEILING); 1178 TestFmwk.assertTrue("div330", ((new com.ibm.icu.math.BigDecimal("1.50")).divide(one,rmcd).toString()).equals("1.5")); 1179 TestFmwk.assertTrue("div331", ((new com.ibm.icu.math.BigDecimal("1.51")).divide(one,rmcd).toString()).equals("1.6")); 1180 TestFmwk.assertTrue("div332", ((new com.ibm.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.6")); 1181 rmcd=new com.ibm.icu.math.MathContext(2,com.ibm.icu.math.MathContext.SCIENTIFIC,false,com.ibm.icu.math.MathContext.ROUND_DOWN); 1182 TestFmwk.assertTrue("div333", ((new com.ibm.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.5")); 1183 TestFmwk.assertTrue("div334", ((new com.ibm.icu.math.BigDecimal("1.59")).divide(one,rmcd).toString()).equals("1.5")); 1184 rmcd=new com.ibm.icu.math.MathContext(2,com.ibm.icu.math.MathContext.SCIENTIFIC,false,com.ibm.icu.math.MathContext.ROUND_FLOOR); 1185 TestFmwk.assertTrue("div335", ((new com.ibm.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.5")); 1186 TestFmwk.assertTrue("div336", ((new com.ibm.icu.math.BigDecimal("1.59")).divide(one,rmcd).toString()).equals("1.5")); 1187 rmcd=new com.ibm.icu.math.MathContext(2,com.ibm.icu.math.MathContext.SCIENTIFIC,false,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN); 1188 TestFmwk.assertTrue("div337", ((new com.ibm.icu.math.BigDecimal("1.45")).divide(one,rmcd).toString()).equals("1.4")); 1189 TestFmwk.assertTrue("div338", ((new com.ibm.icu.math.BigDecimal("1.50")).divide(one,rmcd).toString()).equals("1.5")); 1190 TestFmwk.assertTrue("div339", ((new com.ibm.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.5")); 1191 rmcd=new com.ibm.icu.math.MathContext(2,com.ibm.icu.math.MathContext.SCIENTIFIC,false,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN); 1192 TestFmwk.assertTrue("div340", ((new com.ibm.icu.math.BigDecimal("1.45")).divide(one,rmcd).toString()).equals("1.4")); 1193 TestFmwk.assertTrue("div341", ((new com.ibm.icu.math.BigDecimal("1.50")).divide(one,rmcd).toString()).equals("1.5")); 1194 TestFmwk.assertTrue("div342", ((new com.ibm.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.6")); 1195 rmcd=new com.ibm.icu.math.MathContext(2,com.ibm.icu.math.MathContext.SCIENTIFIC,false,com.ibm.icu.math.MathContext.ROUND_HALF_UP); 1196 TestFmwk.assertTrue("div343", ((new com.ibm.icu.math.BigDecimal("1.45")).divide(one,rmcd).toString()).equals("1.5")); 1197 TestFmwk.assertTrue("div344", ((new com.ibm.icu.math.BigDecimal("1.50")).divide(one,rmcd).toString()).equals("1.5")); 1198 TestFmwk.assertTrue("div345", ((new com.ibm.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.6")); 1199 rmcd=new com.ibm.icu.math.MathContext(2,com.ibm.icu.math.MathContext.SCIENTIFIC,false,com.ibm.icu.math.MathContext.ROUND_UP); 1200 TestFmwk.assertTrue("div346", ((new com.ibm.icu.math.BigDecimal("1.50")).divide(one,rmcd).toString()).equals("1.5")); 1201 TestFmwk.assertTrue("div347", ((new com.ibm.icu.math.BigDecimal("1.51")).divide(one,rmcd).toString()).equals("1.6")); 1202 TestFmwk.assertTrue("div348", ((new com.ibm.icu.math.BigDecimal("1.55")).divide(one,rmcd).toString()).equals("1.6")); 1203 1204 // fixed point... 1205 TestFmwk.assertTrue("div350", ((new com.ibm.icu.math.BigDecimal("1")).divide(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("0")); 1206 TestFmwk.assertTrue("div351", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("1")); 1207 TestFmwk.assertTrue("div352", ((new com.ibm.icu.math.BigDecimal("2.4")).divide(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("2.4")); 1208 TestFmwk.assertTrue("div353", ((new com.ibm.icu.math.BigDecimal("2.4")).divide(new com.ibm.icu.math.BigDecimal("-1")).toString()).equals("-2.4")); 1209 TestFmwk.assertTrue("div354", ((new com.ibm.icu.math.BigDecimal("-2.4")).divide(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("-2.4")); 1210 TestFmwk.assertTrue("div355", ((new com.ibm.icu.math.BigDecimal("-2.4")).divide(new com.ibm.icu.math.BigDecimal("-1")).toString()).equals("2.4")); 1211 TestFmwk.assertTrue("div356", ((new com.ibm.icu.math.BigDecimal("2.40")).divide(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("2.40")); 1212 TestFmwk.assertTrue("div357", ((new com.ibm.icu.math.BigDecimal("2.400")).divide(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("2.400")); 1213 TestFmwk.assertTrue("div358", ((new com.ibm.icu.math.BigDecimal("2.4")).divide(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("1.2")); 1214 TestFmwk.assertTrue("div359", ((new com.ibm.icu.math.BigDecimal("2.400")).divide(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("1.200")); 1215 TestFmwk.assertTrue("div360", ((new com.ibm.icu.math.BigDecimal("2.")).divide(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("1")); 1216 TestFmwk.assertTrue("div361", ((new com.ibm.icu.math.BigDecimal("20")).divide(new com.ibm.icu.math.BigDecimal("20")).toString()).equals("1")); 1217 TestFmwk.assertTrue("div362", ((new com.ibm.icu.math.BigDecimal("187")).divide(new com.ibm.icu.math.BigDecimal("187")).toString()).equals("1")); 1218 TestFmwk.assertTrue("div363", ((new com.ibm.icu.math.BigDecimal("5")).divide(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("3")); 1219 TestFmwk.assertTrue("div364", ((new com.ibm.icu.math.BigDecimal("5")).divide(new com.ibm.icu.math.BigDecimal("2.0")).toString()).equals("3")); 1220 TestFmwk.assertTrue("div365", ((new com.ibm.icu.math.BigDecimal("5")).divide(new com.ibm.icu.math.BigDecimal("2.000")).toString()).equals("3")); 1221 TestFmwk.assertTrue("div366", ((new com.ibm.icu.math.BigDecimal("5")).divide(new com.ibm.icu.math.BigDecimal("0.200")).toString()).equals("25")); 1222 TestFmwk.assertTrue("div367", ((new com.ibm.icu.math.BigDecimal("5.0")).divide(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("2.5")); 1223 TestFmwk.assertTrue("div368", ((new com.ibm.icu.math.BigDecimal("5.0")).divide(new com.ibm.icu.math.BigDecimal("2.0")).toString()).equals("2.5")); 1224 TestFmwk.assertTrue("div369", ((new com.ibm.icu.math.BigDecimal("5.0")).divide(new com.ibm.icu.math.BigDecimal("2.000")).toString()).equals("2.5")); 1225 TestFmwk.assertTrue("div370", ((new com.ibm.icu.math.BigDecimal("5.0")).divide(new com.ibm.icu.math.BigDecimal("0.200")).toString()).equals("25.0")); 1226 TestFmwk.assertTrue("div371", ((new com.ibm.icu.math.BigDecimal("999999999")).divide(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("999999999")); 1227 TestFmwk.assertTrue("div372", ((new com.ibm.icu.math.BigDecimal("999999999.4")).divide(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("999999999.4")); 1228 TestFmwk.assertTrue("div373", ((new com.ibm.icu.math.BigDecimal("999999999.5")).divide(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("999999999.5")); 1229 TestFmwk.assertTrue("div374", ((new com.ibm.icu.math.BigDecimal("999999999.9")).divide(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("999999999.9")); 1230 TestFmwk.assertTrue("div375", ((new com.ibm.icu.math.BigDecimal("999999999.999")).divide(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("999999999.999")); 1231 TestFmwk.assertTrue("div376", ((new com.ibm.icu.math.BigDecimal("0.0000E-5")).divide(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("0")); 1232 TestFmwk.assertTrue("div377", ((new com.ibm.icu.math.BigDecimal("0.000000000")).divide(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("0.000000000")); 1233 1234 // - Fixed point; explicit scales & rounds [old BigDecimal divides] 1235 rhu = com.ibm.icu.math.MathContext.ROUND_HALF_UP; 1236 rd = com.ibm.icu.math.MathContext.ROUND_DOWN; 1237 TestFmwk.assertTrue("div001", ((new com.ibm.icu.math.BigDecimal("0")).divide(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("0")); 1238 TestFmwk.assertTrue("div002", ((new com.ibm.icu.math.BigDecimal("0")).divide(new com.ibm.icu.math.BigDecimal("3"),rhu).toString()).equals("0")); 1239 TestFmwk.assertTrue("div003", ((new com.ibm.icu.math.BigDecimal("0")).divide(new com.ibm.icu.math.BigDecimal("3"),0,rhu).toString()).equals("0")); 1240 TestFmwk.assertTrue("div004", ((new com.ibm.icu.math.BigDecimal("0")).divide(new com.ibm.icu.math.BigDecimal("3"),1,rhu).toString()).equals("0.0")); 1241 TestFmwk.assertTrue("div005", ((new com.ibm.icu.math.BigDecimal("0")).divide(new com.ibm.icu.math.BigDecimal("3"),2,rhu).toString()).equals("0.00")); 1242 TestFmwk.assertTrue("div006", ((new com.ibm.icu.math.BigDecimal("0")).divide(new com.ibm.icu.math.BigDecimal("3"),3,rhu).toString()).equals("0.000")); 1243 TestFmwk.assertTrue("div007", ((new com.ibm.icu.math.BigDecimal("0")).divide(new com.ibm.icu.math.BigDecimal("3"),4,rhu).toString()).equals("0.0000")); 1244 TestFmwk.assertTrue("div008", ((new com.ibm.icu.math.BigDecimal("1")).divide(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("0")); 1245 TestFmwk.assertTrue("div009", ((new com.ibm.icu.math.BigDecimal("1")).divide(new com.ibm.icu.math.BigDecimal("3"),rhu).toString()).equals("0")); 1246 TestFmwk.assertTrue("div010", ((new com.ibm.icu.math.BigDecimal("1")).divide(new com.ibm.icu.math.BigDecimal("3"),0,rhu).toString()).equals("0")); 1247 TestFmwk.assertTrue("div011", ((new com.ibm.icu.math.BigDecimal("1")).divide(new com.ibm.icu.math.BigDecimal("3"),1,rhu).toString()).equals("0.3")); 1248 TestFmwk.assertTrue("div012", ((new com.ibm.icu.math.BigDecimal("1")).divide(new com.ibm.icu.math.BigDecimal("3"),2,rhu).toString()).equals("0.33")); 1249 TestFmwk.assertTrue("div013", ((new com.ibm.icu.math.BigDecimal("1")).divide(new com.ibm.icu.math.BigDecimal("3"),3,rhu).toString()).equals("0.333")); 1250 TestFmwk.assertTrue("div014", ((new com.ibm.icu.math.BigDecimal("1")).divide(new com.ibm.icu.math.BigDecimal("3"),4,rhu).toString()).equals("0.3333")); 1251 TestFmwk.assertTrue("div015", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("1")); 1252 TestFmwk.assertTrue("div016", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),rhu).toString()).equals("1")); 1253 TestFmwk.assertTrue("div017", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),0,rhu).toString()).equals("1")); 1254 TestFmwk.assertTrue("div018", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),1,rhu).toString()).equals("0.7")); 1255 TestFmwk.assertTrue("div019", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),2,rhu).toString()).equals("0.67")); 1256 TestFmwk.assertTrue("div020", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),3,rhu).toString()).equals("0.667")); 1257 TestFmwk.assertTrue("div021", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),4,rhu).toString()).equals("0.6667")); 1258 1259 TestFmwk.assertTrue("div030", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("2000"),4,rhu).toString()).equals("0.5000")); 1260 TestFmwk.assertTrue("div031", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("2000"),3,rhu).toString()).equals("0.500")); 1261 TestFmwk.assertTrue("div032", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("2000"),2,rhu).toString()).equals("0.50")); 1262 TestFmwk.assertTrue("div033", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("2000"),1,rhu).toString()).equals("0.5")); 1263 TestFmwk.assertTrue("div034", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("2000"),0,rhu).toString()).equals("1")); 1264 1265 TestFmwk.assertTrue("div035", ((new com.ibm.icu.math.BigDecimal("100")).divide(new com.ibm.icu.math.BigDecimal("5000"),4,rhu).toString()).equals("0.0200")); 1266 TestFmwk.assertTrue("div036", ((new com.ibm.icu.math.BigDecimal("100")).divide(new com.ibm.icu.math.BigDecimal("5000"),3,rhu).toString()).equals("0.020")); 1267 TestFmwk.assertTrue("div037", ((new com.ibm.icu.math.BigDecimal("100")).divide(new com.ibm.icu.math.BigDecimal("5000"),2,rhu).toString()).equals("0.02")); 1268 TestFmwk.assertTrue("div038", ((new com.ibm.icu.math.BigDecimal("100")).divide(new com.ibm.icu.math.BigDecimal("5000"),1,rhu).toString()).equals("0.0")); 1269 TestFmwk.assertTrue("div039", ((new com.ibm.icu.math.BigDecimal("100")).divide(new com.ibm.icu.math.BigDecimal("5000"),0,rhu).toString()).equals("0")); 1270 1271 TestFmwk.assertTrue("div040", ((new com.ibm.icu.math.BigDecimal("9.99999999")).divide(new com.ibm.icu.math.BigDecimal("9.77777777"),4,rhu).toString()).equals("1.0227")); 1272 TestFmwk.assertTrue("div041", ((new com.ibm.icu.math.BigDecimal("9.9999999")).divide(new com.ibm.icu.math.BigDecimal("9.7777777"),4,rhu).toString()).equals("1.0227")); 1273 TestFmwk.assertTrue("div042", ((new com.ibm.icu.math.BigDecimal("9.999999")).divide(new com.ibm.icu.math.BigDecimal("9.777777"),4,rhu).toString()).equals("1.0227")); 1274 TestFmwk.assertTrue("div043", ((new com.ibm.icu.math.BigDecimal("9.77777777")).divide(new com.ibm.icu.math.BigDecimal("9.99999999"),4,rhu).toString()).equals("0.9778")); 1275 TestFmwk.assertTrue("div044", ((new com.ibm.icu.math.BigDecimal("9.7777777")).divide(new com.ibm.icu.math.BigDecimal("9.9999999"),4,rhu).toString()).equals("0.9778")); 1276 TestFmwk.assertTrue("div045", ((new com.ibm.icu.math.BigDecimal("9.777777")).divide(new com.ibm.icu.math.BigDecimal("9.999999"),4,rhu).toString()).equals("0.9778")); 1277 TestFmwk.assertTrue("div046", ((new com.ibm.icu.math.BigDecimal("9.77777")).divide(new com.ibm.icu.math.BigDecimal("9.99999"),4,rhu).toString()).equals("0.9778")); 1278 TestFmwk.assertTrue("div047", ((new com.ibm.icu.math.BigDecimal("9.7777")).divide(new com.ibm.icu.math.BigDecimal("9.9999"),4,rhu).toString()).equals("0.9778")); 1279 TestFmwk.assertTrue("div048", ((new com.ibm.icu.math.BigDecimal("9.777")).divide(new com.ibm.icu.math.BigDecimal("9.999"),4,rhu).toString()).equals("0.9778")); 1280 TestFmwk.assertTrue("div049", ((new com.ibm.icu.math.BigDecimal("9.77")).divide(new com.ibm.icu.math.BigDecimal("9.99"),4,rhu).toString()).equals("0.9780")); 1281 TestFmwk.assertTrue("div050", ((new com.ibm.icu.math.BigDecimal("9.7")).divide(new com.ibm.icu.math.BigDecimal("9.9"),4,rhu).toString()).equals("0.9798")); 1282 TestFmwk.assertTrue("div051", ((new com.ibm.icu.math.BigDecimal("9.")).divide(new com.ibm.icu.math.BigDecimal("9."),4,rhu).toString()).equals("1.0000")); 1283 1284 TestFmwk.assertTrue("div060", ((new com.ibm.icu.math.BigDecimal("9.99999999")).divide(new com.ibm.icu.math.BigDecimal("9.77777777"),rhu).toString()).equals("1.02272727")); 1285 TestFmwk.assertTrue("div061", ((new com.ibm.icu.math.BigDecimal("9.9999999")).divide(new com.ibm.icu.math.BigDecimal("9.7777777"),rhu).toString()).equals("1.0227273")); 1286 TestFmwk.assertTrue("div062", ((new com.ibm.icu.math.BigDecimal("9.999999")).divide(new com.ibm.icu.math.BigDecimal("9.777777"),rhu).toString()).equals("1.022727")); 1287 TestFmwk.assertTrue("div063", ((new com.ibm.icu.math.BigDecimal("9.77777777")).divide(new com.ibm.icu.math.BigDecimal("9.99999999"),rhu).toString()).equals("0.97777778")); 1288 TestFmwk.assertTrue("div064", ((new com.ibm.icu.math.BigDecimal("9.7777777")).divide(new com.ibm.icu.math.BigDecimal("9.9999999"),rhu).toString()).equals("0.9777778")); 1289 TestFmwk.assertTrue("div065", ((new com.ibm.icu.math.BigDecimal("9.777777")).divide(new com.ibm.icu.math.BigDecimal("9.999999"),rhu).toString()).equals("0.977778")); 1290 TestFmwk.assertTrue("div066", ((new com.ibm.icu.math.BigDecimal("9.77777")).divide(new com.ibm.icu.math.BigDecimal("9.99999"),rhu).toString()).equals("0.97778")); 1291 TestFmwk.assertTrue("div067", ((new com.ibm.icu.math.BigDecimal("9.7777")).divide(new com.ibm.icu.math.BigDecimal("9.9999"),rhu).toString()).equals("0.9778")); 1292 TestFmwk.assertTrue("div068", ((new com.ibm.icu.math.BigDecimal("9.777")).divide(new com.ibm.icu.math.BigDecimal("9.999"),rhu).toString()).equals("0.978")); 1293 TestFmwk.assertTrue("div069", ((new com.ibm.icu.math.BigDecimal("9.77")).divide(new com.ibm.icu.math.BigDecimal("9.99"),rhu).toString()).equals("0.98")); 1294 TestFmwk.assertTrue("div070", ((new com.ibm.icu.math.BigDecimal("9.7")).divide(new com.ibm.icu.math.BigDecimal("9.9"),rhu).toString()).equals("1.0")); 1295 TestFmwk.assertTrue("div071", ((new com.ibm.icu.math.BigDecimal("9.")).divide(new com.ibm.icu.math.BigDecimal("9."),rhu).toString()).equals("1")); 1296 1297 rd=com.ibm.icu.math.MathContext.ROUND_DOWN; // test this is actually being used 1298 TestFmwk.assertTrue("div080", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),0,rd).toString()).equals("0")); 1299 TestFmwk.assertTrue("div081", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),1,rd).toString()).equals("0.6")); 1300 TestFmwk.assertTrue("div082", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),2,rd).toString()).equals("0.66")); 1301 TestFmwk.assertTrue("div083", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),3,rd).toString()).equals("0.666")); 1302 TestFmwk.assertTrue("div084", ((new com.ibm.icu.math.BigDecimal("2")).divide(new com.ibm.icu.math.BigDecimal("3"),4,rd).toString()).equals("0.6666")); 1303 1304 ru=com.ibm.icu.math.MathContext.ROUND_UNNECESSARY; // check for some 0 residues 1305 TestFmwk.assertTrue("div090", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("5"),4,ru).toString()).equals("200.0000")); 1306 TestFmwk.assertTrue("div091", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("50"),4,ru).toString()).equals("20.0000")); 1307 TestFmwk.assertTrue("div092", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("500"),4,ru).toString()).equals("2.0000")); 1308 TestFmwk.assertTrue("div093", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("5000"),4,ru).toString()).equals("0.2000")); 1309 TestFmwk.assertTrue("div094", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("5000"),3,ru).toString()).equals("0.200")); 1310 TestFmwk.assertTrue("div095", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("5000"),2,ru).toString()).equals("0.20")); 1311 TestFmwk.assertTrue("div096", ((new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("5000"),1,ru).toString()).equals("0.2")); 1312 1313 // check rounding explicitly 1314 TestFmwk.assertTrue("div101", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_CEILING).toString()).equals("0.06")); 1315 TestFmwk.assertTrue("div102", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_CEILING).toString()).equals("0.1")); 1316 TestFmwk.assertTrue("div103", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_CEILING).toString()).equals("1")); 1317 TestFmwk.assertTrue("div104", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_DOWN).toString()).equals("0.05")); 1318 TestFmwk.assertTrue("div105", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_DOWN).toString()).equals("0.0")); 1319 TestFmwk.assertTrue("div106", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_DOWN).toString()).equals("0")); 1320 TestFmwk.assertTrue("div107", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0.05")); 1321 TestFmwk.assertTrue("div108", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0.0")); 1322 TestFmwk.assertTrue("div109", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0")); 1323 1324 TestFmwk.assertTrue("div110", ((new com.ibm.icu.math.BigDecimal("0.045")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.04")); 1325 TestFmwk.assertTrue("div111", ((new com.ibm.icu.math.BigDecimal("0.045")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.0")); 1326 TestFmwk.assertTrue("div112", ((new com.ibm.icu.math.BigDecimal("0.045")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0")); 1327 TestFmwk.assertTrue("div113", ((new com.ibm.icu.math.BigDecimal("0.050")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.05")); 1328 TestFmwk.assertTrue("div114", ((new com.ibm.icu.math.BigDecimal("0.050")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.0")); 1329 TestFmwk.assertTrue("div115", ((new com.ibm.icu.math.BigDecimal("0.050")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0")); 1330 TestFmwk.assertTrue("div116", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.05")); 1331 TestFmwk.assertTrue("div117", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.1")); 1332 TestFmwk.assertTrue("div118", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0")); 1333 1334 TestFmwk.assertTrue("div120", ((new com.ibm.icu.math.BigDecimal("0.045")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.04")); 1335 TestFmwk.assertTrue("div121", ((new com.ibm.icu.math.BigDecimal("0.045")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.0")); 1336 TestFmwk.assertTrue("div122", ((new com.ibm.icu.math.BigDecimal("0.045")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 1337 TestFmwk.assertTrue("div123", ((new com.ibm.icu.math.BigDecimal("0.050")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.05")); 1338 TestFmwk.assertTrue("div124", ((new com.ibm.icu.math.BigDecimal("0.050")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.0")); 1339 TestFmwk.assertTrue("div125", ((new com.ibm.icu.math.BigDecimal("0.050")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 1340 TestFmwk.assertTrue("div126", ((new com.ibm.icu.math.BigDecimal("0.150")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.15")); 1341 TestFmwk.assertTrue("div127", ((new com.ibm.icu.math.BigDecimal("0.150")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.2")); 1342 TestFmwk.assertTrue("div128", ((new com.ibm.icu.math.BigDecimal("0.150")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 1343 TestFmwk.assertTrue("div129", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.06")); 1344 TestFmwk.assertTrue("div130", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.1")); 1345 TestFmwk.assertTrue("div131", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 1346 1347 TestFmwk.assertTrue("div140", ((new com.ibm.icu.math.BigDecimal("0.045")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.05")); 1348 TestFmwk.assertTrue("div141", ((new com.ibm.icu.math.BigDecimal("0.045")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.0")); 1349 TestFmwk.assertTrue("div142", ((new com.ibm.icu.math.BigDecimal("0.045")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 1350 TestFmwk.assertTrue("div143", ((new com.ibm.icu.math.BigDecimal("0.050")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.05")); 1351 TestFmwk.assertTrue("div144", ((new com.ibm.icu.math.BigDecimal("0.050")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.1")); 1352 TestFmwk.assertTrue("div145", ((new com.ibm.icu.math.BigDecimal("0.050")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 1353 TestFmwk.assertTrue("div146", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.06")); 1354 TestFmwk.assertTrue("div147", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.1")); 1355 TestFmwk.assertTrue("div148", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 1356 1357 TestFmwk.assertTrue("div150", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,2,com.ibm.icu.math.MathContext.ROUND_UP).toString()).equals("0.06")); 1358 TestFmwk.assertTrue("div151", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,1,com.ibm.icu.math.MathContext.ROUND_UP).toString()).equals("0.1")); 1359 TestFmwk.assertTrue("div52.", ((new com.ibm.icu.math.BigDecimal("0.055")).divide(one,0,com.ibm.icu.math.MathContext.ROUND_UP).toString()).equals("1")); 1360 1361 // - error conditions --- 1362 try { 1363 ten.divide((com.ibm.icu.math.BigDecimal) null); 1364 flag = false; 1365 } catch (java.lang.NullPointerException $32) { 1366 flag = true; 1367 }/* checknull */ 1368 TestFmwk.assertTrue("div201", flag); 1369 try { 1370 ten.divide(ten, (com.ibm.icu.math.MathContext) null); 1371 flag = false; 1372 } catch (java.lang.NullPointerException $33) { 1373 flag = true; 1374 }/* checknull2 */ 1375 TestFmwk.assertTrue("div202", flag); 1376 1377 try { 1378 (new com.ibm.icu.math.BigDecimal("1")).divide(new com.ibm.icu.math.BigDecimal("3"), -8, 0); 1379 flag = false; 1380 } catch (java.lang.RuntimeException $34) { 1381 e = $34; 1382 flag = flag & (e.getMessage()).equals("Negative scale: -8"); 1383 }/* checkscale */ 1384 TestFmwk.assertTrue("div203", flag); 1385 1386 try { 1387 (new com.ibm.icu.math.BigDecimal("1000")).divide(new com.ibm.icu.math.BigDecimal("5000"), 0, com.ibm.icu.math.MathContext.ROUND_UNNECESSARY); 1388 flag = false; 1389 } catch (java.lang.ArithmeticException $35) { 1390 ae = $35; 1391 flag = (ae.getMessage()).equals("Rounding necessary"); 1392 }/* rounn */ 1393 TestFmwk.assertTrue("div204", flag); 1394 try { 1395 (new com.ibm.icu.math.BigDecimal("1001")).divide(new com.ibm.icu.math.BigDecimal("10"), 0, com.ibm.icu.math.MathContext.ROUND_UNNECESSARY); 1396 flag = false; 1397 } catch (java.lang.ArithmeticException $36) { 1398 ae = $36; 1399 flag = (ae.getMessage()).equals("Rounding necessary"); 1400 }/* rounn */ 1401 TestFmwk.assertTrue("div205", flag); 1402 try { 1403 (new com.ibm.icu.math.BigDecimal("1001")).divide(new com.ibm.icu.math.BigDecimal("100"), 1, com.ibm.icu.math.MathContext.ROUND_UNNECESSARY); 1404 flag = false; 1405 } catch (java.lang.ArithmeticException $37) { 1406 ae = $37; 1407 flag = (ae.getMessage()).equals("Rounding necessary"); 1408 }/* rounn */ 1409 TestFmwk.assertTrue("div206", flag); 1410 try { 1411 (new com.ibm.icu.math.BigDecimal("10001")).divide( 1412 new com.ibm.icu.math.BigDecimal("10000"), 1, 1413 com.ibm.icu.math.MathContext.ROUND_UNNECESSARY); 1414 flag = false; 1415 } catch (java.lang.ArithmeticException $38) { 1416 ae = $38; 1417 flag = (ae.getMessage()).equals("Rounding necessary"); 1418 }/* rounn */ 1419 TestFmwk.assertTrue("div207", flag); 1420 try { 1421 (new com.ibm.icu.math.BigDecimal("1.0001")).divide( 1422 new com.ibm.icu.math.BigDecimal("1"), 1, 1423 com.ibm.icu.math.MathContext.ROUND_UNNECESSARY); 1424 flag = false; 1425 } catch (java.lang.ArithmeticException $39) { 1426 ae = $39; 1427 flag = (ae.getMessage()).equals("Rounding necessary"); 1428 }/* rounn */ 1429 TestFmwk.assertTrue("div208", flag); 1430 1431 try { 1432 (new com.ibm.icu.math.BigDecimal("5")) 1433 .divide(new com.ibm.icu.math.BigDecimal("0.00")); 1434 flag = false; 1435 } catch (java.lang.ArithmeticException $40) { 1436 ae = $40; 1437 flag = (ae.getMessage()).equals("Divide by 0"); 1438 }/* div0 */ 1439 TestFmwk.assertTrue("div209", flag); 1440 1441 try { 1442 tenlong.divide(com.ibm.icu.math.BigDecimal.ONE, mcld); 1443 flag = false; 1444 } catch (java.lang.ArithmeticException $41) { 1445 ae = $41; 1446 flag = (ae.getMessage()).equals("Too many digits:" + " " 1447 + tenlong.toString()); 1448 }/* checkdigits */ 1449 TestFmwk.assertTrue("div210", flag); 1450 try { 1451 com.ibm.icu.math.BigDecimal.ONE.divide(tenlong, mcld); 1452 flag = false; 1453 } catch (java.lang.ArithmeticException $42) { 1454 ae = $42; 1455 flag = (ae.getMessage()).equals("Too many digits:" + " " 1456 + tenlong.toString()); 1457 }/* checkdigits */ 1458 TestFmwk.assertTrue("div211", flag); 1459 1460 } 1461 1462 /* ----------------------------------------------------------------- */ 1463 1464 /** Test the {@link com.ibm.icu.math.BigDecimal#divideInteger} method. */ 1465 1466 @Test 1467 public void diagdivideInteger() { 1468 boolean flag = false; 1469 java.lang.ArithmeticException ae = null; 1470 1471 TestFmwk.assertTrue("dvI001", ((new com.ibm.icu.math.BigDecimal("101.3")).divideInteger(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("101")); 1472 TestFmwk.assertTrue("dvI002", ((new com.ibm.icu.math.BigDecimal("101.0")).divideInteger(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("101")); 1473 TestFmwk.assertTrue("dvI003", ((new com.ibm.icu.math.BigDecimal("101.3")).divideInteger(new com.ibm.icu.math.BigDecimal("3"),mcdef).toString()).equals("33")); 1474 TestFmwk.assertTrue("dvI004", ((new com.ibm.icu.math.BigDecimal("101.0")).divideInteger(new com.ibm.icu.math.BigDecimal("3"),mcdef).toString()).equals("33")); 1475 TestFmwk.assertTrue("dvI005", ((new com.ibm.icu.math.BigDecimal("2.4")).divideInteger(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("2")); 1476 TestFmwk.assertTrue("dvI006", ((new com.ibm.icu.math.BigDecimal("2.400")).divideInteger(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("2")); 1477 TestFmwk.assertTrue("dvI007", ((new com.ibm.icu.math.BigDecimal("18")).divideInteger(new com.ibm.icu.math.BigDecimal("18"),mcdef).toString()).equals("1")); 1478 TestFmwk.assertTrue("dvI008", ((new com.ibm.icu.math.BigDecimal("1120")).divideInteger(new com.ibm.icu.math.BigDecimal("1000"),mcdef).toString()).equals("1")); 1479 TestFmwk.assertTrue("dvI009", ((new com.ibm.icu.math.BigDecimal("2.4")).divideInteger(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("1")); 1480 TestFmwk.assertTrue("dvI010", ((new com.ibm.icu.math.BigDecimal("2.400")).divideInteger(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("1")); 1481 TestFmwk.assertTrue("dvI011", ((new com.ibm.icu.math.BigDecimal("0.5")).divideInteger(new com.ibm.icu.math.BigDecimal("2.000"),mcdef).toString()).equals("0")); 1482 TestFmwk.assertTrue("dvI012", ((new com.ibm.icu.math.BigDecimal("8.005")).divideInteger(new com.ibm.icu.math.BigDecimal("7"),mcdef).toString()).equals("1")); 1483 TestFmwk.assertTrue("dvI013", ((new com.ibm.icu.math.BigDecimal("5")).divideInteger(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("2")); 1484 TestFmwk.assertTrue("dvI014", ((new com.ibm.icu.math.BigDecimal("0")).divideInteger(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("0")); 1485 TestFmwk.assertTrue("dvI015", ((new com.ibm.icu.math.BigDecimal("0.00")).divideInteger(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("0")); 1486 // MC 1487 TestFmwk.assertTrue("dvI016", ((new com.ibm.icu.math.BigDecimal("5")).divideInteger(new com.ibm.icu.math.BigDecimal("2"), mce).toString()).equals("2")); 1488 TestFmwk.assertTrue("dvI017", ((new com.ibm.icu.math.BigDecimal("5")).divideInteger(new com.ibm.icu.math.BigDecimal("2"), mc6).toString()).equals("2")); 1489 1490 // Fixed -- 1491 TestFmwk.assertTrue("dvI021", ((new com.ibm.icu.math.BigDecimal("101.3")).divideInteger(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("101")); 1492 TestFmwk.assertTrue("dvI022", ((new com.ibm.icu.math.BigDecimal("101.0")).divideInteger(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("101")); 1493 TestFmwk.assertTrue("dvI023", ((new com.ibm.icu.math.BigDecimal("101.3")).divideInteger(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("33")); 1494 TestFmwk.assertTrue("dvI024", ((new com.ibm.icu.math.BigDecimal("101.0")).divideInteger(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("33")); 1495 TestFmwk.assertTrue("dvI025", ((new com.ibm.icu.math.BigDecimal("2.4")).divideInteger(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("2")); 1496 TestFmwk.assertTrue("dvI026", ((new com.ibm.icu.math.BigDecimal("2.400")).divideInteger(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("2")); 1497 TestFmwk.assertTrue("dvI027", ((new com.ibm.icu.math.BigDecimal("18")).divideInteger(new com.ibm.icu.math.BigDecimal("18")).toString()).equals("1")); 1498 TestFmwk.assertTrue("dvI028", ((new com.ibm.icu.math.BigDecimal("1120")).divideInteger(new com.ibm.icu.math.BigDecimal("1000")).toString()).equals("1")); 1499 TestFmwk.assertTrue("dvI029", ((new com.ibm.icu.math.BigDecimal("2.4")).divideInteger(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("1")); 1500 TestFmwk.assertTrue("dvI030", ((new com.ibm.icu.math.BigDecimal("2.400")).divideInteger(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("1")); 1501 TestFmwk.assertTrue("dvI031", ((new com.ibm.icu.math.BigDecimal("0.5")).divideInteger(new com.ibm.icu.math.BigDecimal("2.000")).toString()).equals("0")); 1502 TestFmwk.assertTrue("dvI032", ((new com.ibm.icu.math.BigDecimal("8.005")).divideInteger(new com.ibm.icu.math.BigDecimal("7")).toString()).equals("1")); 1503 TestFmwk.assertTrue("dvI033", ((new com.ibm.icu.math.BigDecimal("5")).divideInteger(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("2")); 1504 TestFmwk.assertTrue("dvI034", ((new com.ibm.icu.math.BigDecimal("0")).divideInteger(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("0")); 1505 TestFmwk.assertTrue("dvI035", ((new com.ibm.icu.math.BigDecimal("0.00")).divideInteger(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("0")); 1506 1507 try { 1508 ten.divideInteger((com.ibm.icu.math.BigDecimal) null); 1509 flag = false; 1510 } catch (java.lang.NullPointerException $43) { 1511 flag = true; 1512 }/* checknull */ 1513 TestFmwk.assertTrue("dvI101", flag); 1514 try { 1515 ten.divideInteger(ten, (com.ibm.icu.math.MathContext) null); 1516 flag = false; 1517 } catch (java.lang.NullPointerException $44) { 1518 flag = true; 1519 }/* checknull2 */ 1520 TestFmwk.assertTrue("dvI102", flag); 1521 1522 try { 1523 com.ibm.icu.math.BigDecimal.ONE.divideInteger(tenlong, mcld); 1524 flag = false; 1525 } catch (java.lang.ArithmeticException $45) { 1526 ae = $45; 1527 flag = (ae.getMessage()).equals("Too many digits:" + " " 1528 + tenlong.toString()); 1529 }/* checkdigits */ 1530 TestFmwk.assertTrue("dvI103", flag); 1531 1532 try { 1533 tenlong.divideInteger(com.ibm.icu.math.BigDecimal.ONE, mcld); 1534 flag = false; 1535 } catch (java.lang.ArithmeticException $46) { 1536 ae = $46; 1537 flag = (ae.getMessage()).equals("Too many digits:" + " " 1538 + tenlong.toString()); 1539 }/* checkdigits */ 1540 TestFmwk.assertTrue("dvI104", flag); 1541 1542 } 1543 1544 /* ----------------------------------------------------------------- */ 1545 1546 /** Test the {@link com.ibm.icu.math.BigDecimal#max} method. */ 1547 1548 @Test 1549 public void diagmax() { 1550 boolean flag = false; 1551 java.lang.ArithmeticException ae = null; 1552 1553 // we assume add/subtract test function; this and min just 1554 // test existence and test the truth table 1555 TestFmwk.assertTrue("max001", ((new com.ibm.icu.math.BigDecimal("5")).max(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("5")); 1556 TestFmwk.assertTrue("max002", ((new com.ibm.icu.math.BigDecimal("5")).max(new com.ibm.icu.math.BigDecimal("5")).toString()).equals("5")); 1557 TestFmwk.assertTrue("max003", ((new com.ibm.icu.math.BigDecimal("2")).max(new com.ibm.icu.math.BigDecimal("7")).toString()).equals("7")); 1558 TestFmwk.assertTrue("max004", ((new com.ibm.icu.math.BigDecimal("2")).max(new com.ibm.icu.math.BigDecimal("7"),mcdef).toString()).equals("7")); 1559 TestFmwk.assertTrue("max005", ((new com.ibm.icu.math.BigDecimal("2")).max(new com.ibm.icu.math.BigDecimal("7"),mc6).toString()).equals("7")); 1560 TestFmwk.assertTrue("max006", ((new com.ibm.icu.math.BigDecimal("2E+3")).max(new com.ibm.icu.math.BigDecimal("7")).toString()).equals("2000")); 1561 TestFmwk.assertTrue("max007", ((new com.ibm.icu.math.BigDecimal("2E+3")).max(new com.ibm.icu.math.BigDecimal("7"),mc3).toString()).equals("2E+3")); 1562 TestFmwk.assertTrue("max008", ((new com.ibm.icu.math.BigDecimal("7")).max(new com.ibm.icu.math.BigDecimal("2E+3")).toString()).equals("2000")); 1563 TestFmwk.assertTrue("max009", ((new com.ibm.icu.math.BigDecimal("7")).max(new com.ibm.icu.math.BigDecimal("2E+3"),mc3).toString()).equals("2E+3")); 1564 try { 1565 ten.max((com.ibm.icu.math.BigDecimal) null); 1566 flag = false; 1567 } catch (java.lang.NullPointerException $47) { 1568 flag = true; 1569 }/* checknull */ 1570 TestFmwk.assertTrue("max010", flag); 1571 try { 1572 ten.max(ten, (com.ibm.icu.math.MathContext) null); 1573 flag = false; 1574 } catch (java.lang.NullPointerException $48) { 1575 flag = true; 1576 }/* checknull2 */ 1577 TestFmwk.assertTrue("max011", flag); 1578 try { 1579 tenlong.max(com.ibm.icu.math.BigDecimal.ONE, mcld); 1580 flag = false; 1581 } catch (java.lang.ArithmeticException $49) { 1582 ae = $49; 1583 flag = (ae.getMessage()).equals("Too many digits:" + " " 1584 + tenlong.toString()); 1585 }/* checkdigits */ 1586 TestFmwk.assertTrue("max012", flag); 1587 try { 1588 com.ibm.icu.math.BigDecimal.ONE.max(tenlong, mcld); 1589 flag = false; 1590 } catch (java.lang.ArithmeticException $50) { 1591 ae = $50; 1592 flag = (ae.getMessage()).equals("Too many digits:" + " " 1593 + tenlong.toString()); 1594 }/* checkdigits */ 1595 TestFmwk.assertTrue("max013", flag); 1596 } 1597 1598 /** Test the {@link com.ibm.icu.math.BigDecimal#min} method. */ 1599 1600 @Test 1601 public void diagmin() { 1602 boolean flag = false; 1603 com.ibm.icu.math.BigDecimal minx = null; 1604 java.lang.ArithmeticException ae = null; 1605 // we assume add/subtract test function; this and max just 1606 // test existence and test the truth table 1607 1608 TestFmwk.assertTrue("min001", ((new com.ibm.icu.math.BigDecimal("5")).min(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("2")); 1609 TestFmwk.assertTrue("min002", ((new com.ibm.icu.math.BigDecimal("5")).min(new com.ibm.icu.math.BigDecimal("5")).toString()).equals("5")); 1610 TestFmwk.assertTrue("min003", ((new com.ibm.icu.math.BigDecimal("2")).min(new com.ibm.icu.math.BigDecimal("7")).toString()).equals("2")); 1611 TestFmwk.assertTrue("min004", ((new com.ibm.icu.math.BigDecimal("2")).min(new com.ibm.icu.math.BigDecimal("7"),mcdef).toString()).equals("2")); 1612 TestFmwk.assertTrue("min005", ((new com.ibm.icu.math.BigDecimal("1")).min(new com.ibm.icu.math.BigDecimal("7"),mc6).toString()).equals("1")); 1613 TestFmwk.assertTrue("min006", ((new com.ibm.icu.math.BigDecimal("-2E+3")).min(new com.ibm.icu.math.BigDecimal("7")).toString()).equals("-2000")); 1614 TestFmwk.assertTrue("min007", ((new com.ibm.icu.math.BigDecimal("-2E+3")).min(new com.ibm.icu.math.BigDecimal("7"),mc3).toString()).equals("-2E+3")); 1615 TestFmwk.assertTrue("min008", ((new com.ibm.icu.math.BigDecimal("7")).min(new com.ibm.icu.math.BigDecimal("-2E+3")).toString()).equals("-2000")); 1616 TestFmwk.assertTrue("min009", ((new com.ibm.icu.math.BigDecimal("7")).min(new com.ibm.icu.math.BigDecimal("-2E+3"),mc3).toString()).equals("-2E+3")); 1617 try { 1618 minx = ten; 1619 minx.min((com.ibm.icu.math.BigDecimal) null); 1620 flag = false; 1621 } catch (java.lang.NullPointerException $51) { 1622 flag = true; 1623 }/* checknull */ 1624 TestFmwk.assertTrue("min010", flag); 1625 try { 1626 minx = ten; 1627 minx.min(ten, (com.ibm.icu.math.MathContext) null); 1628 flag = false; 1629 } catch (java.lang.NullPointerException $52) { 1630 flag = true; 1631 }/* checknull2 */ 1632 TestFmwk.assertTrue("min011", flag); 1633 1634 try { 1635 tenlong.min(com.ibm.icu.math.BigDecimal.ONE, mcld); 1636 flag = false; 1637 } catch (java.lang.ArithmeticException $53) { 1638 ae = $53; 1639 flag = (ae.getMessage()).equals("Too many digits:" + " " 1640 + tenlong.toString()); 1641 }/* checkdigits */ 1642 TestFmwk.assertTrue("min012", flag); 1643 try { 1644 (new com.ibm.icu.math.BigDecimal(9)).min(tenlong, mcld); 1645 flag = false; 1646 } catch (java.lang.ArithmeticException $54) { 1647 ae = $54; 1648 flag = (ae.getMessage()).equals("Too many digits:" + " " 1649 + tenlong.toString()); 1650 }/* checkdigits */ 1651 TestFmwk.assertTrue("min013", flag); 1652 } 1653 1654 /* ----------------------------------------------------------------- */ 1655 1656 /** Test the {@link com.ibm.icu.math.BigDecimal#multiply} method. */ 1657 1658 @Test 1659 public void diagmultiply() { 1660 boolean flag = false; 1661 com.ibm.icu.math.BigDecimal l9; 1662 com.ibm.icu.math.BigDecimal l77e; 1663 com.ibm.icu.math.BigDecimal l12345; 1664 com.ibm.icu.math.BigDecimal edge; 1665 com.ibm.icu.math.BigDecimal tenedge; 1666 com.ibm.icu.math.BigDecimal hunedge; 1667 com.ibm.icu.math.BigDecimal opo; 1668 com.ibm.icu.math.BigDecimal d1 = null; 1669 com.ibm.icu.math.BigDecimal d2 = null; 1670 java.lang.ArithmeticException oe = null; 1671 java.lang.ArithmeticException ae = null; 1672 1673 TestFmwk.assertTrue("mul001", ((new com.ibm.icu.math.BigDecimal("2")).multiply(new com.ibm.icu.math.BigDecimal("3"),mcdef).toString()).equals("6")); 1674 TestFmwk.assertTrue("mul002", ((new com.ibm.icu.math.BigDecimal("5")).multiply(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("5")); 1675 TestFmwk.assertTrue("mul003", ((new com.ibm.icu.math.BigDecimal("5")).multiply(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("10")); 1676 TestFmwk.assertTrue("mul004", ((new com.ibm.icu.math.BigDecimal("1.20")).multiply(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("2.40")); 1677 TestFmwk.assertTrue("mul005", ((new com.ibm.icu.math.BigDecimal("1.20")).multiply(new com.ibm.icu.math.BigDecimal("0"),mcdef).toString()).equals("0")); 1678 TestFmwk.assertTrue("mul006", ((new com.ibm.icu.math.BigDecimal("1.20")).multiply(new com.ibm.icu.math.BigDecimal("-2"),mcdef).toString()).equals("-2.40")); 1679 TestFmwk.assertTrue("mul007", ((new com.ibm.icu.math.BigDecimal("-1.20")).multiply(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("-2.40")); 1680 TestFmwk.assertTrue("mul008", ((new com.ibm.icu.math.BigDecimal("-1.20")).multiply(new com.ibm.icu.math.BigDecimal("0"),mcdef).toString()).equals("0")); 1681 TestFmwk.assertTrue("mul009", ((new com.ibm.icu.math.BigDecimal("-1.20")).multiply(new com.ibm.icu.math.BigDecimal("-2"),mcdef).toString()).equals("2.40")); 1682 TestFmwk.assertTrue("mul010", ((new com.ibm.icu.math.BigDecimal("5.09")).multiply(new com.ibm.icu.math.BigDecimal("7.1"),mcdef).toString()).equals("36.139")); 1683 TestFmwk.assertTrue("mul011", ((new com.ibm.icu.math.BigDecimal("2.5")).multiply(new com.ibm.icu.math.BigDecimal("4"),mcdef).toString()).equals("10.0")); 1684 TestFmwk.assertTrue("mul012", ((new com.ibm.icu.math.BigDecimal("2.50")).multiply(new com.ibm.icu.math.BigDecimal("4"),mcdef).toString()).equals("10.00")); 1685 TestFmwk.assertTrue("mul013", ((new com.ibm.icu.math.BigDecimal("1.23456789")).multiply(new com.ibm.icu.math.BigDecimal("1.00000000"),mcdef).toString()).equals("1.23456789")); 1686 1687 TestFmwk.assertTrue("mul014", ((new com.ibm.icu.math.BigDecimal("9.999999999")).multiply(new com.ibm.icu.math.BigDecimal("9.999999999"),mcdef).toString()).equals("100.000000")); 1688 1689 TestFmwk.assertTrue("mul015", ((new com.ibm.icu.math.BigDecimal("2.50")).multiply(new com.ibm.icu.math.BigDecimal("4"),mcdef).toString()).equals("10.00")); 1690 TestFmwk.assertTrue("mul016", ((new com.ibm.icu.math.BigDecimal("2.50")).multiply(new com.ibm.icu.math.BigDecimal("4"),mc6).toString()).equals("10.00")); 1691 TestFmwk.assertTrue("mul017", ((new com.ibm.icu.math.BigDecimal("9.999999999")).multiply(new com.ibm.icu.math.BigDecimal("9.999999999"),mc6).toString()).equals("100.000")); 1692 1693 1694 TestFmwk.assertTrue("mul020", ((new com.ibm.icu.math.BigDecimal("2")).multiply(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("6")); 1695 TestFmwk.assertTrue("mul021", ((new com.ibm.icu.math.BigDecimal("5")).multiply(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("5")); 1696 TestFmwk.assertTrue("mul022", ((new com.ibm.icu.math.BigDecimal("5")).multiply(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("10")); 1697 TestFmwk.assertTrue("mul023", ((new com.ibm.icu.math.BigDecimal("1.20")).multiply(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("2.40")); 1698 TestFmwk.assertTrue("mul024", ((new com.ibm.icu.math.BigDecimal("1.20")).multiply(new com.ibm.icu.math.BigDecimal("0")).toString()).equals("0.00")); 1699 TestFmwk.assertTrue("mul025", ((new com.ibm.icu.math.BigDecimal("1.20")).multiply(new com.ibm.icu.math.BigDecimal("-2")).toString()).equals("-2.40")); 1700 TestFmwk.assertTrue("mul026", ((new com.ibm.icu.math.BigDecimal("-1.20")).multiply(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("-2.40")); 1701 TestFmwk.assertTrue("mul027", ((new com.ibm.icu.math.BigDecimal("-1.20")).multiply(new com.ibm.icu.math.BigDecimal("0")).toString()).equals("0.00")); 1702 TestFmwk.assertTrue("mul028", ((new com.ibm.icu.math.BigDecimal("-1.20")).multiply(new com.ibm.icu.math.BigDecimal("-2")).toString()).equals("2.40")); 1703 TestFmwk.assertTrue("mul029", ((new com.ibm.icu.math.BigDecimal("5.09")).multiply(new com.ibm.icu.math.BigDecimal("7.1")).toString()).equals("36.139")); 1704 TestFmwk.assertTrue("mul030", ((new com.ibm.icu.math.BigDecimal("2.5")).multiply(new com.ibm.icu.math.BigDecimal("4")).toString()).equals("10.0")); 1705 TestFmwk.assertTrue("mul031", ((new com.ibm.icu.math.BigDecimal("2.50")).multiply(new com.ibm.icu.math.BigDecimal("4")).toString()).equals("10.00")); 1706 TestFmwk.assertTrue("mul032", ((new com.ibm.icu.math.BigDecimal("1.23456789")).multiply(new com.ibm.icu.math.BigDecimal("1.00000000")).toString()).equals("1.2345678900000000")); 1707 1708 TestFmwk.assertTrue("mul033", ((new com.ibm.icu.math.BigDecimal("1234.56789")).multiply(new com.ibm.icu.math.BigDecimal("-1000.00000")).toString()).equals("-1234567.8900000000")); 1709 1710 TestFmwk.assertTrue("mul034", ((new com.ibm.icu.math.BigDecimal("-1234.56789")).multiply(new com.ibm.icu.math.BigDecimal("1000.00000")).toString()).equals("-1234567.8900000000")); 1711 1712 TestFmwk.assertTrue("mul035", ((new com.ibm.icu.math.BigDecimal("9.999999999")).multiply(new com.ibm.icu.math.BigDecimal("9.999999999")).toString()).equals("99.999999980000000001")); 1713 1714 TestFmwk.assertTrue("mul036", ((new com.ibm.icu.math.BigDecimal("5.00")).multiply(new com.ibm.icu.math.BigDecimal("1E-3")).toString()).equals("0.00500")); 1715 TestFmwk.assertTrue("mul037", ((new com.ibm.icu.math.BigDecimal("00.00")).multiply(new com.ibm.icu.math.BigDecimal("0.000")).toString()).equals("0.00000")); 1716 TestFmwk.assertTrue("mul038", ((new com.ibm.icu.math.BigDecimal("00.00")).multiply(new com.ibm.icu.math.BigDecimal("0E-3")).toString()).equals("0.00")); // rhs is '0' 1717 // 1999.12.21: next one is a edge case if intermediate longs are used 1718 TestFmwk.assertTrue("mul039", ((new com.ibm.icu.math.BigDecimal("999999999999")).multiply(new com.ibm.icu.math.BigDecimal("9765625")).toString()).equals("9765624999990234375")); 1719 1720 l9 = new com.ibm.icu.math.BigDecimal("123456789E+10"); 1721 l77e = new com.ibm.icu.math.BigDecimal("77E-20"); 1722 TestFmwk.assertTrue("mul040", (l9.multiply(new com.ibm.icu.math.BigDecimal("3456757")).toString()).equals("4267601195732730000000000")); 1723 TestFmwk.assertTrue("mul041", (l9.multiply(new com.ibm.icu.math.BigDecimal("3456757"), mc3).toString()).equals("4.26E+24")); 1724 TestFmwk.assertTrue("mul042", (l9.multiply(l77e).toString()).equals("0.95061727530000000000")); 1725 TestFmwk.assertTrue("mul043", (l9.multiply(l77e, mc3).toString()).equals("0.947")); 1726 TestFmwk.assertTrue("mul044", (l77e.multiply(l9, mc3).toString()).equals("0.947")); 1727 1728 l12345 = new com.ibm.icu.math.BigDecimal("123.45"); 1729 TestFmwk.assertTrue("mul050", (l12345.multiply(new com.ibm.icu.math.BigDecimal("1e11"),mcdef).toString()).equals("1.2345E+13")); 1730 TestFmwk.assertTrue("mul051", (l12345.multiply(new com.ibm.icu.math.BigDecimal("1e11"),mcs).toString()).equals("1.2345E+13")); 1731 TestFmwk.assertTrue("mul052", (l12345.multiply(new com.ibm.icu.math.BigDecimal("1e+9"),mce).toString()).equals("123.45E+9")); 1732 TestFmwk.assertTrue("mul053", (l12345.multiply(new com.ibm.icu.math.BigDecimal("1e10"),mce).toString()).equals("1.2345E+12")); 1733 TestFmwk.assertTrue("mul054", (l12345.multiply(new com.ibm.icu.math.BigDecimal("1e11"),mce).toString()).equals("12.345E+12")); 1734 TestFmwk.assertTrue("mul055", (l12345.multiply(new com.ibm.icu.math.BigDecimal("1e12"),mce).toString()).equals("123.45E+12")); 1735 TestFmwk.assertTrue("mul056", (l12345.multiply(new com.ibm.icu.math.BigDecimal("1e13"),mce).toString()).equals("1.2345E+15")); 1736 1737 // test some cases that are close to exponent overflow 1738 TestFmwk.assertTrue("mul060", (one.multiply(new com.ibm.icu.math.BigDecimal("9e999999999"),mcs).toString()).equals("9E+999999999")); 1739 TestFmwk.assertTrue("mul061", (one.multiply(new com.ibm.icu.math.BigDecimal("9.9e999999999"),mcs).toString()).equals("9.9E+999999999")); 1740 TestFmwk.assertTrue("mul062", (one.multiply(new com.ibm.icu.math.BigDecimal("9.99e999999999"),mcs).toString()).equals("9.99E+999999999")); 1741 TestFmwk.assertTrue("mul063", (ten.multiply(new com.ibm.icu.math.BigDecimal("9e999999999"),mce).toString()).equals("90E+999999999")); 1742 TestFmwk.assertTrue("mul064", (ten.multiply(new com.ibm.icu.math.BigDecimal("9.9e999999999"),mce).toString()).equals("99.0E+999999999")); 1743 edge = new com.ibm.icu.math.BigDecimal("9.999e999999999"); 1744 tenedge = ten.multiply(edge, mce); 1745 TestFmwk.assertTrue("mul065", (tenedge.toString()).equals("99.990E+999999999")); 1746 hunedge = ten.multiply(tenedge, mce); 1747 TestFmwk.assertTrue("mul066", (hunedge.toString()).equals("999.900E+999999999")); 1748 opo = new com.ibm.icu.math.BigDecimal("0.1"); // one tenth 1749 TestFmwk.assertTrue("mul067", (opo.multiply(new com.ibm.icu.math.BigDecimal("9e-999999998"),mcs).toString()).equals("9E-999999999")); 1750 TestFmwk.assertTrue("mul068", (opo.multiply(new com.ibm.icu.math.BigDecimal("99e-999999998"),mcs).toString()).equals("9.9E-999999998")); 1751 TestFmwk.assertTrue("mul069", (opo.multiply(new com.ibm.icu.math.BigDecimal("999e-999999998"),mcs).toString()).equals("9.99E-999999997")); 1752 1753 TestFmwk.assertTrue("mul070", (opo.multiply(new com.ibm.icu.math.BigDecimal("9e-999999998"),mce).toString()).equals("9E-999999999")); 1754 TestFmwk.assertTrue("mul071", (opo.multiply(new com.ibm.icu.math.BigDecimal("99e-999999998"),mce).toString()).equals("99E-999999999")); 1755 TestFmwk.assertTrue("mul072", (opo.multiply(new com.ibm.icu.math.BigDecimal("999e-999999998"),mce).toString()).equals("999E-999999999")); 1756 TestFmwk.assertTrue("mul073", (opo.multiply(new com.ibm.icu.math.BigDecimal("999e-999999997"),mce).toString()).equals("9.99E-999999996")); 1757 TestFmwk.assertTrue("mul074", (opo.multiply(new com.ibm.icu.math.BigDecimal("9999e-999999997"),mce).toString()).equals("99.99E-999999996")); 1758 TestFmwk.assertTrue("mul074", (opo.multiply(new com.ibm.icu.math.BigDecimal("99999e-999999997"),mce).toString()).equals("999.99E-999999996")); 1759 1760 // test some intermediate lengths 1761 TestFmwk.assertTrue("mul080", (opo.multiply(new com.ibm.icu.math.BigDecimal("123456789"),mcs).toString()).equals("12345678.9")); 1762 TestFmwk.assertTrue("mul081", (opo.multiply(new com.ibm.icu.math.BigDecimal("12345678901234"),mcs).toString()).equals("1.23456789E+12")); 1763 TestFmwk.assertTrue("mul082", (opo.multiply(new com.ibm.icu.math.BigDecimal("123456789123456789"),mcs).toString()).equals("1.23456789E+16")); 1764 TestFmwk.assertTrue("mul083", (opo.multiply(new com.ibm.icu.math.BigDecimal("123456789"),mcfd).toString()).equals("12345678.9")); 1765 TestFmwk.assertTrue("mul084", (opo.multiply(new com.ibm.icu.math.BigDecimal("12345678901234"),mcfd).toString()).equals("1234567890123.4")); 1766 TestFmwk.assertTrue("mul085", (opo.multiply(new com.ibm.icu.math.BigDecimal("123456789123456789"),mcfd).toString()).equals("12345678912345678.9")); 1767 1768 TestFmwk.assertTrue("mul090", ((new com.ibm.icu.math.BigDecimal("123456789")).multiply(opo,mcs).toString()).equals("12345678.9")); 1769 TestFmwk.assertTrue("mul091", ((new com.ibm.icu.math.BigDecimal("12345678901234")).multiply(opo,mcs).toString()).equals("1.23456789E+12")); 1770 TestFmwk.assertTrue("mul092", ((new com.ibm.icu.math.BigDecimal("123456789123456789")).multiply(opo,mcs).toString()).equals("1.23456789E+16")); 1771 TestFmwk.assertTrue("mul093", ((new com.ibm.icu.math.BigDecimal("123456789")).multiply(opo,mcfd).toString()).equals("12345678.9")); 1772 TestFmwk.assertTrue("mul094", ((new com.ibm.icu.math.BigDecimal("12345678901234")).multiply(opo,mcfd).toString()).equals("1234567890123.4")); 1773 TestFmwk.assertTrue("mul095", ((new com.ibm.icu.math.BigDecimal("123456789123456789")).multiply(opo,mcfd).toString()).equals("12345678912345678.9")); 1774 1775 // test some more edge cases and carries 1776 TestFmwk.assertTrue("mul101", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("9")).toString()).equals("81")); 1777 TestFmwk.assertTrue("mul102", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("90")).toString()).equals("810")); 1778 TestFmwk.assertTrue("mul103", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("900")).toString()).equals("8100")); 1779 TestFmwk.assertTrue("mul104", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("9000")).toString()).equals("81000")); 1780 TestFmwk.assertTrue("mul105", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("90000")).toString()).equals("810000")); 1781 TestFmwk.assertTrue("mul106", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("900000")).toString()).equals("8100000")); 1782 TestFmwk.assertTrue("mul107", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("9000000")).toString()).equals("81000000")); 1783 TestFmwk.assertTrue("mul108", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("90000000")).toString()).equals("810000000")); 1784 TestFmwk.assertTrue("mul109", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("900000000")).toString()).equals("8100000000")); 1785 TestFmwk.assertTrue("mul110", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("9000000000")).toString()).equals("81000000000")); 1786 TestFmwk.assertTrue("mul111", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("90000000000")).toString()).equals("810000000000")); 1787 TestFmwk.assertTrue("mul112", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("900000000000")).toString()).equals("8100000000000")); 1788 TestFmwk.assertTrue("mul113", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("9000000000000")).toString()).equals("81000000000000")); 1789 TestFmwk.assertTrue("mul114", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("90000000000000")).toString()).equals("810000000000000")); 1790 TestFmwk.assertTrue("mul115", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("900000000000000")).toString()).equals("8100000000000000")); 1791 TestFmwk.assertTrue("mul116", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("9000000000000000")).toString()).equals("81000000000000000")); 1792 TestFmwk.assertTrue("mul117", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("90000000000000000")).toString()).equals("810000000000000000")); 1793 TestFmwk.assertTrue("mul118", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("900000000000000000")).toString()).equals("8100000000000000000")); 1794 TestFmwk.assertTrue("mul119", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("9000000000000000000")).toString()).equals("81000000000000000000")); 1795 TestFmwk.assertTrue("mul120", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("90000000000000000000")).toString()).equals("810000000000000000000")); 1796 TestFmwk.assertTrue("mul121", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("900000000000000000000")).toString()).equals("8100000000000000000000")); 1797 TestFmwk.assertTrue("mul122", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("9000000000000000000000")).toString()).equals("81000000000000000000000")); 1798 TestFmwk.assertTrue("mul123", ((new com.ibm.icu.math.BigDecimal("9")).multiply(new com.ibm.icu.math.BigDecimal("90000000000000000000000")).toString()).equals("810000000000000000000000")); 1799 // test some more edge cases without carries 1800 TestFmwk.assertTrue("mul131", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("9")); 1801 TestFmwk.assertTrue("mul132", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("30")).toString()).equals("90")); 1802 TestFmwk.assertTrue("mul133", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("300")).toString()).equals("900")); 1803 TestFmwk.assertTrue("mul134", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("3000")).toString()).equals("9000")); 1804 TestFmwk.assertTrue("mul135", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("30000")).toString()).equals("90000")); 1805 TestFmwk.assertTrue("mul136", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("300000")).toString()).equals("900000")); 1806 TestFmwk.assertTrue("mul137", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("3000000")).toString()).equals("9000000")); 1807 TestFmwk.assertTrue("mul138", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("30000000")).toString()).equals("90000000")); 1808 TestFmwk.assertTrue("mul139", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("300000000")).toString()).equals("900000000")); 1809 TestFmwk.assertTrue("mul140", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("3000000000")).toString()).equals("9000000000")); 1810 TestFmwk.assertTrue("mul141", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("30000000000")).toString()).equals("90000000000")); 1811 TestFmwk.assertTrue("mul142", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("300000000000")).toString()).equals("900000000000")); 1812 TestFmwk.assertTrue("mul143", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("3000000000000")).toString()).equals("9000000000000")); 1813 TestFmwk.assertTrue("mul144", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("30000000000000")).toString()).equals("90000000000000")); 1814 TestFmwk.assertTrue("mul145", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("300000000000000")).toString()).equals("900000000000000")); 1815 TestFmwk.assertTrue("mul146", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("3000000000000000")).toString()).equals("9000000000000000")); 1816 TestFmwk.assertTrue("mul147", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("30000000000000000")).toString()).equals("90000000000000000")); 1817 TestFmwk.assertTrue("mul148", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("300000000000000000")).toString()).equals("900000000000000000")); 1818 TestFmwk.assertTrue("mul149", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("3000000000000000000")).toString()).equals("9000000000000000000")); 1819 TestFmwk.assertTrue("mul150", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("30000000000000000000")).toString()).equals("90000000000000000000")); 1820 TestFmwk.assertTrue("mul151", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("300000000000000000000")).toString()).equals("900000000000000000000")); 1821 TestFmwk.assertTrue("mul152", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("3000000000000000000000")).toString()).equals("9000000000000000000000")); 1822 TestFmwk.assertTrue("mul153", ((new com.ibm.icu.math.BigDecimal("3")).multiply(new com.ibm.icu.math.BigDecimal("30000000000000000000000")).toString()).equals("90000000000000000000000")); 1823 1824 try { 1825 ten.multiply((com.ibm.icu.math.BigDecimal) null); 1826 flag = false; 1827 } catch (java.lang.NullPointerException $55) { 1828 flag = true; 1829 }/* checknull */ 1830 TestFmwk.assertTrue("mul200", flag); 1831 try { 1832 ten.multiply(ten, (com.ibm.icu.math.MathContext) null); 1833 flag = false; 1834 } catch (java.lang.NullPointerException $56) { 1835 flag = true; 1836 }/* checknull2 */ 1837 TestFmwk.assertTrue("mul201", flag); 1838 1839 try { 1840 d1 = new com.ibm.icu.math.BigDecimal("-1.23456789012345E-0"); 1841 d2 = new com.ibm.icu.math.BigDecimal("9E+999999999"); 1842 d1.multiply(d2, mcdef); // marginal overflow 1843 flag = false; 1844 } catch (java.lang.ArithmeticException $57) { 1845 oe = $57; 1846 flag = (oe.getMessage()).equals("Exponent Overflow: 1000000000"); 1847 }/* checkover */ 1848 TestFmwk.assertTrue("mul202", flag); 1849 try { 1850 d1 = new com.ibm.icu.math.BigDecimal("112"); 1851 d2 = new com.ibm.icu.math.BigDecimal("9E+999999999"); 1852 d1.multiply(d2, mce); // marginal overflow, engineering 1853 flag = false; 1854 } catch (java.lang.ArithmeticException $58) { 1855 oe = $58; 1856 flag = (oe.getMessage()).equals("Exponent Overflow: 1000000002"); 1857 }/* checkover */ 1858 TestFmwk.assertTrue("mul203", flag); 1859 1860 try { 1861 d1 = new com.ibm.icu.math.BigDecimal("0.9"); 1862 d2 = new com.ibm.icu.math.BigDecimal("1E-999999999"); 1863 d1.multiply(d2, mcdef); // marginal negative overflow 1864 flag = false; 1865 } catch (java.lang.ArithmeticException $59) { 1866 oe = $59; 1867 flag = (oe.getMessage()).equals("Exponent Overflow: -1000000000"); 1868 }/* checkover */ 1869 TestFmwk.assertTrue("mul204", flag); 1870 try { 1871 d1 = new com.ibm.icu.math.BigDecimal("0.9"); 1872 d2 = new com.ibm.icu.math.BigDecimal("1E-999999999"); 1873 d1.multiply(d2, mce); // marginal negative overflow, 1874 // engineering 1875 flag = false; 1876 } catch (java.lang.ArithmeticException $60) { 1877 oe = $60; 1878 flag = (oe.getMessage()).equals("Exponent Overflow: -1000000002"); 1879 }/* checkover */ 1880 TestFmwk.assertTrue("mul205", flag); 1881 1882 try { 1883 tenlong.multiply(com.ibm.icu.math.BigDecimal.ONE, mcld); 1884 flag = false; 1885 } catch (java.lang.ArithmeticException $61) { 1886 ae = $61; 1887 flag = (ae.getMessage()).equals("Too many digits:" + " " 1888 + tenlong.toString()); 1889 }/* checkdigits */ 1890 TestFmwk.assertTrue("mul206", flag); 1891 try { 1892 com.ibm.icu.math.BigDecimal.TEN.multiply(tenlong, mcld); 1893 flag = false; 1894 } catch (java.lang.ArithmeticException $62) { 1895 ae = $62; 1896 flag = (ae.getMessage()).equals("Too many digits:" + " " 1897 + tenlong.toString()); 1898 }/* checkdigits */ 1899 TestFmwk.assertTrue("mul207", flag); 1900 1901 } 1902 1903 /* ----------------------------------------------------------------- */ 1904 1905 /** Test the {@link com.ibm.icu.math.BigDecimal#negate} method. */ 1906 1907 @Test 1908 public void diagnegate() { 1909 boolean flag = false; 1910 java.lang.ArithmeticException ae = null; 1911 1912 TestFmwk.assertTrue("neg001", ((new com.ibm.icu.math.BigDecimal("2")).negate().toString()).equals("-2")); 1913 TestFmwk.assertTrue("neg002", ((new com.ibm.icu.math.BigDecimal("-2")).negate().toString()).equals("2")); 1914 TestFmwk.assertTrue("neg003", ((new com.ibm.icu.math.BigDecimal("2.00")).negate(mcdef).toString()).equals("-2.00")); 1915 TestFmwk.assertTrue("neg004", ((new com.ibm.icu.math.BigDecimal("-2.00")).negate(mcdef).toString()).equals("2.00")); 1916 TestFmwk.assertTrue("neg005", ((new com.ibm.icu.math.BigDecimal("0")).negate(mcdef).toString()).equals("0")); 1917 TestFmwk.assertTrue("neg006", ((new com.ibm.icu.math.BigDecimal("0.00")).negate(mcdef).toString()).equals("0")); 1918 TestFmwk.assertTrue("neg007", ((new com.ibm.icu.math.BigDecimal("00.0")).negate(mcdef).toString()).equals("0")); 1919 TestFmwk.assertTrue("neg008", ((new com.ibm.icu.math.BigDecimal("00")).negate(mcdef).toString()).equals("0")); 1920 1921 TestFmwk.assertTrue("neg010", ((new com.ibm.icu.math.BigDecimal("2.00")).negate().toString()).equals("-2.00")); 1922 TestFmwk.assertTrue("neg011", ((new com.ibm.icu.math.BigDecimal("-2.00")).negate().toString()).equals("2.00")); 1923 TestFmwk.assertTrue("neg012", ((new com.ibm.icu.math.BigDecimal("0")).negate().toString()).equals("0")); 1924 TestFmwk.assertTrue("neg013", ((new com.ibm.icu.math.BigDecimal("0.00")).negate().toString()).equals("0.00")); 1925 TestFmwk.assertTrue("neg014", ((new com.ibm.icu.math.BigDecimal("00.0")).negate().toString()).equals("0.0")); 1926 TestFmwk.assertTrue("neg015", ((new com.ibm.icu.math.BigDecimal("00.00")).negate().toString()).equals("0.00")); 1927 TestFmwk.assertTrue("neg016", ((new com.ibm.icu.math.BigDecimal("00")).negate().toString()).equals("0")); 1928 1929 TestFmwk.assertTrue("neg020", ((new com.ibm.icu.math.BigDecimal("-2000000")).negate().toString()).equals("2000000")); 1930 TestFmwk.assertTrue("neg021", ((new com.ibm.icu.math.BigDecimal("-2000000")).negate(mcdef).toString()).equals("2000000")); 1931 TestFmwk.assertTrue("neg022", ((new com.ibm.icu.math.BigDecimal("-2000000")).negate(mc6).toString()).equals("2.00000E+6")); 1932 TestFmwk.assertTrue("neg023", ((new com.ibm.icu.math.BigDecimal("2000000")).negate(mc6).toString()).equals("-2.00000E+6")); 1933 1934 try { 1935 ten.negate((com.ibm.icu.math.MathContext) null); 1936 flag = false; 1937 } catch (java.lang.NullPointerException $63) { 1938 flag = true; 1939 }/* checknull */ 1940 TestFmwk.assertTrue("neg100", flag); 1941 1942 try { 1943 tenlong.negate(mcld); 1944 flag = false; 1945 } catch (java.lang.ArithmeticException $64) { 1946 ae = $64; 1947 flag = (ae.getMessage()).equals("Too many digits:" + " " 1948 + tenlong.toString()); 1949 }/* checkdigits */ 1950 TestFmwk.assertTrue("neg101", flag); 1951 } 1952 1953 /* ----------------------------------------------------------------- */ 1954 1955 /** Test the {@link com.ibm.icu.math.BigDecimal#plus} method. */ 1956 1957 @Test 1958 public void diagplus() { 1959 boolean flag = false; 1960 com.ibm.icu.math.MathContext mche1; 1961 java.lang.ArithmeticException ae = null; 1962 1963 TestFmwk.assertTrue("plu001", ((new com.ibm.icu.math.BigDecimal("2")).plus(mcdef).toString()).equals("2")); 1964 TestFmwk.assertTrue("plu002", ((new com.ibm.icu.math.BigDecimal("-2")).plus(mcdef).toString()).equals("-2")); 1965 TestFmwk.assertTrue("plu003", ((new com.ibm.icu.math.BigDecimal("2.00")).plus(mcdef).toString()).equals("2.00")); 1966 TestFmwk.assertTrue("plu004", ((new com.ibm.icu.math.BigDecimal("-2.00")).plus(mcdef).toString()).equals("-2.00")); 1967 TestFmwk.assertTrue("plu005", ((new com.ibm.icu.math.BigDecimal("0")).plus(mcdef).toString()).equals("0")); 1968 TestFmwk.assertTrue("plu006", ((new com.ibm.icu.math.BigDecimal("0.00")).plus(mcdef).toString()).equals("0")); 1969 TestFmwk.assertTrue("plu007", ((new com.ibm.icu.math.BigDecimal("00.0")).plus(mcdef).toString()).equals("0")); 1970 TestFmwk.assertTrue("plu008", ((new com.ibm.icu.math.BigDecimal("00")).plus(mcdef).toString()).equals("0")); 1971 1972 TestFmwk.assertTrue("plu010", ((new com.ibm.icu.math.BigDecimal("2")).plus().toString()).equals("2")); 1973 TestFmwk.assertTrue("plu011", ((new com.ibm.icu.math.BigDecimal("-2")).plus().toString()).equals("-2")); 1974 TestFmwk.assertTrue("plu012", ((new com.ibm.icu.math.BigDecimal("2.00")).plus().toString()).equals("2.00")); 1975 TestFmwk.assertTrue("plu013", ((new com.ibm.icu.math.BigDecimal("-2.00")).plus().toString()).equals("-2.00")); 1976 TestFmwk.assertTrue("plu014", ((new com.ibm.icu.math.BigDecimal("0")).plus().toString()).equals("0")); 1977 TestFmwk.assertTrue("plu015", ((new com.ibm.icu.math.BigDecimal("0.00")).plus().toString()).equals("0.00")); 1978 TestFmwk.assertTrue("plu016", ((new com.ibm.icu.math.BigDecimal("00.0")).plus().toString()).equals("0.0")); 1979 TestFmwk.assertTrue("plu017", ((new com.ibm.icu.math.BigDecimal("00.00")).plus().toString()).equals("0.00")); 1980 TestFmwk.assertTrue("plu018", ((new com.ibm.icu.math.BigDecimal("00")).plus().toString()).equals("0")); 1981 1982 TestFmwk.assertTrue("plu020", ((new com.ibm.icu.math.BigDecimal("-2000000")).plus().toString()).equals("-2000000")); 1983 TestFmwk.assertTrue("plu021", ((new com.ibm.icu.math.BigDecimal("-2000000")).plus(mcdef).toString()).equals("-2000000")); 1984 TestFmwk.assertTrue("plu022", ((new com.ibm.icu.math.BigDecimal("-2000000")).plus(mc6).toString()).equals("-2.00000E+6")); 1985 TestFmwk.assertTrue("plu023", ((new com.ibm.icu.math.BigDecimal("2000000")).plus(mc6).toString()).equals("2.00000E+6")); 1986 1987 // try some exotic but silly rounding [format checks more varieties] 1988 // [this mostly ensures we can set up and pass the setting] 1989 mche1=new com.ibm.icu.math.MathContext(1,com.ibm.icu.math.MathContext.SCIENTIFIC,false,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN); 1990 TestFmwk.assertTrue("plu030", ((new com.ibm.icu.math.BigDecimal("0.24")).plus(mche1).toString()).equals("0.2")); 1991 TestFmwk.assertTrue("plu031", ((new com.ibm.icu.math.BigDecimal("0.25")).plus(mche1).toString()).equals("0.2")); 1992 TestFmwk.assertTrue("plu032", ((new com.ibm.icu.math.BigDecimal("0.26")).plus(mche1).toString()).equals("0.3")); 1993 TestFmwk.assertTrue("plu033", ((new com.ibm.icu.math.BigDecimal("0.14")).plus(mche1).toString()).equals("0.1")); 1994 TestFmwk.assertTrue("plu034", ((new com.ibm.icu.math.BigDecimal("0.15")).plus(mche1).toString()).equals("0.2")); 1995 TestFmwk.assertTrue("plu035", ((new com.ibm.icu.math.BigDecimal("0.16")).plus(mche1).toString()).equals("0.2")); 1996 1997 TestFmwk.assertTrue("plu040", ((new com.ibm.icu.math.BigDecimal("0.251")).plus(mche1).toString()).equals("0.3")); 1998 TestFmwk.assertTrue("plu041", ((new com.ibm.icu.math.BigDecimal("0.151")).plus(mche1).toString()).equals("0.2")); 1999 2000 TestFmwk.assertTrue("plu050", ((new com.ibm.icu.math.BigDecimal("-0.24")).plus(mche1).toString()).equals("-0.2")); 2001 TestFmwk.assertTrue("plu051", ((new com.ibm.icu.math.BigDecimal("-0.25")).plus(mche1).toString()).equals("-0.2")); 2002 TestFmwk.assertTrue("plu052", ((new com.ibm.icu.math.BigDecimal("-0.26")).plus(mche1).toString()).equals("-0.3")); 2003 TestFmwk.assertTrue("plu053", ((new com.ibm.icu.math.BigDecimal("-0.14")).plus(mche1).toString()).equals("-0.1")); 2004 TestFmwk.assertTrue("plu054", ((new com.ibm.icu.math.BigDecimal("-0.15")).plus(mche1).toString()).equals("-0.2")); 2005 TestFmwk.assertTrue("plu055", ((new com.ibm.icu.math.BigDecimal("-0.16")).plus(mche1).toString()).equals("-0.2")); 2006 2007 // more fixed, potential LHS swaps if done by add 0 2008 TestFmwk.assertTrue("plu060", ((new com.ibm.icu.math.BigDecimal("-56267E-10")).plus().toString()).equals("-0.0000056267")); 2009 TestFmwk.assertTrue("plu061", ((new com.ibm.icu.math.BigDecimal("-56267E-5")).plus().toString()).equals("-0.56267")); 2010 TestFmwk.assertTrue("plu062", ((new com.ibm.icu.math.BigDecimal("-56267E-2")).plus().toString()).equals("-562.67")); 2011 TestFmwk.assertTrue("plu063", ((new com.ibm.icu.math.BigDecimal("-56267E-1")).plus().toString()).equals("-5626.7")); 2012 TestFmwk.assertTrue("plu065", ((new com.ibm.icu.math.BigDecimal("-56267E-0")).plus().toString()).equals("-56267")); 2013 2014 try { 2015 ten.plus((com.ibm.icu.math.MathContext) null); 2016 flag = false; 2017 } catch (java.lang.NullPointerException $65) { 2018 flag = true; 2019 }/* checknull */ 2020 TestFmwk.assertTrue("plu100", flag); 2021 2022 try { 2023 tenlong.plus(mcld); 2024 flag = false; 2025 } catch (java.lang.ArithmeticException $66) { 2026 ae = $66; 2027 flag = (ae.getMessage()).equals("Too many digits:" + " " 2028 + tenlong.toString()); 2029 }/* checkdigits */ 2030 TestFmwk.assertTrue("plu101", flag); 2031 } 2032 2033 /* ----------------------------------------------------------------- */ 2034 2035 /** Test the {@link com.ibm.icu.math.BigDecimal#pow} method. */ 2036 2037 @Test 2038 public void diagpow() { 2039 boolean flag; 2040 com.ibm.icu.math.BigDecimal x; 2041 com.ibm.icu.math.BigDecimal temp; 2042 int n = 0; 2043 com.ibm.icu.math.BigDecimal vx; 2044 com.ibm.icu.math.BigDecimal vn; 2045 java.lang.ArithmeticException ae = null; 2046 flag = true; 2047 TestFmwk.assertTrue("pow001", "1".equals((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("0"),mcdef).toString())); 2048 TestFmwk.assertTrue("pow002", "0.3".equals((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString())); 2049 TestFmwk.assertTrue("pow003", "0.3".equals((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("1.00"),mcdef).toString())); 2050 TestFmwk.assertTrue("pow004", "0.09".equals((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("2.00"),mcdef).toString())); 2051 TestFmwk.assertTrue("pow005", "0.09".equals((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("2.000000000"),mcdef).toString())); 2052 TestFmwk.assertTrue("pow006", ("1E-8").equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-8"),mcdef).toString())); 2053 TestFmwk.assertTrue("pow007", ("1E-7").equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-7"),mcdef).toString())); 2054 TestFmwk.assertTrue("pow008", "0.000001".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-6"),mcdef).toString())); 2055 TestFmwk.assertTrue("pow009", "0.00001".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-5"),mcdef).toString())); 2056 TestFmwk.assertTrue("pow010", "0.0001".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-4"),mcdef).toString())); 2057 TestFmwk.assertTrue("pow011", "0.001".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-3"),mcdef).toString())); 2058 TestFmwk.assertTrue("pow012", "0.01".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-2"),mcdef).toString())); 2059 TestFmwk.assertTrue("pow013", "0.1".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-1"),mcdef).toString())); 2060 TestFmwk.assertTrue("pow014", "1".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("0"),mcdef).toString())); 2061 TestFmwk.assertTrue("pow015", "10".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString())); 2062 TestFmwk.assertTrue("pow016", "100000000".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("8"),mcdef).toString())); 2063 TestFmwk.assertTrue("pow017", ("1E+9").equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("9"),mcdef).toString())); 2064 TestFmwk.assertTrue("pow018", ("1E+99").equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("99"),mcdef).toString())); 2065 TestFmwk.assertTrue("pow019", ("1E+999999999").equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("999999999"),mcdef).toString())); 2066 TestFmwk.assertTrue("pow020", ("1E+999999998").equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("999999998"),mcdef).toString())); 2067 TestFmwk.assertTrue("pow021", ("1E+999999997").equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("999999997"),mcdef).toString())); 2068 TestFmwk.assertTrue("pow022", ("1E+333333333").equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("333333333"),mcdef).toString())); 2069 TestFmwk.assertTrue("pow023", ("1E-333333333").equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-333333333"),mcdef).toString())); 2070 TestFmwk.assertTrue("pow024", ("1E-999999998").equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-999999998"),mcdef).toString())); 2071 TestFmwk.assertTrue("pow025", ("1E-999999999").equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-999999999"),mcdef).toString())); 2072 TestFmwk.assertTrue("pow026", "0.5".equals((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("-1"),mcdef).toString())); 2073 TestFmwk.assertTrue("pow027", "0.25".equals((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("-2"),mcdef).toString())); 2074 TestFmwk.assertTrue("pow028", "0.0625".equals((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("-4"),mcdef).toString())); 2075 2076 TestFmwk.assertTrue("pow050", ((new com.ibm.icu.math.BigDecimal("0")).pow(new com.ibm.icu.math.BigDecimal("0"),mcdef).toString()).equals("1")); 2077 TestFmwk.assertTrue("pow051", ((new com.ibm.icu.math.BigDecimal("0")).pow(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("0")); 2078 TestFmwk.assertTrue("pow052", ((new com.ibm.icu.math.BigDecimal("0")).pow(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("0")); 2079 TestFmwk.assertTrue("pow053", ((new com.ibm.icu.math.BigDecimal("1")).pow(new com.ibm.icu.math.BigDecimal("0"),mcdef).toString()).equals("1")); 2080 TestFmwk.assertTrue("pow054", ((new com.ibm.icu.math.BigDecimal("1")).pow(new com.ibm.icu.math.BigDecimal("1"),mcdef).toString()).equals("1")); 2081 TestFmwk.assertTrue("pow055", ((new com.ibm.icu.math.BigDecimal("1")).pow(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("1")); 2082 TestFmwk.assertTrue("pow056", ((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("0"),mcdef).toString()).equals("1")); 2083 TestFmwk.assertTrue("pow057", ((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("999999999"),mcdef).toString()).equals("1E+999999999")); 2084 TestFmwk.assertTrue("pow058", ((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("999999998"),mcdef).toString()).equals("1E+999999998")); 2085 TestFmwk.assertTrue("pow059", ((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("999999997"),mcdef).toString()).equals("1E+999999997")); 2086 TestFmwk.assertTrue("pow060", ((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("333333333"),mcdef).toString()).equals("1E+333333333")); 2087 TestFmwk.assertTrue("pow061", ((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("77"),mcdef).toString()).equals("1E+77")); 2088 TestFmwk.assertTrue("pow062", ((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("22"),mcdef).toString()).equals("1E+22")); 2089 TestFmwk.assertTrue("pow063", ((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-77"),mcdef).toString()).equals("1E-77")); 2090 TestFmwk.assertTrue("pow064", ((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("-22"),mcdef).toString()).equals("1E-22")); 2091 TestFmwk.assertTrue("pow065", ((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("-1"),mcdef).toString()).equals("0.5")); 2092 TestFmwk.assertTrue("pow066", ((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("-2"),mcdef).toString()).equals("0.25")); 2093 TestFmwk.assertTrue("pow067", ((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("-4"),mcdef).toString()).equals("0.0625")); 2094 TestFmwk.assertTrue("pow068", ((new com.ibm.icu.math.BigDecimal("6.0")).pow(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("36")); 2095 TestFmwk.assertTrue("pow069", ((new com.ibm.icu.math.BigDecimal("-3")).pow(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("9"));/* from book */ 2096 TestFmwk.assertTrue("pow070", ((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("2"),mcdef).pow(new com.ibm.icu.math.BigDecimal("3"),mcdef).toString()).equals("64"));/* from book */ 2097 2098 // 1998.12.14 Next test removed as pow() no longer rounds RHS [as per ANSI] 2099 // Test('pow071').ok=BigDecimal('2').pow(BigDecimal('2.000000001'),mcdef).toString == '4'/* check input rounding */ 2100 2101 /* General tests from original Rexx diagnostics */ 2102 x = new com.ibm.icu.math.BigDecimal("0.5"); 2103 temp = com.ibm.icu.math.BigDecimal.ONE; 2104 flag = true; 2105 { 2106 n = 1; 2107 for (; n <= 10; n++) { 2108 temp = temp.multiply(x).divide(com.ibm.icu.math.BigDecimal.ONE); 2109 flag = flag 2110 & (x.pow(new com.ibm.icu.math.BigDecimal(n), mcdef) 2111 .toString()).equals(temp.toString()); 2112 } 2113 }/* n */ 2114 TestFmwk.assertTrue("pow080", flag); 2115 2116 x = new com.ibm.icu.math.BigDecimal("2"); 2117 temp = com.ibm.icu.math.BigDecimal.ONE; 2118 flag = true; 2119 { 2120 n = 1; 2121 for (; n <= 29; n++) { 2122 temp = temp.multiply(x).divide(com.ibm.icu.math.BigDecimal.ONE); 2123 flag=flag&(x.pow(new com.ibm.icu.math.BigDecimal(n),mcdef).toString()).equals(temp.toString()); 2124 flag=flag&(x.pow(new com.ibm.icu.math.BigDecimal(-n),mcdef).toString()).equals(com.ibm.icu.math.BigDecimal.ONE.divide(temp,mcdef).toString()); 2125 /* Note that rounding errors are possible for larger "n" */ 2126 /* due to the information content of the exponent */ 2127 } 2128 }/* n */ 2129 TestFmwk.assertTrue("pow081", flag); 2130 2131 /* The Vienna case. Checks both setup and 1/acc working precision */ 2132 // Modified 1998.12.14 as RHS no longer rounded before use (must fit) 2133 // Modified 1990.02.04 as LHS is now rounded (instead of truncated to guard) 2134 vx=new com.ibm.icu.math.BigDecimal("123456789E+10"); // lhs .. rounded to 1.23E+18 2135 vn=new com.ibm.icu.math.BigDecimal("-1.23000e+2"); // rhs .. [was: -1.23455e+2, rounds to -123] 2136 TestFmwk.assertTrue("pow090", (vx.pow(vn,mc3).toString()).equals("8.74E-2226")); 2137 2138 // - fixed point versions --- 2139 TestFmwk.assertTrue("pow101", "1".equals((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("0")).toString())); 2140 TestFmwk.assertTrue("pow102", "0.3".equals((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("1")).toString())); 2141 TestFmwk.assertTrue("pow103", "0.3".equals((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("1.00")).toString())); 2142 TestFmwk.assertTrue("pow104", "0.09".equals((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("2")).toString())); 2143 TestFmwk.assertTrue("pow105", "0.09".equals((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("2.00")).toString())); 2144 TestFmwk.assertTrue("pow106", "10".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("1")).toString())); 2145 TestFmwk.assertTrue("pow107", "100000000".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("8")).toString())); 2146 TestFmwk.assertTrue("pow108", "1000000000".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("9")).toString())); 2147 TestFmwk.assertTrue("pow109", "10000000000".equals((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("10")).toString())); 2148 TestFmwk.assertTrue("pow110", "1".equals((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("0")).toString())); 2149 TestFmwk.assertTrue("pow111", "16".equals((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("4")).toString())); 2150 TestFmwk.assertTrue("pow112", "256".equals((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("8")).toString())); 2151 TestFmwk.assertTrue("pow113", "1024".equals((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("10")).toString())); 2152 TestFmwk.assertTrue("pow114", "1.0510100501".equals((new com.ibm.icu.math.BigDecimal("1.01")).pow(new com.ibm.icu.math.BigDecimal("5")).toString())); 2153 2154 TestFmwk.assertTrue("pow120", ((new com.ibm.icu.math.BigDecimal("0")).pow(new com.ibm.icu.math.BigDecimal("0")).toString()).equals("1")); 2155 TestFmwk.assertTrue("pow121", ((new com.ibm.icu.math.BigDecimal("0")).pow(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("0")); 2156 TestFmwk.assertTrue("pow122", ((new com.ibm.icu.math.BigDecimal("0")).pow(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("0")); 2157 TestFmwk.assertTrue("pow123", ((new com.ibm.icu.math.BigDecimal("1")).pow(new com.ibm.icu.math.BigDecimal("0")).toString()).equals("1")); 2158 TestFmwk.assertTrue("pow144", ((new com.ibm.icu.math.BigDecimal("1")).pow(new com.ibm.icu.math.BigDecimal("1")).toString()).equals("1")); 2159 TestFmwk.assertTrue("pow125", ((new com.ibm.icu.math.BigDecimal("1")).pow(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("1")); 2160 TestFmwk.assertTrue("pow126", ((new com.ibm.icu.math.BigDecimal("0.3")).pow(new com.ibm.icu.math.BigDecimal("0")).toString()).equals("1")); 2161 TestFmwk.assertTrue("pow127", ((new com.ibm.icu.math.BigDecimal("10")).pow(new com.ibm.icu.math.BigDecimal("7")).toString()).equals("10000000")); 2162 TestFmwk.assertTrue("pow128", ((new com.ibm.icu.math.BigDecimal("6.0")).pow(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("36.00")); 2163 TestFmwk.assertTrue("pow129", ((new com.ibm.icu.math.BigDecimal("6.00")).pow(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("36.0000")); 2164 TestFmwk.assertTrue("pow130", ((new com.ibm.icu.math.BigDecimal("6.000")).pow(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("36.000000")); 2165 TestFmwk.assertTrue("pow131", ((new com.ibm.icu.math.BigDecimal("-3")).pow(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("9")); 2166 TestFmwk.assertTrue("pow132", ((new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("2")).pow(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("64")); 2167 2168 /* errors */ 2169 try { 2170 ten.pow((com.ibm.icu.math.BigDecimal) null); 2171 flag = false; 2172 } catch (java.lang.NullPointerException $67) { 2173 flag = true; 2174 }/* checknull */ 2175 TestFmwk.assertTrue("pow150", flag); 2176 try { 2177 ten.pow(ten, (com.ibm.icu.math.MathContext) null); 2178 flag = false; 2179 } catch (java.lang.NullPointerException $68) { 2180 flag = true; 2181 }/* checknull2 */ 2182 TestFmwk.assertTrue("pow151", flag); 2183 2184 flag = true; 2185 try { 2186 tenlong.pow(com.ibm.icu.math.BigDecimal.ONE, mcld); 2187 flag = false; 2188 } catch (java.lang.ArithmeticException $69) { 2189 ae = $69; 2190 flag = (ae.getMessage()).equals("Too many digits:" + " " 2191 + tenlong.toString()); 2192 }/* checkdigits */ 2193 TestFmwk.assertTrue("pow152", flag); 2194 2195 try { 2196 com.ibm.icu.math.BigDecimal.ONE.pow(tenlong, mcld); 2197 flag = false; 2198 } catch (java.lang.ArithmeticException $70) { 2199 ae = $70; 2200 flag = (ae.getMessage()).equals("Too many digits:" + " " 2201 + tenlong.toString()); 2202 }/* checkdigits */ 2203 TestFmwk.assertTrue("pow153", flag); 2204 2205 try { 2206 com.ibm.icu.math.BigDecimal.ONE 2207 .pow(new com.ibm.icu.math.BigDecimal("-71")); 2208 flag = false; 2209 } catch (java.lang.ArithmeticException $71) { 2210 ae = $71; 2211 flag = (ae.getMessage()).equals("Negative power: -71"); 2212 }/* checkpos */ 2213 TestFmwk.assertTrue("pow154", flag); 2214 2215 try { 2216 com.ibm.icu.math.BigDecimal.ONE.pow( 2217 new com.ibm.icu.math.BigDecimal("1234"), mc3); 2218 flag = false; 2219 } catch (java.lang.ArithmeticException $72) { 2220 ae = $72; 2221 flag = (ae.getMessage()).equals("Too many digits: 1234"); 2222 }/* checkwhole */ 2223 TestFmwk.assertTrue("pow155", flag); 2224 2225 try { 2226 com.ibm.icu.math.BigDecimal.ONE.pow( 2227 new com.ibm.icu.math.BigDecimal("12.34e+2"), mc3); 2228 flag = false; 2229 } catch (java.lang.ArithmeticException $73) { 2230 ae = $73; 2231 flag = (ae.getMessage()).equals("Too many digits: 1.234E+3"); 2232 }/* checkwhole1 */ 2233 TestFmwk.assertTrue("pow156", flag); 2234 2235 try { 2236 com.ibm.icu.math.BigDecimal.ONE.pow( 2237 new com.ibm.icu.math.BigDecimal("12.4"), mcdef); 2238 flag = false; 2239 } catch (java.lang.ArithmeticException $74) { 2240 ae = $74; 2241 flag = (ae.getMessage()).equals("Decimal part non-zero: 12.4"); 2242 }/* checkwhole2 */ 2243 TestFmwk.assertTrue("pow157", flag); 2244 2245 try { 2246 com.ibm.icu.math.BigDecimal.ONE.pow( 2247 new com.ibm.icu.math.BigDecimal("1.01"), mcdef); 2248 flag = false; 2249 } catch (java.lang.ArithmeticException $75) { 2250 ae = $75; 2251 flag = (ae.getMessage()).equals("Decimal part non-zero: 1.01"); 2252 }/* checkwhole3 */ 2253 TestFmwk.assertTrue("pow158", flag); 2254 2255 try { 2256 com.ibm.icu.math.BigDecimal.ONE.pow( 2257 new com.ibm.icu.math.BigDecimal("1.000000001"), mcdef); 2258 flag = false; 2259 } catch (java.lang.ArithmeticException $76) { 2260 ae = $76; 2261 flag = (ae.getMessage()) 2262 .equals("Decimal part non-zero: 1.000000001"); 2263 }/* checkwhole4 */ 2264 TestFmwk.assertTrue("pow159", flag); 2265 2266 try { 2267 com.ibm.icu.math.BigDecimal.ONE.pow( 2268 new com.ibm.icu.math.BigDecimal("1.000000001"), mc3); 2269 flag = false; 2270 } catch (java.lang.ArithmeticException $77) { 2271 ae = $77; 2272 flag = (ae.getMessage()) 2273 .equals("Decimal part non-zero: 1.000000001"); 2274 }/* checkwhole5 */ 2275 TestFmwk.assertTrue("pow160", flag); 2276 2277 try { 2278 com.ibm.icu.math.BigDecimal.ONE 2279 .pow( 2280 new com.ibm.icu.math.BigDecimal( 2281 "5.67E-987654321"), mc3); 2282 flag = false; 2283 } catch (java.lang.ArithmeticException $78) { 2284 ae = $78; 2285 flag = (ae.getMessage()) 2286 .equals("Decimal part non-zero: 5.67E-987654321"); 2287 }/* checkwhole6 */ 2288 TestFmwk.assertTrue("pow161", flag); 2289 } 2290 2291 /*--------------------------------------------------------------------*/ 2292 2293 /** Test the {@link com.ibm.icu.math.BigDecimal#remainder} method. */ 2294 2295 @Test 2296 public void diagremainder() { 2297 boolean flag = false; 2298 java.lang.ArithmeticException ae = null; 2299 2300 TestFmwk.assertTrue("rem001", ((new com.ibm.icu.math.BigDecimal("1")).remainder(new com.ibm.icu.math.BigDecimal("3"),mcdef).toString()).equals("1")); 2301 TestFmwk.assertTrue("rem002", ((new com.ibm.icu.math.BigDecimal("5")).remainder(new com.ibm.icu.math.BigDecimal("5"),mcdef).toString()).equals("0")); 2302 TestFmwk.assertTrue("rem003", ((new com.ibm.icu.math.BigDecimal("13")).remainder(new com.ibm.icu.math.BigDecimal("10"),mcdef).toString()).equals("3")); 2303 TestFmwk.assertTrue("rem004", ((new com.ibm.icu.math.BigDecimal("13")).remainder(new com.ibm.icu.math.BigDecimal("50"),mcdef).toString()).equals("13")); 2304 TestFmwk.assertTrue("rem005", ((new com.ibm.icu.math.BigDecimal("13")).remainder(new com.ibm.icu.math.BigDecimal("100"),mcdef).toString()).equals("13")); 2305 TestFmwk.assertTrue("rem006", ((new com.ibm.icu.math.BigDecimal("13")).remainder(new com.ibm.icu.math.BigDecimal("1000"),mcdef).toString()).equals("13")); 2306 TestFmwk.assertTrue("rem007", ((new com.ibm.icu.math.BigDecimal(".13")).remainder(one).toString()).equals("0.13")); 2307 TestFmwk.assertTrue("rem008", ((new com.ibm.icu.math.BigDecimal("0.133")).remainder(one).toString()).equals("0.133")); 2308 TestFmwk.assertTrue("rem009", ((new com.ibm.icu.math.BigDecimal("0.1033")).remainder(one).toString()).equals("0.1033")); 2309 TestFmwk.assertTrue("rem010", ((new com.ibm.icu.math.BigDecimal("1.033")).remainder(one).toString()).equals("0.033")); 2310 TestFmwk.assertTrue("rem011", ((new com.ibm.icu.math.BigDecimal("10.33")).remainder(one).toString()).equals("0.33")); 2311 TestFmwk.assertTrue("rem012", ((new com.ibm.icu.math.BigDecimal("10.33")).remainder(com.ibm.icu.math.BigDecimal.TEN).toString()).equals("0.33")); 2312 TestFmwk.assertTrue("rem013", ((new com.ibm.icu.math.BigDecimal("103.3")).remainder(com.ibm.icu.math.BigDecimal.ONE).toString()).equals("0.3")); 2313 TestFmwk.assertTrue("rem014", ((new com.ibm.icu.math.BigDecimal("133")).remainder(com.ibm.icu.math.BigDecimal.TEN).toString()).equals("3")); 2314 TestFmwk.assertTrue("rem015", ((new com.ibm.icu.math.BigDecimal("1033")).remainder(com.ibm.icu.math.BigDecimal.TEN).toString()).equals("3")); 2315 TestFmwk.assertTrue("rem016", ((new com.ibm.icu.math.BigDecimal("1033")).remainder(new com.ibm.icu.math.BigDecimal(50),mcdef).toString()).equals("33")); 2316 TestFmwk.assertTrue("rem017", ((new com.ibm.icu.math.BigDecimal("101.0")).remainder(new com.ibm.icu.math.BigDecimal(3),mcdef).toString()).equals("2.0")); 2317 TestFmwk.assertTrue("rem018", ((new com.ibm.icu.math.BigDecimal("102.0")).remainder(new com.ibm.icu.math.BigDecimal(3),mcdef).toString()).equals("0")); 2318 TestFmwk.assertTrue("rem019", ((new com.ibm.icu.math.BigDecimal("103.0")).remainder(new com.ibm.icu.math.BigDecimal(3),mcdef).toString()).equals("1.0")); 2319 TestFmwk.assertTrue("rem020", ((new com.ibm.icu.math.BigDecimal("2.40")).remainder(one).toString()).equals("0.40")); 2320 TestFmwk.assertTrue("rem021", ((new com.ibm.icu.math.BigDecimal("2.400")).remainder(one).toString()).equals("0.400")); 2321 TestFmwk.assertTrue("rem022", ((new com.ibm.icu.math.BigDecimal("2.4")).remainder(one).toString()).equals("0.4")); 2322 TestFmwk.assertTrue("rem023", ((new com.ibm.icu.math.BigDecimal("2.4")).remainder(new com.ibm.icu.math.BigDecimal(2),mcdef).toString()).equals("0.4")); 2323 TestFmwk.assertTrue("rem024", ((new com.ibm.icu.math.BigDecimal("2.400")).remainder(new com.ibm.icu.math.BigDecimal(2),mcdef).toString()).equals("0.400")); 2324 TestFmwk.assertTrue("rem025", ((new com.ibm.icu.math.BigDecimal("1")).remainder(new com.ibm.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.1")); 2325 TestFmwk.assertTrue("rem026", ((new com.ibm.icu.math.BigDecimal("1")).remainder(new com.ibm.icu.math.BigDecimal("0.30"),mcdef).toString()).equals("0.10")); 2326 TestFmwk.assertTrue("rem027", ((new com.ibm.icu.math.BigDecimal("1")).remainder(new com.ibm.icu.math.BigDecimal("0.300"),mcdef).toString()).equals("0.100")); 2327 TestFmwk.assertTrue("rem028", ((new com.ibm.icu.math.BigDecimal("1")).remainder(new com.ibm.icu.math.BigDecimal("0.3000"),mcdef).toString()).equals("0.1000")); 2328 TestFmwk.assertTrue("rem029", ((new com.ibm.icu.math.BigDecimal("1.0")).remainder(new com.ibm.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.1")); 2329 TestFmwk.assertTrue("rem030", ((new com.ibm.icu.math.BigDecimal("1.00")).remainder(new com.ibm.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.10")); 2330 TestFmwk.assertTrue("rem031", ((new com.ibm.icu.math.BigDecimal("1.000")).remainder(new com.ibm.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.100")); 2331 TestFmwk.assertTrue("rem032", ((new com.ibm.icu.math.BigDecimal("1.0000")).remainder(new com.ibm.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.1000")); 2332 TestFmwk.assertTrue("rem033", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("2.001"),mcdef).toString()).equals("0.5")); 2333 2334 TestFmwk.assertTrue("rem040", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.5000001"),mcdef).toString()).equals("0.5")); 2335 TestFmwk.assertTrue("rem041", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.50000001"),mcdef).toString()).equals("0.5")); 2336 TestFmwk.assertTrue("rem042", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.500000001"),mcdef).toString()).equals("0.5")); 2337 TestFmwk.assertTrue("rem043", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.5000000001"),mcdef).toString()).equals("0")); 2338 TestFmwk.assertTrue("rem044", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.50000000001"),mcdef).toString()).equals("0")); 2339 TestFmwk.assertTrue("rem045", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.4999999"),mcdef).toString()).equals("1E-7")); 2340 TestFmwk.assertTrue("rem046", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.49999999"),mcdef).toString()).equals("1E-8")); 2341 TestFmwk.assertTrue("rem047", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.499999999"),mcdef).toString()).equals("1E-9")); 2342 TestFmwk.assertTrue("rem048", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.4999999999"),mcdef).toString()).equals("0")); 2343 TestFmwk.assertTrue("rem049", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.49999999999"),mcdef).toString()).equals("0")); 2344 2345 TestFmwk.assertTrue("rem050", ((new com.ibm.icu.math.BigDecimal("0.03")).remainder(new com.ibm.icu.math.BigDecimal("7"),mcdef).toString()).equals("0.03")); 2346 TestFmwk.assertTrue("rem051", ((new com.ibm.icu.math.BigDecimal("5")).remainder(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("1")); 2347 TestFmwk.assertTrue("rem052", ((new com.ibm.icu.math.BigDecimal("4.1")).remainder(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.1")); 2348 TestFmwk.assertTrue("rem053", ((new com.ibm.icu.math.BigDecimal("4.01")).remainder(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.01")); 2349 TestFmwk.assertTrue("rem054", ((new com.ibm.icu.math.BigDecimal("4.001")).remainder(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.001")); 2350 TestFmwk.assertTrue("rem055", ((new com.ibm.icu.math.BigDecimal("4.0001")).remainder(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.0001")); 2351 TestFmwk.assertTrue("rem056", ((new com.ibm.icu.math.BigDecimal("4.00001")).remainder(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.00001")); 2352 TestFmwk.assertTrue("rem057", ((new com.ibm.icu.math.BigDecimal("4.000001")).remainder(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("0.000001")); 2353 TestFmwk.assertTrue("rem058", ((new com.ibm.icu.math.BigDecimal("4.0000001")).remainder(new com.ibm.icu.math.BigDecimal("2"),mcdef).toString()).equals("1E-7")); 2354 2355 TestFmwk.assertTrue("rem060", ((new com.ibm.icu.math.BigDecimal("1.2")).remainder(new com.ibm.icu.math.BigDecimal("0.7345"),mcdef).toString()).equals("0.4655")); 2356 TestFmwk.assertTrue("rem061", ((new com.ibm.icu.math.BigDecimal("0.8")).remainder(new com.ibm.icu.math.BigDecimal("12"),mcdef).toString()).equals("0.8")); 2357 TestFmwk.assertTrue("rem062", ((new com.ibm.icu.math.BigDecimal("0.8")).remainder(new com.ibm.icu.math.BigDecimal("0.2"),mcdef).toString()).equals("0")); 2358 TestFmwk.assertTrue("rem063", ((new com.ibm.icu.math.BigDecimal("0.8")).remainder(new com.ibm.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.2")); 2359 TestFmwk.assertTrue("rem064", ((new com.ibm.icu.math.BigDecimal("0.800")).remainder(new com.ibm.icu.math.BigDecimal("12"),mcdef).toString()).equals("0.800")); 2360 TestFmwk.assertTrue("rem065", ((new com.ibm.icu.math.BigDecimal("0.800")).remainder(new com.ibm.icu.math.BigDecimal("1.7"),mcdef).toString()).equals("0.800")); 2361 TestFmwk.assertTrue("rem066", ((new com.ibm.icu.math.BigDecimal("2.400")).remainder(new com.ibm.icu.math.BigDecimal(2),mcdef).toString()).equals("0.400")); 2362 2363 // MC -- 2364 TestFmwk.assertTrue("rem071", ((new com.ibm.icu.math.BigDecimal("2.400")).remainder(new com.ibm.icu.math.BigDecimal(2),mc6).toString()).equals("0.400")); 2365 TestFmwk.assertTrue("rem072", ((new com.ibm.icu.math.BigDecimal("12345678900000")).remainder(new com.ibm.icu.math.BigDecimal("12e+12"),mc3).toString()).equals("3E+11")); 2366 2367 // Fixed -- 2368 TestFmwk.assertTrue("rem101", ((new com.ibm.icu.math.BigDecimal("1")).remainder(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("1")); 2369 TestFmwk.assertTrue("rem102", ((new com.ibm.icu.math.BigDecimal("5")).remainder(new com.ibm.icu.math.BigDecimal("5")).toString()).equals("0")); 2370 TestFmwk.assertTrue("rem103", ((new com.ibm.icu.math.BigDecimal("13")).remainder(new com.ibm.icu.math.BigDecimal("10")).toString()).equals("3")); 2371 TestFmwk.assertTrue("rem104", ((new com.ibm.icu.math.BigDecimal("13")).remainder(new com.ibm.icu.math.BigDecimal("50")).toString()).equals("13")); 2372 TestFmwk.assertTrue("rem105", ((new com.ibm.icu.math.BigDecimal("13")).remainder(new com.ibm.icu.math.BigDecimal("100")).toString()).equals("13")); 2373 TestFmwk.assertTrue("rem106", ((new com.ibm.icu.math.BigDecimal("13")).remainder(new com.ibm.icu.math.BigDecimal("1000")).toString()).equals("13")); 2374 TestFmwk.assertTrue("rem107", ((new com.ibm.icu.math.BigDecimal(".13")).remainder(one).toString()).equals("0.13")); 2375 TestFmwk.assertTrue("rem108", ((new com.ibm.icu.math.BigDecimal("0.133")).remainder(one).toString()).equals("0.133")); 2376 TestFmwk.assertTrue("rem109", ((new com.ibm.icu.math.BigDecimal("0.1033")).remainder(one).toString()).equals("0.1033")); 2377 TestFmwk.assertTrue("rem110", ((new com.ibm.icu.math.BigDecimal("1.033")).remainder(one).toString()).equals("0.033")); 2378 TestFmwk.assertTrue("rem111", ((new com.ibm.icu.math.BigDecimal("10.33")).remainder(one).toString()).equals("0.33")); 2379 TestFmwk.assertTrue("rem112", ((new com.ibm.icu.math.BigDecimal("10.33")).remainder(com.ibm.icu.math.BigDecimal.TEN).toString()).equals("0.33")); 2380 TestFmwk.assertTrue("rem113", ((new com.ibm.icu.math.BigDecimal("103.3")).remainder(com.ibm.icu.math.BigDecimal.ONE).toString()).equals("0.3")); 2381 TestFmwk.assertTrue("rem114", ((new com.ibm.icu.math.BigDecimal("133")).remainder(com.ibm.icu.math.BigDecimal.TEN).toString()).equals("3")); 2382 TestFmwk.assertTrue("rem115", ((new com.ibm.icu.math.BigDecimal("1033")).remainder(com.ibm.icu.math.BigDecimal.TEN).toString()).equals("3")); 2383 TestFmwk.assertTrue("rem116", ((new com.ibm.icu.math.BigDecimal("1033")).remainder(new com.ibm.icu.math.BigDecimal(50)).toString()).equals("33")); 2384 TestFmwk.assertTrue("rem117", ((new com.ibm.icu.math.BigDecimal("101.0")).remainder(new com.ibm.icu.math.BigDecimal(3)).toString()).equals("2.0")); 2385 TestFmwk.assertTrue("rem118", ((new com.ibm.icu.math.BigDecimal("102.0")).remainder(new com.ibm.icu.math.BigDecimal(3)).toString()).equals("0")); 2386 TestFmwk.assertTrue("rem119", ((new com.ibm.icu.math.BigDecimal("103.0")).remainder(new com.ibm.icu.math.BigDecimal(3)).toString()).equals("1.0")); 2387 TestFmwk.assertTrue("rem120", ((new com.ibm.icu.math.BigDecimal("2.40")).remainder(one).toString()).equals("0.40")); 2388 TestFmwk.assertTrue("rem121", ((new com.ibm.icu.math.BigDecimal("2.400")).remainder(one).toString()).equals("0.400")); 2389 TestFmwk.assertTrue("rem122", ((new com.ibm.icu.math.BigDecimal("2.4")).remainder(one).toString()).equals("0.4")); 2390 TestFmwk.assertTrue("rem123", ((new com.ibm.icu.math.BigDecimal("2.4")).remainder(new com.ibm.icu.math.BigDecimal(2)).toString()).equals("0.4")); 2391 TestFmwk.assertTrue("rem124", ((new com.ibm.icu.math.BigDecimal("2.400")).remainder(new com.ibm.icu.math.BigDecimal(2)).toString()).equals("0.400")); 2392 TestFmwk.assertTrue("rem125", ((new com.ibm.icu.math.BigDecimal("1")).remainder(new com.ibm.icu.math.BigDecimal("0.3")).toString()).equals("0.1")); 2393 TestFmwk.assertTrue("rem126", ((new com.ibm.icu.math.BigDecimal("1")).remainder(new com.ibm.icu.math.BigDecimal("0.30")).toString()).equals("0.10")); 2394 TestFmwk.assertTrue("rem127", ((new com.ibm.icu.math.BigDecimal("1")).remainder(new com.ibm.icu.math.BigDecimal("0.300")).toString()).equals("0.100")); 2395 TestFmwk.assertTrue("rem128", ((new com.ibm.icu.math.BigDecimal("1")).remainder(new com.ibm.icu.math.BigDecimal("0.3000")).toString()).equals("0.1000")); 2396 TestFmwk.assertTrue("rem129", ((new com.ibm.icu.math.BigDecimal("1.0")).remainder(new com.ibm.icu.math.BigDecimal("0.3")).toString()).equals("0.1")); 2397 TestFmwk.assertTrue("rem130", ((new com.ibm.icu.math.BigDecimal("1.00")).remainder(new com.ibm.icu.math.BigDecimal("0.3")).toString()).equals("0.10")); 2398 TestFmwk.assertTrue("rem131", ((new com.ibm.icu.math.BigDecimal("1.000")).remainder(new com.ibm.icu.math.BigDecimal("0.3")).toString()).equals("0.100")); 2399 TestFmwk.assertTrue("rem132", ((new com.ibm.icu.math.BigDecimal("1.0000")).remainder(new com.ibm.icu.math.BigDecimal("0.3")).toString()).equals("0.1000")); 2400 TestFmwk.assertTrue("rem133", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("2.001")).toString()).equals("0.5")); 2401 TestFmwk.assertTrue("rem134", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.500000001")).toString()).equals("0.5")); 2402 TestFmwk.assertTrue("rem135", ((new com.ibm.icu.math.BigDecimal("0.5")).remainder(new com.ibm.icu.math.BigDecimal("0.5000000001")).toString()).equals("0.5")); 2403 TestFmwk.assertTrue("rem136", ((new com.ibm.icu.math.BigDecimal("0.03")).remainder(new com.ibm.icu.math.BigDecimal("7")).toString()).equals("0.03")); 2404 TestFmwk.assertTrue("rem137", ((new com.ibm.icu.math.BigDecimal("5")).remainder(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("1")); 2405 TestFmwk.assertTrue("rem138", ((new com.ibm.icu.math.BigDecimal("4.1")).remainder(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("0.1")); 2406 TestFmwk.assertTrue("rem139", ((new com.ibm.icu.math.BigDecimal("4.01")).remainder(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("0.01")); 2407 TestFmwk.assertTrue("rem140", ((new com.ibm.icu.math.BigDecimal("4.001")).remainder(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("0.001")); 2408 TestFmwk.assertTrue("rem141", ((new com.ibm.icu.math.BigDecimal("4.0001")).remainder(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("0.0001")); 2409 TestFmwk.assertTrue("rem142", ((new com.ibm.icu.math.BigDecimal("4.00001")).remainder(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("0.00001")); 2410 TestFmwk.assertTrue("rem143", ((new com.ibm.icu.math.BigDecimal("4.000001")).remainder(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("0.000001")); 2411 TestFmwk.assertTrue("rem144", ((new com.ibm.icu.math.BigDecimal("4.0000001")).remainder(new com.ibm.icu.math.BigDecimal("2")).toString()).equals("0.0000001")); // 1E-7, plain 2412 TestFmwk.assertTrue("rem145", ((new com.ibm.icu.math.BigDecimal("1.2")).remainder(new com.ibm.icu.math.BigDecimal("0.7345")).toString()).equals("0.4655")); 2413 TestFmwk.assertTrue("rem146", ((new com.ibm.icu.math.BigDecimal("0.8")).remainder(new com.ibm.icu.math.BigDecimal("12")).toString()).equals("0.8")); 2414 TestFmwk.assertTrue("rem147", ((new com.ibm.icu.math.BigDecimal("0.8")).remainder(new com.ibm.icu.math.BigDecimal("0.2")).toString()).equals("0")); 2415 TestFmwk.assertTrue("rem148", ((new com.ibm.icu.math.BigDecimal("0.8")).remainder(new com.ibm.icu.math.BigDecimal("0.3")).toString()).equals("0.2")); 2416 TestFmwk.assertTrue("rem149", ((new com.ibm.icu.math.BigDecimal("0.800")).remainder(new com.ibm.icu.math.BigDecimal("12")).toString()).equals("0.800")); 2417 TestFmwk.assertTrue("rem150", ((new com.ibm.icu.math.BigDecimal("0.800")).remainder(new com.ibm.icu.math.BigDecimal("1.7")).toString()).equals("0.800")); 2418 TestFmwk.assertTrue("rem151", ((new com.ibm.icu.math.BigDecimal("2.400")).remainder(new com.ibm.icu.math.BigDecimal(2),mcdef).toString()).equals("0.400")); 2419 2420 2421 try { 2422 ten.remainder((com.ibm.icu.math.BigDecimal) null); 2423 flag = false; 2424 } catch (java.lang.NullPointerException $79) { 2425 flag = true; 2426 }/* checknull */ 2427 TestFmwk.assertTrue("rem200", flag); 2428 try { 2429 ten.remainder(ten, (com.ibm.icu.math.MathContext) null); 2430 flag = false; 2431 } catch (java.lang.NullPointerException $80) { 2432 flag = true; 2433 }/* checknull2 */ 2434 TestFmwk.assertTrue("rem201", flag); 2435 2436 try { 2437 com.ibm.icu.math.BigDecimal.ONE.remainder(tenlong, mcld); 2438 flag = false; 2439 } catch (java.lang.ArithmeticException $81) { 2440 ae = $81; 2441 flag = (ae.getMessage()).equals("Too many digits:" + " " 2442 + tenlong.toString()); 2443 }/* checkdigits */ 2444 TestFmwk.assertTrue("rem202", flag); 2445 2446 try { 2447 tenlong.remainder(one, mcld); 2448 flag = false; 2449 } catch (java.lang.ArithmeticException $82) { 2450 ae = $82; 2451 flag = (ae.getMessage()).equals("Too many digits:" + " " 2452 + tenlong.toString()); 2453 }/* checkdigits */ 2454 TestFmwk.assertTrue("rem203", flag); 2455 } 2456 2457 /*--------------------------------------------------------------------*/ 2458 2459 /** Test the {@link com.ibm.icu.math.BigDecimal#subtract} method. */ 2460 2461 @Test 2462 public void diagsubtract() { 2463 boolean flag = false; 2464 com.ibm.icu.math.BigDecimal alhs; 2465 com.ibm.icu.math.BigDecimal arhs; 2466 java.lang.ArithmeticException ae = null; 2467 2468 // [first group are 'quick confidence check'] 2469 TestFmwk.assertTrue("sub301", ((new com.ibm.icu.math.BigDecimal(2)).subtract(new com.ibm.icu.math.BigDecimal(3),mcdef).toString()).equals("-1")); 2470 TestFmwk.assertTrue("sub302", ((new com.ibm.icu.math.BigDecimal("5.75")).subtract(new com.ibm.icu.math.BigDecimal("3.3"),mcdef).toString()).equals("2.45")); 2471 TestFmwk.assertTrue("sub303", ((new com.ibm.icu.math.BigDecimal("5")).subtract(new com.ibm.icu.math.BigDecimal("-3"),mcdef).toString()).equals("8")); 2472 TestFmwk.assertTrue("sub304", ((new com.ibm.icu.math.BigDecimal("-5")).subtract(new com.ibm.icu.math.BigDecimal("-3"),mcdef).toString()).equals("-2")); 2473 TestFmwk.assertTrue("sub305", ((new com.ibm.icu.math.BigDecimal("-7")).subtract(new com.ibm.icu.math.BigDecimal("2.5"),mcdef).toString()).equals("-9.5")); 2474 TestFmwk.assertTrue("sub306", ((new com.ibm.icu.math.BigDecimal("0.7")).subtract(new com.ibm.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("0.4")); 2475 TestFmwk.assertTrue("sub307", ((new com.ibm.icu.math.BigDecimal("1.3")).subtract(new com.ibm.icu.math.BigDecimal("0.3"),mcdef).toString()).equals("1.0")); 2476 TestFmwk.assertTrue("sub308", ((new com.ibm.icu.math.BigDecimal("1.25")).subtract(new com.ibm.icu.math.BigDecimal("1.25"),mcdef).toString()).equals("0")); 2477 TestFmwk.assertTrue("sub309", ((new com.ibm.icu.math.BigDecimal("1.23456789")).subtract(new com.ibm.icu.math.BigDecimal("1.00000000"),mcdef).toString()).equals("0.23456789")); 2478 2479 TestFmwk.assertTrue("sub310", ((new com.ibm.icu.math.BigDecimal("1.23456789")).subtract(new com.ibm.icu.math.BigDecimal("1.00000089"),mcdef).toString()).equals("0.23456700")); 2480 2481 TestFmwk.assertTrue("sub311", ((new com.ibm.icu.math.BigDecimal("0.5555555559")).subtract(new com.ibm.icu.math.BigDecimal("0.0000000001"),mcdef).toString()).equals("0.555555556")); 2482 2483 TestFmwk.assertTrue("sub312", ((new com.ibm.icu.math.BigDecimal("0.5555555559")).subtract(new com.ibm.icu.math.BigDecimal("0.0000000005"),mcdef).toString()).equals("0.555555556")); 2484 2485 TestFmwk.assertTrue("sub313", ((new com.ibm.icu.math.BigDecimal("0.4444444444")).subtract(new com.ibm.icu.math.BigDecimal("0.1111111111"),mcdef).toString()).equals("0.333333333")); 2486 2487 TestFmwk.assertTrue("sub314", ((new com.ibm.icu.math.BigDecimal("1.0000000000")).subtract(new com.ibm.icu.math.BigDecimal("0.00000001"),mcdef).toString()).equals("0.99999999")); 2488 2489 TestFmwk.assertTrue("sub315", ((new com.ibm.icu.math.BigDecimal("0.4444444444999")).subtract(new com.ibm.icu.math.BigDecimal("0"),mcdef).toString()).equals("0.444444444")); 2490 2491 TestFmwk.assertTrue("sub316", ((new com.ibm.icu.math.BigDecimal("0.4444444445000")).subtract(new com.ibm.icu.math.BigDecimal("0"),mcdef).toString()).equals("0.444444445")); 2492 2493 2494 TestFmwk.assertTrue("sub317", ((new com.ibm.icu.math.BigDecimal("70")).subtract(new com.ibm.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("-1.00000000E+13")); 2495 2496 TestFmwk.assertTrue("sub318", ((new com.ibm.icu.math.BigDecimal("700")).subtract(new com.ibm.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("-1.00000000E+13")); 2497 2498 TestFmwk.assertTrue("sub319", ((new com.ibm.icu.math.BigDecimal("7000")).subtract(new com.ibm.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("-1.00000000E+13")); 2499 2500 TestFmwk.assertTrue("sub320", ((new com.ibm.icu.math.BigDecimal("70000")).subtract(new com.ibm.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("-9.9999999E+12")); 2501 2502 TestFmwk.assertTrue("sub321", ((new com.ibm.icu.math.BigDecimal("700000")).subtract(new com.ibm.icu.math.BigDecimal("10000e+9"),mcdef).toString()).equals("-9.9999993E+12")); 2503 2504 // symmetry: 2505 TestFmwk.assertTrue("sub322", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("70"),mcdef).toString()).equals("1.00000000E+13")); 2506 2507 TestFmwk.assertTrue("sub323", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("700"),mcdef).toString()).equals("1.00000000E+13")); 2508 2509 TestFmwk.assertTrue("sub324", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("7000"),mcdef).toString()).equals("1.00000000E+13")); 2510 2511 TestFmwk.assertTrue("sub325", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("70000"),mcdef).toString()).equals("9.9999999E+12")); 2512 2513 TestFmwk.assertTrue("sub326", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("700000"),mcdef).toString()).equals("9.9999993E+12")); 2514 2515 2516 // [same with fixed point arithmetic] 2517 TestFmwk.assertTrue("sub001", ((new com.ibm.icu.math.BigDecimal(2)).subtract(new com.ibm.icu.math.BigDecimal(3)).toString()).equals("-1")); 2518 TestFmwk.assertTrue("sub002", ((new com.ibm.icu.math.BigDecimal("5.75")).subtract(new com.ibm.icu.math.BigDecimal("3.3")).toString()).equals("2.45")); 2519 TestFmwk.assertTrue("sub003", ((new com.ibm.icu.math.BigDecimal("5")).subtract(new com.ibm.icu.math.BigDecimal("-3")).toString()).equals("8")); 2520 TestFmwk.assertTrue("sub004", ((new com.ibm.icu.math.BigDecimal("-5")).subtract(new com.ibm.icu.math.BigDecimal("-3")).toString()).equals("-2")); 2521 TestFmwk.assertTrue("sub005", ((new com.ibm.icu.math.BigDecimal("-7")).subtract(new com.ibm.icu.math.BigDecimal("2.5")).toString()).equals("-9.5")); 2522 TestFmwk.assertTrue("sub006", ((new com.ibm.icu.math.BigDecimal("0.7")).subtract(new com.ibm.icu.math.BigDecimal("0.3")).toString()).equals("0.4")); 2523 TestFmwk.assertTrue("sub007", ((new com.ibm.icu.math.BigDecimal("1.3")).subtract(new com.ibm.icu.math.BigDecimal("0.3")).toString()).equals("1.0")); 2524 TestFmwk.assertTrue("sub008", ((new com.ibm.icu.math.BigDecimal("1.25")).subtract(new com.ibm.icu.math.BigDecimal("1.25")).toString()).equals("0.00")); 2525 TestFmwk.assertTrue("sub009", ((new com.ibm.icu.math.BigDecimal("0.02")).subtract(new com.ibm.icu.math.BigDecimal("0.02")).toString()).equals("0.00")); 2526 2527 TestFmwk.assertTrue("sub010", ((new com.ibm.icu.math.BigDecimal("1.23456789")).subtract(new com.ibm.icu.math.BigDecimal("1.00000000")).toString()).equals("0.23456789")); 2528 2529 TestFmwk.assertTrue("sub011", ((new com.ibm.icu.math.BigDecimal("1.23456789")).subtract(new com.ibm.icu.math.BigDecimal("1.00000089")).toString()).equals("0.23456700")); 2530 2531 TestFmwk.assertTrue("sub012", ((new com.ibm.icu.math.BigDecimal("0.5555555559")).subtract(new com.ibm.icu.math.BigDecimal("0.0000000001")).toString()).equals("0.5555555558")); 2532 2533 TestFmwk.assertTrue("sub013", ((new com.ibm.icu.math.BigDecimal("0.5555555559")).subtract(new com.ibm.icu.math.BigDecimal("0.0000000005")).toString()).equals("0.5555555554")); 2534 2535 TestFmwk.assertTrue("sub014", ((new com.ibm.icu.math.BigDecimal("0.4444444444")).subtract(new com.ibm.icu.math.BigDecimal("0.1111111111")).toString()).equals("0.3333333333")); 2536 2537 TestFmwk.assertTrue("sub015", ((new com.ibm.icu.math.BigDecimal("1.0000000000")).subtract(new com.ibm.icu.math.BigDecimal("0.00000001")).toString()).equals("0.9999999900")); 2538 2539 TestFmwk.assertTrue("sub016", ((new com.ibm.icu.math.BigDecimal("0.4444444444999")).subtract(new com.ibm.icu.math.BigDecimal("0")).toString()).equals("0.4444444444999")); 2540 2541 TestFmwk.assertTrue("sub017", ((new com.ibm.icu.math.BigDecimal("0.4444444445000")).subtract(new com.ibm.icu.math.BigDecimal("0")).toString()).equals("0.4444444445000")); 2542 2543 2544 TestFmwk.assertTrue("sub018", ((new com.ibm.icu.math.BigDecimal("70")).subtract(new com.ibm.icu.math.BigDecimal("10000e+9")).toString()).equals("-9999999999930")); 2545 2546 TestFmwk.assertTrue("sub019", ((new com.ibm.icu.math.BigDecimal("700")).subtract(new com.ibm.icu.math.BigDecimal("10000e+9")).toString()).equals("-9999999999300")); 2547 2548 TestFmwk.assertTrue("sub020", ((new com.ibm.icu.math.BigDecimal("7000")).subtract(new com.ibm.icu.math.BigDecimal("10000e+9")).toString()).equals("-9999999993000")); 2549 2550 TestFmwk.assertTrue("sub021", ((new com.ibm.icu.math.BigDecimal("70000")).subtract(new com.ibm.icu.math.BigDecimal("10000e+9")).toString()).equals("-9999999930000")); 2551 2552 TestFmwk.assertTrue("sub022", ((new com.ibm.icu.math.BigDecimal("700000")).subtract(new com.ibm.icu.math.BigDecimal("10000e+9")).toString()).equals("-9999999300000")); 2553 2554 // symmetry: 2555 TestFmwk.assertTrue("sub023", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("70")).toString()).equals("9999999999930")); 2556 2557 TestFmwk.assertTrue("sub024", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("700")).toString()).equals("9999999999300")); 2558 2559 TestFmwk.assertTrue("sub025", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("7000")).toString()).equals("9999999993000")); 2560 2561 TestFmwk.assertTrue("sub026", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("70000")).toString()).equals("9999999930000")); 2562 2563 TestFmwk.assertTrue("sub027", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("700000")).toString()).equals("9999999300000")); 2564 2565 // MC 2566 TestFmwk.assertTrue("sub030", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("70000"),mcdef).toString()).equals("9.9999999E+12")); 2567 2568 TestFmwk.assertTrue("sub031", ((new com.ibm.icu.math.BigDecimal("10000e+9")).subtract(new com.ibm.icu.math.BigDecimal("70000"),mc6).toString()).equals("1.00000E+13")); 2569 2570 2571 // some of the next group are really constructor tests 2572 TestFmwk.assertTrue("sub040", ((new com.ibm.icu.math.BigDecimal("00.0")).subtract(new com.ibm.icu.math.BigDecimal("0.0")).toString()).equals("0.0")); 2573 TestFmwk.assertTrue("sub041", ((new com.ibm.icu.math.BigDecimal("00.0")).subtract(new com.ibm.icu.math.BigDecimal("0.00")).toString()).equals("0.00")); 2574 TestFmwk.assertTrue("sub042", ((new com.ibm.icu.math.BigDecimal("0.00")).subtract(new com.ibm.icu.math.BigDecimal("00.0")).toString()).equals("0.00")); 2575 TestFmwk.assertTrue("sub043", ((new com.ibm.icu.math.BigDecimal("00.0")).subtract(new com.ibm.icu.math.BigDecimal("0.00"),mcdef).toString()).equals("0")); 2576 TestFmwk.assertTrue("sub044", ((new com.ibm.icu.math.BigDecimal("0.00")).subtract(new com.ibm.icu.math.BigDecimal("00.0"),mcdef).toString()).equals("0")); 2577 TestFmwk.assertTrue("sub045", ((new com.ibm.icu.math.BigDecimal("3")).subtract(new com.ibm.icu.math.BigDecimal(".3"),mcdef).toString()).equals("2.7")); 2578 TestFmwk.assertTrue("sub046", ((new com.ibm.icu.math.BigDecimal("3.")).subtract(new com.ibm.icu.math.BigDecimal(".3"),mcdef).toString()).equals("2.7")); 2579 TestFmwk.assertTrue("sub047", ((new com.ibm.icu.math.BigDecimal("3.0")).subtract(new com.ibm.icu.math.BigDecimal(".3"),mcdef).toString()).equals("2.7")); 2580 TestFmwk.assertTrue("sub048", ((new com.ibm.icu.math.BigDecimal("3.00")).subtract(new com.ibm.icu.math.BigDecimal(".3"),mcdef).toString()).equals("2.70")); 2581 TestFmwk.assertTrue("sub049", ((new com.ibm.icu.math.BigDecimal("3")).subtract(new com.ibm.icu.math.BigDecimal("3"),mcdef).toString()).equals("0")); 2582 TestFmwk.assertTrue("sub050", ((new com.ibm.icu.math.BigDecimal("3")).subtract(new com.ibm.icu.math.BigDecimal("+3"),mcdef).toString()).equals("0")); 2583 TestFmwk.assertTrue("sub051", ((new com.ibm.icu.math.BigDecimal("3")).subtract(new com.ibm.icu.math.BigDecimal("-3"),mcdef).toString()).equals("6")); 2584 TestFmwk.assertTrue("sub052", ((new com.ibm.icu.math.BigDecimal("3")).subtract(new com.ibm.icu.math.BigDecimal(".3")).toString()).equals("2.7")); 2585 TestFmwk.assertTrue("sub053", ((new com.ibm.icu.math.BigDecimal("3.")).subtract(new com.ibm.icu.math.BigDecimal(".3")).toString()).equals("2.7")); 2586 TestFmwk.assertTrue("sub054", ((new com.ibm.icu.math.BigDecimal("3.0")).subtract(new com.ibm.icu.math.BigDecimal(".3")).toString()).equals("2.7")); 2587 TestFmwk.assertTrue("sub055", ((new com.ibm.icu.math.BigDecimal("3.00")).subtract(new com.ibm.icu.math.BigDecimal(".3")).toString()).equals("2.70")); 2588 TestFmwk.assertTrue("sub056", ((new com.ibm.icu.math.BigDecimal("3")).subtract(new com.ibm.icu.math.BigDecimal("3")).toString()).equals("0")); 2589 TestFmwk.assertTrue("sub057", ((new com.ibm.icu.math.BigDecimal("3")).subtract(new com.ibm.icu.math.BigDecimal("+3")).toString()).equals("0")); 2590 TestFmwk.assertTrue("sub058", ((new com.ibm.icu.math.BigDecimal("3")).subtract(new com.ibm.icu.math.BigDecimal("-3")).toString()).equals("6")); 2591 2592 // the above all from add; massaged and extended. Now some new ones... 2593 // [particularly important for comparisons] 2594 // NB: -1E-7 below were non-exponents pre-ANSI 2595 TestFmwk.assertTrue("sub080", ("-1E-7").equals((new com.ibm.icu.math.BigDecimal("10.23456784")).subtract(new com.ibm.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2596 TestFmwk.assertTrue("sub081", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456785")).subtract(new com.ibm.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2597 TestFmwk.assertTrue("sub082", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456786")).subtract(new com.ibm.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2598 TestFmwk.assertTrue("sub083", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456787")).subtract(new com.ibm.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2599 TestFmwk.assertTrue("sub084", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456788")).subtract(new com.ibm.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2600 TestFmwk.assertTrue("sub085", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456789")).subtract(new com.ibm.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2601 TestFmwk.assertTrue("sub086", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456790")).subtract(new com.ibm.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2602 TestFmwk.assertTrue("sub087", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456791")).subtract(new com.ibm.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2603 TestFmwk.assertTrue("sub088", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456792")).subtract(new com.ibm.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2604 TestFmwk.assertTrue("sub089", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456793")).subtract(new com.ibm.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2605 TestFmwk.assertTrue("sub090", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456794")).subtract(new com.ibm.icu.math.BigDecimal("10.23456789"),mcdef).toString())); 2606 TestFmwk.assertTrue("sub091", ("-1E-7").equals((new com.ibm.icu.math.BigDecimal("10.23456781")).subtract(new com.ibm.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2607 TestFmwk.assertTrue("sub092", ("-1E-7").equals((new com.ibm.icu.math.BigDecimal("10.23456782")).subtract(new com.ibm.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2608 TestFmwk.assertTrue("sub093", ("-1E-7").equals((new com.ibm.icu.math.BigDecimal("10.23456783")).subtract(new com.ibm.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2609 TestFmwk.assertTrue("sub094", ("-1E-7").equals((new com.ibm.icu.math.BigDecimal("10.23456784")).subtract(new com.ibm.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2610 TestFmwk.assertTrue("sub095", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456785")).subtract(new com.ibm.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2611 TestFmwk.assertTrue("sub096", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456786")).subtract(new com.ibm.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2612 TestFmwk.assertTrue("sub097", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456787")).subtract(new com.ibm.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2613 TestFmwk.assertTrue("sub098", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456788")).subtract(new com.ibm.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2614 TestFmwk.assertTrue("sub099", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456789")).subtract(new com.ibm.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2615 TestFmwk.assertTrue("sub100", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456790")).subtract(new com.ibm.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2616 TestFmwk.assertTrue("sub101", "0".equals((new com.ibm.icu.math.BigDecimal("10.23456791")).subtract(new com.ibm.icu.math.BigDecimal("10.23456786"),mcdef).toString())); 2617 TestFmwk.assertTrue("sub102", "0".equals(com.ibm.icu.math.BigDecimal.ONE.subtract(new com.ibm.icu.math.BigDecimal("0.999999999"),mcdef).toString())); 2618 TestFmwk.assertTrue("sub103", "0".equals((new com.ibm.icu.math.BigDecimal("0.999999999")).subtract(com.ibm.icu.math.BigDecimal.ONE,mcdef).toString())); 2619 2620 alhs = new com.ibm.icu.math.BigDecimal("12345678900000"); 2621 arhs = new com.ibm.icu.math.BigDecimal("9999999999999"); 2622 TestFmwk.assertTrue("sub110", (alhs.subtract(arhs, mc3).toString()).equals("2.3E+12")); 2623 TestFmwk.assertTrue("sub111", (arhs.subtract(alhs, mc3).toString()).equals("-2.3E+12")); 2624 TestFmwk.assertTrue("sub112", (alhs.subtract(arhs).toString()).equals("2345678900001")); 2625 TestFmwk.assertTrue("sub113", (arhs.subtract(alhs).toString()).equals("-2345678900001")); 2626 2627 // additional scaled arithmetic tests [0.97 problem] 2628 TestFmwk.assertTrue("sub120", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal(".1")).toString()).equals("-0.1")); 2629 TestFmwk.assertTrue("sub121", ((new com.ibm.icu.math.BigDecimal("00")).subtract(new com.ibm.icu.math.BigDecimal(".97983")).toString()).equals("-0.97983")); 2630 TestFmwk.assertTrue("sub122", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal(".9")).toString()).equals("-0.9")); 2631 TestFmwk.assertTrue("sub123", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("0.102")).toString()).equals("-0.102")); 2632 TestFmwk.assertTrue("sub124", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal(".4")).toString()).equals("-0.4")); 2633 TestFmwk.assertTrue("sub125", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal(".307")).toString()).equals("-0.307")); 2634 TestFmwk.assertTrue("sub126", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal(".43822")).toString()).equals("-0.43822")); 2635 TestFmwk.assertTrue("sub127", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal(".911")).toString()).equals("-0.911")); 2636 TestFmwk.assertTrue("sub128", ((new com.ibm.icu.math.BigDecimal(".0")).subtract(new com.ibm.icu.math.BigDecimal(".02")).toString()).equals("-0.02")); 2637 TestFmwk.assertTrue("sub129", ((new com.ibm.icu.math.BigDecimal("00")).subtract(new com.ibm.icu.math.BigDecimal(".392")).toString()).equals("-0.392")); 2638 TestFmwk.assertTrue("sub130", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal(".26")).toString()).equals("-0.26")); 2639 TestFmwk.assertTrue("sub131", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("0.51")).toString()).equals("-0.51")); 2640 TestFmwk.assertTrue("sub132", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal(".2234")).toString()).equals("-0.2234")); 2641 TestFmwk.assertTrue("sub133", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal(".2")).toString()).equals("-0.2")); 2642 TestFmwk.assertTrue("sub134", ((new com.ibm.icu.math.BigDecimal(".0")).subtract(new com.ibm.icu.math.BigDecimal(".0008")).toString()).equals("-0.0008")); 2643 // 0. on left 2644 TestFmwk.assertTrue("sub140", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-.1")).toString()).equals("0.1")); 2645 TestFmwk.assertTrue("sub141", ((new com.ibm.icu.math.BigDecimal("0.00")).subtract(new com.ibm.icu.math.BigDecimal("-.97983")).toString()).equals("0.97983")); 2646 TestFmwk.assertTrue("sub142", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-.9")).toString()).equals("0.9")); 2647 TestFmwk.assertTrue("sub143", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-0.102")).toString()).equals("0.102")); 2648 TestFmwk.assertTrue("sub144", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-.4")).toString()).equals("0.4")); 2649 TestFmwk.assertTrue("sub145", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-.307")).toString()).equals("0.307")); 2650 TestFmwk.assertTrue("sub146", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-.43822")).toString()).equals("0.43822")); 2651 TestFmwk.assertTrue("sub147", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-.911")).toString()).equals("0.911")); 2652 TestFmwk.assertTrue("sub148", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-.02")).toString()).equals("0.02")); 2653 TestFmwk.assertTrue("sub149", ((new com.ibm.icu.math.BigDecimal("0.00")).subtract(new com.ibm.icu.math.BigDecimal("-.392")).toString()).equals("0.392")); 2654 TestFmwk.assertTrue("sub150", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-.26")).toString()).equals("0.26")); 2655 TestFmwk.assertTrue("sub151", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-0.51")).toString()).equals("0.51")); 2656 TestFmwk.assertTrue("sub152", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-.2234")).toString()).equals("0.2234")); 2657 TestFmwk.assertTrue("sub153", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-.2")).toString()).equals("0.2")); 2658 TestFmwk.assertTrue("sub154", ((new com.ibm.icu.math.BigDecimal("0.0")).subtract(new com.ibm.icu.math.BigDecimal("-.0008")).toString()).equals("0.0008")); 2659 // negatives of same 2660 TestFmwk.assertTrue("sub160", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("-.1")).toString()).equals("0.1")); 2661 TestFmwk.assertTrue("sub161", ((new com.ibm.icu.math.BigDecimal("00")).subtract(new com.ibm.icu.math.BigDecimal("-.97983")).toString()).equals("0.97983")); 2662 TestFmwk.assertTrue("sub162", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("-.9")).toString()).equals("0.9")); 2663 TestFmwk.assertTrue("sub163", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("-0.102")).toString()).equals("0.102")); 2664 TestFmwk.assertTrue("sub164", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("-.4")).toString()).equals("0.4")); 2665 TestFmwk.assertTrue("sub165", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("-.307")).toString()).equals("0.307")); 2666 TestFmwk.assertTrue("sub166", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("-.43822")).toString()).equals("0.43822")); 2667 TestFmwk.assertTrue("sub167", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("-.911")).toString()).equals("0.911")); 2668 TestFmwk.assertTrue("sub168", ((new com.ibm.icu.math.BigDecimal(".0")).subtract(new com.ibm.icu.math.BigDecimal("-.02")).toString()).equals("0.02")); 2669 TestFmwk.assertTrue("sub169", ((new com.ibm.icu.math.BigDecimal("00")).subtract(new com.ibm.icu.math.BigDecimal("-.392")).toString()).equals("0.392")); 2670 TestFmwk.assertTrue("sub170", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("-.26")).toString()).equals("0.26")); 2671 TestFmwk.assertTrue("sub171", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("-0.51")).toString()).equals("0.51")); 2672 TestFmwk.assertTrue("sub172", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("-.2234")).toString()).equals("0.2234")); 2673 TestFmwk.assertTrue("sub173", ((new com.ibm.icu.math.BigDecimal("0")).subtract(new com.ibm.icu.math.BigDecimal("-.2")).toString()).equals("0.2")); 2674 TestFmwk.assertTrue("sub174", ((new com.ibm.icu.math.BigDecimal(".0")).subtract(new com.ibm.icu.math.BigDecimal("-.0008")).toString()).equals("0.0008")); 2675 2676 // more fixed, LHS swaps [really same as testcases under add] 2677 TestFmwk.assertTrue("sub180", ((new com.ibm.icu.math.BigDecimal("-56267E-10")).subtract(zero).toString()).equals("-0.0000056267")); 2678 TestFmwk.assertTrue("sub181", ((new com.ibm.icu.math.BigDecimal("-56267E-5")).subtract(zero).toString()).equals("-0.56267")); 2679 TestFmwk.assertTrue("sub182", ((new com.ibm.icu.math.BigDecimal("-56267E-2")).subtract(zero).toString()).equals("-562.67")); 2680 TestFmwk.assertTrue("sub183", ((new com.ibm.icu.math.BigDecimal("-56267E-1")).subtract(zero).toString()).equals("-5626.7")); 2681 TestFmwk.assertTrue("sub185", ((new com.ibm.icu.math.BigDecimal("-56267E-0")).subtract(zero).toString()).equals("-56267")); 2682 2683 try { 2684 ten.subtract((com.ibm.icu.math.BigDecimal) null); 2685 flag = false; 2686 } catch (java.lang.NullPointerException $83) { 2687 flag = true; 2688 }/* checknull */ 2689 TestFmwk.assertTrue("sub200", flag); 2690 try { 2691 ten.subtract(ten, (com.ibm.icu.math.MathContext) null); 2692 flag = false; 2693 } catch (java.lang.NullPointerException $84) { 2694 flag = true; 2695 }/* checknull2 */ 2696 TestFmwk.assertTrue("sub201", flag); 2697 2698 try { 2699 com.ibm.icu.math.BigDecimal.ONE.subtract(tenlong, mcld); 2700 flag = false; 2701 } catch (java.lang.ArithmeticException $85) { 2702 ae = $85; 2703 flag = (ae.getMessage()).equals("Too many digits:" + " " 2704 + tenlong.toString()); 2705 }/* checkdigits */ 2706 TestFmwk.assertTrue("sub202", flag); 2707 try { 2708 tenlong.subtract(com.ibm.icu.math.BigDecimal.ONE, mcld); 2709 flag = false; 2710 } catch (java.lang.ArithmeticException $86) { 2711 ae = $86; 2712 flag = (ae.getMessage()).equals("Too many digits:" + " " 2713 + tenlong.toString()); 2714 }/* checkdigits */ 2715 TestFmwk.assertTrue("sub203", flag); 2716 } 2717 2718 /* ----------------------------------------------------------------- */ 2719 2720 /* ----------------------------------------------------------------- */ 2721 /* Other methods */ 2722 /* ----------------------------------------------------------------- */ 2723 2724 /** Test the <code>BigDecimal.byteValue()</code> method. */ 2725 2726 @Test 2727 public void diagbyteValue() { 2728 boolean flag = false; 2729 java.lang.String v = null; 2730 java.lang.ArithmeticException ae = null; 2731 java.lang.String badstrings[]; 2732 int i = 0; 2733 java.lang.String norm = null; 2734 2735 TestFmwk.assertTrue("byv001", ((((byte)-128)))==((new com.ibm.icu.math.BigDecimal("-128")).byteValue())); 2736 TestFmwk.assertTrue("byv002", ((0))==((new com.ibm.icu.math.BigDecimal("0")).byteValue())); 2737 TestFmwk.assertTrue("byv003", ((1))==((new com.ibm.icu.math.BigDecimal("1")).byteValue())); 2738 TestFmwk.assertTrue("byv004", ((99))==((new com.ibm.icu.math.BigDecimal("99")).byteValue())); 2739 TestFmwk.assertTrue("byv005", ((127))==((new com.ibm.icu.math.BigDecimal("127")).byteValue())); 2740 TestFmwk.assertTrue("byv006", ((-128))==((new com.ibm.icu.math.BigDecimal("128")).byteValue())); 2741 TestFmwk.assertTrue("byv007", ((-127))==((new com.ibm.icu.math.BigDecimal("129")).byteValue())); 2742 TestFmwk.assertTrue("byv008", ((127))==((new com.ibm.icu.math.BigDecimal("-129")).byteValue())); 2743 TestFmwk.assertTrue("byv009", ((126))==((new com.ibm.icu.math.BigDecimal("-130")).byteValue())); 2744 TestFmwk.assertTrue("byv010", ((bmax))==((new com.ibm.icu.math.BigDecimal(bmax)).byteValue())); 2745 TestFmwk.assertTrue("byv011", ((bmin))==((new com.ibm.icu.math.BigDecimal(bmin)).byteValue())); 2746 TestFmwk.assertTrue("byv012", ((bneg))==((new com.ibm.icu.math.BigDecimal(bneg)).byteValue())); 2747 TestFmwk.assertTrue("byv013", ((bzer))==((new com.ibm.icu.math.BigDecimal(bzer)).byteValue())); 2748 TestFmwk.assertTrue("byv014", ((bpos))==((new com.ibm.icu.math.BigDecimal(bpos)).byteValue())); 2749 TestFmwk.assertTrue("byv015", ((bmin))==((new com.ibm.icu.math.BigDecimal(bmax+1)).byteValue())); 2750 TestFmwk.assertTrue("byv016", ((bmax))==((new com.ibm.icu.math.BigDecimal(bmin-1)).byteValue())); 2751 2752 TestFmwk.assertTrue("byv021", ((((byte)-128)))==((new com.ibm.icu.math.BigDecimal("-128")).byteValueExact())); 2753 TestFmwk.assertTrue("byv022", ((0))==((new com.ibm.icu.math.BigDecimal("0")).byteValueExact())); 2754 TestFmwk.assertTrue("byv023", ((1))==((new com.ibm.icu.math.BigDecimal("1")).byteValueExact())); 2755 TestFmwk.assertTrue("byv024", ((99))==((new com.ibm.icu.math.BigDecimal("99")).byteValueExact())); 2756 TestFmwk.assertTrue("byv025", ((127))==((new com.ibm.icu.math.BigDecimal("127")).byteValueExact())); 2757 TestFmwk.assertTrue("byv026", ((bmax))==((new com.ibm.icu.math.BigDecimal(bmax)).byteValueExact())); 2758 TestFmwk.assertTrue("byv027", ((bmin))==((new com.ibm.icu.math.BigDecimal(bmin)).byteValueExact())); 2759 TestFmwk.assertTrue("byv028", ((bneg))==((new com.ibm.icu.math.BigDecimal(bneg)).byteValueExact())); 2760 TestFmwk.assertTrue("byv029", ((bzer))==((new com.ibm.icu.math.BigDecimal(bzer)).byteValueExact())); 2761 TestFmwk.assertTrue("byv030", ((bpos))==((new com.ibm.icu.math.BigDecimal(bpos)).byteValueExact())); 2762 try { 2763 v = "-129"; 2764 (new com.ibm.icu.math.BigDecimal(v)).byteValueExact(); 2765 flag = false; 2766 } catch (java.lang.ArithmeticException $87) { 2767 ae = $87; 2768 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 2769 } 2770 TestFmwk.assertTrue("byv100", flag); 2771 try { 2772 v = "128"; 2773 (new com.ibm.icu.math.BigDecimal(v)).byteValueExact(); 2774 flag = false; 2775 } catch (java.lang.ArithmeticException $88) { 2776 ae = $88; 2777 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 2778 } 2779 TestFmwk.assertTrue("byv101", flag); 2780 try { 2781 v = "1.5"; 2782 (new com.ibm.icu.math.BigDecimal(v)).byteValueExact(); 2783 flag = false; 2784 } catch (java.lang.ArithmeticException $89) { 2785 ae = $89; 2786 flag = (ae.getMessage()).equals("Decimal part non-zero:" + " " + v); 2787 } 2788 TestFmwk.assertTrue("byv102", flag); 2789 2790 badstrings = new java.lang.String[] { 2791 "1234", 2792 (new com.ibm.icu.math.BigDecimal(bmax)).add(one).toString(), 2793 (new com.ibm.icu.math.BigDecimal(bmin)).subtract(one) 2794 .toString(), 2795 "170", 2796 "270", 2797 "370", 2798 "470", 2799 "570", 2800 "670", 2801 "770", 2802 "870", 2803 "970", 2804 "-170", 2805 "-270", 2806 "-370", 2807 "-470", 2808 "-570", 2809 "-670", 2810 "-770", 2811 "-870", 2812 "-970", 2813 (new com.ibm.icu.math.BigDecimal(bmin)).multiply(two) 2814 .toString(), 2815 (new com.ibm.icu.math.BigDecimal(bmax)).multiply(two) 2816 .toString(), 2817 (new com.ibm.icu.math.BigDecimal(bmin)).multiply(ten) 2818 .toString(), 2819 (new com.ibm.icu.math.BigDecimal(bmax)).multiply(ten) 2820 .toString(), "-1234" }; // 220 2821 // 221 2822 // 222 2823 // 223 2824 // 224 2825 // 225 2826 // 226 2827 // 227 2828 // 228 2829 // 229 2830 // 230 2831 // 231 2832 // 232 2833 // 233 2834 // 234 2835 // 235 2836 // 236 2837 // 237 2838 // 238 2839 // 239 2840 // 240 2841 // 241 2842 // 242 2843 // 243 2844 // 244 2845 // 245 2846 { 2847 int $90 = badstrings.length; 2848 i = 0; 2849 for (; $90 > 0; $90--, i++) { 2850 try { 2851 v = badstrings[i]; 2852 (new com.ibm.icu.math.BigDecimal(v)).byteValueExact(); 2853 flag = false; 2854 } catch (java.lang.ArithmeticException $91) { 2855 ae = $91; 2856 norm = (new com.ibm.icu.math.BigDecimal(v)).toString(); 2857 flag = (ae.getMessage()).equals("Conversion overflow:" 2858 + " " + norm); 2859 } 2860 TestFmwk.assertTrue("byv" + (220 + i), flag); 2861 } 2862 }/* i */ 2863 } 2864 2865 /* ----------------------------------------------------------------- */ 2866 2867 /** 2868 * Test the {@link com.ibm.icu.math.BigDecimal#compareTo(java.lang.Object)} 2869 * method. 2870 */ 2871 2872 @Test 2873 public void diagcomparetoObj() { 2874 // boolean flag = false; 2875 // com.ibm.icu.math.BigDecimal d; 2876 // com.ibm.icu.math.BigDecimal long1; 2877 // com.ibm.icu.math.BigDecimal long2; 2878 // 2879 // d = new com.ibm.icu.math.BigDecimal(17); 2880 // (new Test("cto001")).ok = (d 2881 // .compareTo((java.lang.Object) (new com.ibm.icu.math.BigDecimal( 2882 // 66)))) == (-1); 2883 // (new Test("cto002")).ok = (d 2884 // .compareTo((java.lang.Object) ((new com.ibm.icu.math.BigDecimal( 2885 // 10)).add(new com.ibm.icu.math.BigDecimal(7))))) == 0; 2886 // (new Test("cto003")).ok = (d 2887 // .compareTo((java.lang.Object) (new com.ibm.icu.math.BigDecimal( 2888 // 10)))) == 1; 2889 // long1 = new com.ibm.icu.math.BigDecimal("12345678903"); 2890 // long2 = new com.ibm.icu.math.BigDecimal("12345678900"); 2891 // TestFmwk.assertTrue("cto004", (long1.compareTo((java.lang.Object) long2)) == 1); 2892 // TestFmwk.assertTrue("cto005", (long2.compareTo((java.lang.Object) long1)) == (-1)); 2893 // TestFmwk.assertTrue("cto006", (long2.compareTo((java.lang.Object) long2)) == 0); 2894 // try { 2895 // d.compareTo((java.lang.Object) null); 2896 // flag = false; 2897 // } catch (java.lang.NullPointerException $92) { 2898 // flag = true; // should get here 2899 // } 2900 // TestFmwk.assertTrue("cto101", flag); 2901 // try { 2902 // d.compareTo((java.lang.Object) "foo"); 2903 // flag = false; 2904 // } catch (java.lang.ClassCastException $93) { 2905 // flag = true; // should get here 2906 // } 2907 // TestFmwk.assertTrue("cto102", flag); 2908 // summary("compareTo(Obj)"); 2909 } 2910 2911 /* ----------------------------------------------------------------- */ 2912 2913 /** Test the {@link com.ibm.icu.math.BigDecimal#doubleValue} method. */ 2914 2915 @Test 2916 public void diagdoublevalue() { 2917 java.lang.String val; 2918 // 1999.03.07 Infinities no longer errors 2919 val = "-1"; 2920 TestFmwk.assertTrue("dov001", ((new com.ibm.icu.math.BigDecimal(val)).doubleValue()) == ((new java.lang.Double(val)).doubleValue())); 2921 val = "-0.1"; 2922 TestFmwk.assertTrue("dov002", ((new com.ibm.icu.math.BigDecimal(val)).doubleValue()) == ((new java.lang.Double(val)).doubleValue())); 2923 val = "0"; 2924 TestFmwk.assertTrue("dov003", ((new com.ibm.icu.math.BigDecimal(val)).doubleValue()) == ((new java.lang.Double(val)).doubleValue())); 2925 val = "0.1"; 2926 TestFmwk.assertTrue("dov004", ((new com.ibm.icu.math.BigDecimal(val)).doubleValue()) == ((new java.lang.Double(val)).doubleValue())); 2927 val = "1"; 2928 TestFmwk.assertTrue("dov005", ((new com.ibm.icu.math.BigDecimal(val)).doubleValue()) == ((new java.lang.Double(val)).doubleValue())); 2929 val = "1e1000"; 2930 TestFmwk.assertTrue("dov006", ((new com.ibm.icu.math.BigDecimal(val)).doubleValue()) == java.lang.Double.POSITIVE_INFINITY); 2931 val = "-1e1000"; 2932 TestFmwk.assertTrue("dov007", ((new com.ibm.icu.math.BigDecimal(val)).doubleValue()) == java.lang.Double.NEGATIVE_INFINITY); 2933 } 2934 2935 /* ----------------------------------------------------------------- */ 2936 2937 /** Test the {@link com.ibm.icu.math.BigDecimal#equals} method. */ 2938 2939 @Test 2940 public void diagequals() { 2941 com.ibm.icu.math.BigDecimal d; 2942 d = new com.ibm.icu.math.BigDecimal(17); 2943 TestFmwk.assertTrue("equ001", (!(d.equals((java.lang.Object) null)))); 2944 TestFmwk.assertTrue("equ002", (!(d.equals("foo")))); 2945 TestFmwk.assertTrue("equ003", (!(d.equals((new com.ibm.icu.math.BigDecimal(66)))))); 2946 TestFmwk.assertTrue("equ004", d.equals(d)); 2947 TestFmwk.assertTrue("equ005", d.equals(((new com.ibm.icu.math.BigDecimal(10)).add(new com.ibm.icu.math.BigDecimal(7))))); 2948 } 2949 2950 /* ----------------------------------------------------------------- */ 2951 2952 /** Test the {@link com.ibm.icu.math.BigDecimal#floatValue} method. */ 2953 2954 @Test 2955 public void diagfloatvalue() { 2956 java.lang.String val; 2957 // 1999.03.07 Infinities no longer errors 2958 val = "-1"; 2959 TestFmwk.assertTrue("flv001", ((new com.ibm.icu.math.BigDecimal(val)).floatValue()) == ((new java.lang.Float(val)).floatValue())); 2960 val = "-0.1"; 2961 TestFmwk.assertTrue("flv002", ((new com.ibm.icu.math.BigDecimal(val)).floatValue()) == ((new java.lang.Float(val)).floatValue())); 2962 val = "0"; 2963 TestFmwk.assertTrue("flv003", ((new com.ibm.icu.math.BigDecimal(val)).floatValue()) == ((new java.lang.Float(val)).floatValue())); 2964 val = "0.1"; 2965 TestFmwk.assertTrue("flv004", ((new com.ibm.icu.math.BigDecimal(val)).floatValue()) == ((new java.lang.Float(val)).floatValue())); 2966 val = "1"; 2967 TestFmwk.assertTrue("flv005", ((new com.ibm.icu.math.BigDecimal(val)).floatValue()) == ((new java.lang.Float(val)).floatValue())); 2968 val = "1e200"; 2969 TestFmwk.assertTrue("flv006", ((new com.ibm.icu.math.BigDecimal(val)).floatValue()) == java.lang.Float.POSITIVE_INFINITY); 2970 val = "-1e200"; 2971 TestFmwk.assertTrue("flv007", ((new com.ibm.icu.math.BigDecimal(val)).floatValue()) == java.lang.Float.NEGATIVE_INFINITY); 2972 val = "1e1000"; 2973 TestFmwk.assertTrue("flv008", ((new com.ibm.icu.math.BigDecimal(val)).floatValue()) == java.lang.Float.POSITIVE_INFINITY); 2974 val = "-1e1000"; 2975 TestFmwk.assertTrue("flv009", ((new com.ibm.icu.math.BigDecimal(val)).floatValue()) == java.lang.Float.NEGATIVE_INFINITY); 2976 } 2977 2978 /* ----------------------------------------------------------------- */ 2979 2980 /** Test the {@link com.ibm.icu.math.BigDecimal#format} method. */ 2981 2982 @Test 2983 public void diagformat() { 2984 boolean flag = false; 2985 int eng; 2986 int sci; 2987 com.ibm.icu.math.BigDecimal d04; 2988 com.ibm.icu.math.BigDecimal d05; 2989 com.ibm.icu.math.BigDecimal d06; 2990 com.ibm.icu.math.BigDecimal d15; 2991 java.lang.IllegalArgumentException iae = null; 2992 com.ibm.icu.math.BigDecimal d050; 2993 com.ibm.icu.math.BigDecimal d150; 2994 com.ibm.icu.math.BigDecimal m050; 2995 com.ibm.icu.math.BigDecimal m150; 2996 com.ibm.icu.math.BigDecimal d051; 2997 com.ibm.icu.math.BigDecimal d151; 2998 com.ibm.icu.math.BigDecimal d000; 2999 com.ibm.icu.math.BigDecimal d500; 3000 java.lang.ArithmeticException ae = null; 3001 // 1999.02.09 now only two signatures for format(), so some tests below 3002 // may now be redundant 3003 3004 TestFmwk.assertTrue("for001", ((new com.ibm.icu.math.BigDecimal("12.3")).format(-1,-1)).equals("12.3")); 3005 TestFmwk.assertTrue("for002", ((new com.ibm.icu.math.BigDecimal("-12.73")).format(-1,-1)).equals("-12.73")); 3006 TestFmwk.assertTrue("for003", ((new com.ibm.icu.math.BigDecimal("0.000")).format(-1,-1)).equals("0.000")); 3007 TestFmwk.assertTrue("for004", ((new com.ibm.icu.math.BigDecimal("3E+3")).format(-1,-1)).equals("3000")); 3008 TestFmwk.assertTrue("for005", ((new com.ibm.icu.math.BigDecimal("3")).format(4,-1)).equals(" 3")); 3009 TestFmwk.assertTrue("for006", ((new com.ibm.icu.math.BigDecimal("1.73")).format(4,0)).equals(" 2")); 3010 TestFmwk.assertTrue("for007", ((new com.ibm.icu.math.BigDecimal("1.73")).format(4,1)).equals(" 1.7")); 3011 TestFmwk.assertTrue("for008", ((new com.ibm.icu.math.BigDecimal("1.75")).format(4,1)).equals(" 1.8")); 3012 TestFmwk.assertTrue("for009", ((new com.ibm.icu.math.BigDecimal("0.5")).format(4,1)).equals(" 0.5")); 3013 TestFmwk.assertTrue("for010", ((new com.ibm.icu.math.BigDecimal("0.05")).format(4,1)).equals(" 0.1")); 3014 TestFmwk.assertTrue("for011", ((new com.ibm.icu.math.BigDecimal("0.04")).format(4,1)).equals(" 0.0")); 3015 TestFmwk.assertTrue("for012", ((new com.ibm.icu.math.BigDecimal("0")).format(4,0)).equals(" 0")); 3016 TestFmwk.assertTrue("for013", ((new com.ibm.icu.math.BigDecimal("0")).format(4,1)).equals(" 0.0")); 3017 TestFmwk.assertTrue("for014", ((new com.ibm.icu.math.BigDecimal("0")).format(4,2)).equals(" 0.00")); 3018 TestFmwk.assertTrue("for015", ((new com.ibm.icu.math.BigDecimal("0")).format(4,3)).equals(" 0.000")); 3019 TestFmwk.assertTrue("for016", ((new com.ibm.icu.math.BigDecimal("0")).format(4,4)).equals(" 0.0000")); 3020 TestFmwk.assertTrue("for017", ((new com.ibm.icu.math.BigDecimal("0.005")).format(4,0)).equals(" 0")); 3021 TestFmwk.assertTrue("for018", ((new com.ibm.icu.math.BigDecimal("0.005")).format(4,1)).equals(" 0.0")); 3022 TestFmwk.assertTrue("for019", ((new com.ibm.icu.math.BigDecimal("0.005")).format(4,2)).equals(" 0.01")); 3023 TestFmwk.assertTrue("for020", ((new com.ibm.icu.math.BigDecimal("0.004")).format(4,2)).equals(" 0.00")); 3024 TestFmwk.assertTrue("for021", ((new com.ibm.icu.math.BigDecimal("0.005")).format(4,3)).equals(" 0.005")); 3025 TestFmwk.assertTrue("for022", ((new com.ibm.icu.math.BigDecimal("0.005")).format(4,4)).equals(" 0.0050")); 3026 3027 TestFmwk.assertTrue("for023", ((new com.ibm.icu.math.BigDecimal("1.73")).format(4,2)).equals(" 1.73")); 3028 TestFmwk.assertTrue("for024", ((new com.ibm.icu.math.BigDecimal("1.73")).format(4,3)).equals(" 1.730")); 3029 TestFmwk.assertTrue("for025", ((new com.ibm.icu.math.BigDecimal("-.76")).format(4,1)).equals(" -0.8")); 3030 TestFmwk.assertTrue("for026", ((new com.ibm.icu.math.BigDecimal("-12.73")).format(-1,4)).equals("-12.7300")); 3031 3032 TestFmwk.assertTrue("for027", ((new com.ibm.icu.math.BigDecimal("3.03")).format(4,-1)).equals(" 3.03")); 3033 TestFmwk.assertTrue("for028", ((new com.ibm.icu.math.BigDecimal("3.03")).format(4,1)).equals(" 3.0")); 3034 TestFmwk.assertTrue("for029", ((new com.ibm.icu.math.BigDecimal("3.03")).format(4,-1,3,-1,-1,-1)).equals(" 3.03 ")); 3035 TestFmwk.assertTrue("for030", ((new com.ibm.icu.math.BigDecimal("3.03")).format(-1,-1,3,-1,-1,-1)).equals("3.03 ")); 3036 TestFmwk.assertTrue("for031", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,-1,-1,4,-1,-1)).equals("1.234573E+4")); 3037 TestFmwk.assertTrue("for032", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,-1,-1,5,-1,-1)).equals("12345.73")); 3038 TestFmwk.assertTrue("for033", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,-1,-1,6,-1,-1)).equals("12345.73")); 3039 3040 TestFmwk.assertTrue("for034", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,8,-1,3,-1,-1)).equals("1.23457300E+4")); 3041 TestFmwk.assertTrue("for035", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,7,-1,3,-1,-1)).equals("1.2345730E+4")); 3042 TestFmwk.assertTrue("for036", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,6,-1,3,-1,-1)).equals("1.234573E+4")); 3043 TestFmwk.assertTrue("for037", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,5,-1,3,-1,-1)).equals("1.23457E+4")); 3044 TestFmwk.assertTrue("for038", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,4,-1,3,-1,-1)).equals("1.2346E+4")); 3045 TestFmwk.assertTrue("for039", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,3,-1,3,-1,-1)).equals("1.235E+4")); 3046 TestFmwk.assertTrue("for040", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,2,-1,3,-1,-1)).equals("1.23E+4")); 3047 TestFmwk.assertTrue("for041", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,1,-1,3,-1,-1)).equals("1.2E+4")); 3048 TestFmwk.assertTrue("for042", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,0,-1,3,-1,-1)).equals("1E+4")); 3049 3050 TestFmwk.assertTrue("for043", ((new com.ibm.icu.math.BigDecimal("99999.99")).format(-1,6,-1,3,-1,-1)).equals("9.999999E+4")); 3051 TestFmwk.assertTrue("for044", ((new com.ibm.icu.math.BigDecimal("99999.99")).format(-1,5,-1,3,-1,-1)).equals("1.00000E+5")); 3052 TestFmwk.assertTrue("for045", ((new com.ibm.icu.math.BigDecimal("99999.99")).format(-1,2,-1,3,-1,-1)).equals("1.00E+5")); 3053 TestFmwk.assertTrue("for046", ((new com.ibm.icu.math.BigDecimal("99999.99")).format(-1,0,-1,3,-1,-1)).equals("1E+5")); 3054 TestFmwk.assertTrue("for047", ((new com.ibm.icu.math.BigDecimal("99999.99")).format(3,0,-1,3,-1,-1)).equals(" 1E+5")); 3055 3056 TestFmwk.assertTrue("for048", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,-1,2,2,-1,-1)).equals("1.234573E+04")); 3057 TestFmwk.assertTrue("for049", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,3,-1,0,-1,-1)).equals("1.235E+4")); 3058 TestFmwk.assertTrue("for050", ((new com.ibm.icu.math.BigDecimal("1.234573")).format(-1,3,-1,0,-1,-1)).equals("1.235")); 3059 TestFmwk.assertTrue("for051", ((new com.ibm.icu.math.BigDecimal("123.45")).format(-1,3,2,0,-1,-1)).equals("1.235E+02")); 3060 3061 TestFmwk.assertTrue("for052", ((new com.ibm.icu.math.BigDecimal("0.444")).format(-1,0)).equals("0")); 3062 TestFmwk.assertTrue("for053", ((new com.ibm.icu.math.BigDecimal("-0.444")).format(-1,0)).equals("0")); 3063 TestFmwk.assertTrue("for054", ((new com.ibm.icu.math.BigDecimal("0.4")).format(-1,0)).equals("0")); 3064 TestFmwk.assertTrue("for055", ((new com.ibm.icu.math.BigDecimal("-0.4")).format(-1,0)).equals("0")); 3065 3066 eng = com.ibm.icu.math.MathContext.ENGINEERING; 3067 sci = com.ibm.icu.math.MathContext.SCIENTIFIC; 3068 TestFmwk.assertTrue("for060", ((new com.ibm.icu.math.BigDecimal("1234.5")).format(-1,3,2,0,eng,-1)).equals("1.235E+03")); 3069 TestFmwk.assertTrue("for061", ((new com.ibm.icu.math.BigDecimal("12345")).format(-1,3,3,0,eng,-1)).equals("12.345E+003")); 3070 TestFmwk.assertTrue("for062", ((new com.ibm.icu.math.BigDecimal("12345")).format(-1,3,3,0,sci,-1)).equals("1.235E+004")); 3071 TestFmwk.assertTrue("for063", ((new com.ibm.icu.math.BigDecimal("1234.5")).format(4,3,2,0,eng,-1)).equals(" 1.235E+03")); 3072 TestFmwk.assertTrue("for064", ((new com.ibm.icu.math.BigDecimal("12345")).format(5,3,3,0,eng,-1)).equals(" 12.345E+003")); 3073 TestFmwk.assertTrue("for065", ((new com.ibm.icu.math.BigDecimal("12345")).format(6,3,3,0,sci,-1)).equals(" 1.235E+004")); 3074 3075 TestFmwk.assertTrue("for066", ((new com.ibm.icu.math.BigDecimal("1.2345")).format(-1,3,2,0,-1,-1)).equals("1.235 ")); 3076 TestFmwk.assertTrue("for067", ((new com.ibm.icu.math.BigDecimal("12345.73")).format(-1,-1,3,6,-1,-1)).equals("12345.73 ")); 3077 TestFmwk.assertTrue("for068", ((new com.ibm.icu.math.BigDecimal("12345e+5")).format(-1,0)).equals("1234500000")); 3078 TestFmwk.assertTrue("for069", ((new com.ibm.icu.math.BigDecimal("12345e+5")).format(-1,1)).equals("1234500000.0")); 3079 TestFmwk.assertTrue("for070", ((new com.ibm.icu.math.BigDecimal("12345e+5")).format(-1,2)).equals("1234500000.00")); 3080 TestFmwk.assertTrue("for071", ((new com.ibm.icu.math.BigDecimal("12345e+5")).format(-1,3)).equals("1234500000.000")); 3081 TestFmwk.assertTrue("for072", ((new com.ibm.icu.math.BigDecimal("12345e+5")).format(-1,4)).equals("1234500000.0000")); 3082 3083 // some from ANSI Dallas [Nov 1998] 3084 TestFmwk.assertTrue("for073", ((new com.ibm.icu.math.BigDecimal("99.999")).format(-1,2,-1,2,-1,-1)).equals("100.00")); 3085 TestFmwk.assertTrue("for074", ((new com.ibm.icu.math.BigDecimal("0.99999")).format(-1,4,2,2,-1,-1)).equals("1.0000 ")); 3086 3087 // try some rounding modes [default ROUND_HALF_UP widely tested above] 3088 // the first few also tests that defaults are accepted for the others 3089 d04 = new com.ibm.icu.math.BigDecimal("0.04"); 3090 d05 = new com.ibm.icu.math.BigDecimal("0.05"); 3091 d06 = new com.ibm.icu.math.BigDecimal("0.06"); 3092 d15 = new com.ibm.icu.math.BigDecimal("0.15"); 3093 TestFmwk.assertTrue("for080", (d05.format(-1, 1)).equals("0.1")); 3094 TestFmwk.assertTrue("for081", (d05.format(-1, 1, -1, -1, -1, com.ibm.icu.math.MathContext.ROUND_HALF_UP)).equals("0.1")); 3095 TestFmwk.assertTrue("for082", (d05.format(-1, 1, -1, -1, -1, -1)).equals("0.1")); 3096 TestFmwk.assertTrue("for083", (d05.format(-1, -1, -1, -1, -1, -1)).equals("0.05")); 3097 TestFmwk.assertTrue("for084", (d05.format(-1, -1)).equals("0.05")); 3098 try { 3099 d05.format(-1, -1, -1, -1, -1, 30); // bad mode 3100 flag = false; // shouldn't get here 3101 } catch (java.lang.IllegalArgumentException $94) { 3102 iae = $94; 3103 flag = (iae.getMessage()).equals("Bad argument 6 to format: 30"); 3104 } 3105 TestFmwk.assertTrue("for085", flag); 3106 3107 TestFmwk.assertTrue("for090", (d04.format(-1,1)).equals("0.0")); 3108 TestFmwk.assertTrue("for091", (d06.format(-1,1)).equals("0.1")); 3109 TestFmwk.assertTrue("for092", (d04.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN)).equals("0.0")); 3110 TestFmwk.assertTrue("for093", (d05.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN)).equals("0.0")); 3111 TestFmwk.assertTrue("for094", (d06.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN)).equals("0.1")); 3112 3113 TestFmwk.assertTrue("for095", (d04.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.0")); 3114 TestFmwk.assertTrue("for096", (d05.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.0")); 3115 TestFmwk.assertTrue("for097", (d06.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.1")); 3116 TestFmwk.assertTrue("for098", (d15.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.2")); 3117 d050 = new com.ibm.icu.math.BigDecimal("0.050"); 3118 d150 = new com.ibm.icu.math.BigDecimal("0.150"); 3119 TestFmwk.assertTrue("for099", (d050.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.0")); 3120 TestFmwk.assertTrue("for100", (d150.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.2")); 3121 m050 = new com.ibm.icu.math.BigDecimal("-0.050"); 3122 m150 = new com.ibm.icu.math.BigDecimal("-0.150"); 3123 TestFmwk.assertTrue("for101", (m050.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.0")); 3124 TestFmwk.assertTrue("for102", (m150.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN)).equals("-0.2")); 3125 d051 = new com.ibm.icu.math.BigDecimal("0.051"); 3126 d151 = new com.ibm.icu.math.BigDecimal("0.151"); 3127 TestFmwk.assertTrue("for103", (d051.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.1")); 3128 TestFmwk.assertTrue("for104", (d151.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN)).equals("0.2")); 3129 3130 TestFmwk.assertTrue("for105", (m050.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_CEILING)).equals("0.0")); 3131 TestFmwk.assertTrue("for106", (m150.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_CEILING)).equals("-0.1")); 3132 TestFmwk.assertTrue("for107", (d050.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_CEILING)).equals("0.1")); 3133 TestFmwk.assertTrue("for108", (d150.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_CEILING)).equals("0.2")); 3134 3135 TestFmwk.assertTrue("for109", (m050.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_FLOOR)).equals("-0.1")); 3136 TestFmwk.assertTrue("for110", (m150.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_FLOOR)).equals("-0.2")); 3137 TestFmwk.assertTrue("for111", (d050.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_FLOOR)).equals("0.0")); 3138 TestFmwk.assertTrue("for112", (d150.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_FLOOR)).equals("0.1")); 3139 3140 TestFmwk.assertTrue("for113", (m050.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UP)).equals("-0.1")); 3141 TestFmwk.assertTrue("for114", (m150.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UP)).equals("-0.2")); 3142 TestFmwk.assertTrue("for115", (d050.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UP)).equals("0.1")); 3143 TestFmwk.assertTrue("for116", (d150.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UP)).equals("0.2")); 3144 3145 TestFmwk.assertTrue("for117", (m050.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_DOWN)).equals("0.0")); 3146 TestFmwk.assertTrue("for118", (m150.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_DOWN)).equals("-0.1")); 3147 TestFmwk.assertTrue("for119", (d050.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_DOWN)).equals("0.0")); 3148 TestFmwk.assertTrue("for120", (d150.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_DOWN)).equals("0.1")); 3149 3150 d000 = new com.ibm.icu.math.BigDecimal("0.000"); 3151 d500 = new com.ibm.icu.math.BigDecimal("0.500"); 3152 TestFmwk.assertTrue("for121", (d000.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.0")); 3153 TestFmwk.assertTrue("for122", (d000.format(-1,2,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.00")); 3154 TestFmwk.assertTrue("for123", (d000.format(-1,3,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.000")); 3155 try { // this should trap.. 3156 d050.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UNNECESSARY); 3157 flag = false; 3158 } catch (java.lang.ArithmeticException $95) { 3159 ae = $95; 3160 flag = (ae.getMessage()).equals("Rounding necessary"); 3161 } 3162 TestFmwk.assertTrue("for124", flag); 3163 TestFmwk.assertTrue("for125", (d050.format(-1,2,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.05")); 3164 TestFmwk.assertTrue("for126", (d050.format(-1,3,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.050")); 3165 TestFmwk.assertTrue("for127", (d500.format(-1,1,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.5")); 3166 TestFmwk.assertTrue("for128", (d500.format(-1,2,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.50")); 3167 TestFmwk.assertTrue("for129", (d500.format(-1,3,-1,-1,-1,com.ibm.icu.math.MathContext.ROUND_UNNECESSARY)).equals("0.500")); 3168 3169 // bad negs -- 3170 try { 3171 d050.format(-2, -1, -1, -1, -1, -1); 3172 flag = false; 3173 } catch (java.lang.IllegalArgumentException $96) { 3174 flag = true; 3175 } 3176 TestFmwk.assertTrue("for131", flag); 3177 try { 3178 d050.format(-1, -2, -1, -1, -1, -1); 3179 flag = false; 3180 } catch (java.lang.IllegalArgumentException $97) { 3181 flag = true; 3182 } 3183 TestFmwk.assertTrue("for132", flag); 3184 try { 3185 d050.format(-1, -1, -2, -1, -1, -1); 3186 flag = false; 3187 } catch (java.lang.IllegalArgumentException $98) { 3188 flag = true; 3189 } 3190 TestFmwk.assertTrue("for133", flag); 3191 try { 3192 d050.format(-1, -1, -1, -2, -1, -1); 3193 flag = false; 3194 } catch (java.lang.IllegalArgumentException $99) { 3195 flag = true; 3196 } 3197 TestFmwk.assertTrue("for134", flag); 3198 try { 3199 d050.format(-1, -1, -1, -1, -2, -1); 3200 flag = false; 3201 } catch (java.lang.IllegalArgumentException $100) { 3202 flag = true; 3203 } 3204 TestFmwk.assertTrue("for135", flag); 3205 try { 3206 d050.format(-1, -1, -1, -1, -1, -2); 3207 flag = false; 3208 } catch (java.lang.IllegalArgumentException $101) { 3209 flag = true; 3210 } 3211 TestFmwk.assertTrue("for136", flag); 3212 } 3213 3214 /* ----------------------------------------------------------------- */ 3215 3216 /** Test the {@link com.ibm.icu.math.BigDecimal#hashCode} method. */ 3217 3218 @Test 3219 public void diaghashcode() { 3220 java.lang.String hs; 3221 com.ibm.icu.math.BigDecimal d; 3222 hs = "27827817"; 3223 d = new com.ibm.icu.math.BigDecimal(hs); 3224 TestFmwk.assertTrue("has001", (d.hashCode()) == (hs.hashCode())); 3225 hs = "1.265E+200"; 3226 d = new com.ibm.icu.math.BigDecimal(hs); 3227 TestFmwk.assertTrue("has002", (d.hashCode()) == (hs.hashCode())); 3228 hs = "126.5E+200"; 3229 d = new com.ibm.icu.math.BigDecimal(hs); 3230 TestFmwk.assertTrue("has003", (d.hashCode()) != (hs.hashCode())); 3231 } 3232 3233 /* ----------------------------------------------------------------- */ 3234 3235 /** Test the {@link com.ibm.icu.math.BigDecimal#intValue} method. */ 3236 3237 @Test 3238 public void diagintvalue() { 3239 boolean flag = false; 3240 java.lang.String v = null; 3241 java.lang.ArithmeticException ae = null; 3242 java.lang.String badstrings[]; 3243 int i = 0; 3244 java.lang.String norm = null; 3245 com.ibm.icu.math.BigDecimal dimax; 3246 com.ibm.icu.math.BigDecimal num = null; 3247 com.ibm.icu.math.BigDecimal dv = null; 3248 com.ibm.icu.math.BigDecimal dimin; 3249 3250 // intValue -- 3251 3252 TestFmwk.assertTrue("inv001", imin==((new com.ibm.icu.math.BigDecimal(imin)).intValue())); 3253 TestFmwk.assertTrue("inv002", ((99))==((new com.ibm.icu.math.BigDecimal("99")).intValue())); 3254 TestFmwk.assertTrue("inv003", ((1))==((new com.ibm.icu.math.BigDecimal("1")).intValue())); 3255 TestFmwk.assertTrue("inv004", ((0))==((new com.ibm.icu.math.BigDecimal("0")).intValue())); 3256 TestFmwk.assertTrue("inv005", ((-1))==((new com.ibm.icu.math.BigDecimal("-1")).intValue())); 3257 TestFmwk.assertTrue("inv006", ((-99))==((new com.ibm.icu.math.BigDecimal("-99")).intValue())); 3258 TestFmwk.assertTrue("inv007", imax==((new com.ibm.icu.math.BigDecimal(imax)).intValue())); 3259 TestFmwk.assertTrue("inv008", ((5))==((new com.ibm.icu.math.BigDecimal("5.0")).intValue())); 3260 TestFmwk.assertTrue("inv009", ((5))==((new com.ibm.icu.math.BigDecimal("5.3")).intValue())); 3261 TestFmwk.assertTrue("inv010", ((5))==((new com.ibm.icu.math.BigDecimal("5.5")).intValue())); 3262 TestFmwk.assertTrue("inv011", ((5))==((new com.ibm.icu.math.BigDecimal("5.7")).intValue())); 3263 TestFmwk.assertTrue("inv012", ((5))==((new com.ibm.icu.math.BigDecimal("5.9")).intValue())); 3264 TestFmwk.assertTrue("inv013", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.0")).intValue())); 3265 TestFmwk.assertTrue("inv014", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.3")).intValue())); 3266 TestFmwk.assertTrue("inv015", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.5")).intValue())); 3267 TestFmwk.assertTrue("inv016", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.7")).intValue())); 3268 TestFmwk.assertTrue("inv017", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.9")).intValue())); 3269 TestFmwk.assertTrue("inv018", ((new com.ibm.icu.math.BigDecimal("88888888888")).intValue())==(-1305424328)); // ugh 3270 TestFmwk.assertTrue("inv019", ((new com.ibm.icu.math.BigDecimal("-88888888888")).intValue())==1305424328); // ugh 3271 TestFmwk.assertTrue("inv020", ((imin))==((new com.ibm.icu.math.BigDecimal((((long)imax))+1)).intValue())); 3272 TestFmwk.assertTrue("inv021", ((imax))==((new com.ibm.icu.math.BigDecimal((((long)imin))-1)).intValue())); 3273 3274 // intValueExact -- 3275 3276 TestFmwk.assertTrue("inv101", imin==((new com.ibm.icu.math.BigDecimal(imin)).intValueExact())); 3277 TestFmwk.assertTrue("inv102", ((99))==((new com.ibm.icu.math.BigDecimal("99")).intValue())); 3278 TestFmwk.assertTrue("inv103", ((1))==((new com.ibm.icu.math.BigDecimal("1")).intValue())); 3279 TestFmwk.assertTrue("inv104", ((0))==((new com.ibm.icu.math.BigDecimal("0")).intValue())); 3280 TestFmwk.assertTrue("inv105", ((-1))==((new com.ibm.icu.math.BigDecimal("-1")).intValue())); 3281 TestFmwk.assertTrue("inv106", ((-99))==((new com.ibm.icu.math.BigDecimal("-99")).intValue())); 3282 TestFmwk.assertTrue("inv107", imax==((new com.ibm.icu.math.BigDecimal(imax)).intValue())); 3283 TestFmwk.assertTrue("inv108", ((5))==((new com.ibm.icu.math.BigDecimal("5.0")).intValue())); 3284 TestFmwk.assertTrue("inv109", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.0")).intValue())); 3285 TestFmwk.assertTrue("inv110", imax==((new com.ibm.icu.math.BigDecimal(imax)).intValueExact())); 3286 3287 try { 3288 v = "-88588688888"; 3289 (new com.ibm.icu.math.BigDecimal(v)).intValueExact(); 3290 flag = false; 3291 } catch (java.lang.ArithmeticException $102) { 3292 ae = $102; 3293 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 3294 } 3295 TestFmwk.assertTrue("inv200", flag); 3296 3297 // this one could raise either overflow or bad decimal part 3298 try { 3299 v = "88088818888.00001"; 3300 (new com.ibm.icu.math.BigDecimal(v)).intValueExact(); 3301 flag = false; 3302 } catch (java.lang.ArithmeticException $103) { 3303 flag = true; 3304 } 3305 TestFmwk.assertTrue("inv201", flag); 3306 3307 // 1999.10.28: the testcases marked '*' failed 3308 badstrings = new java.lang.String[] { 3309 "12345678901", 3310 (new com.ibm.icu.math.BigDecimal(imax)).add(one).toString(), 3311 (new com.ibm.icu.math.BigDecimal(imin)).subtract(one) 3312 .toString(), 3313 "3731367293", 3314 "4731367293", 3315 "5731367293", 3316 "6731367293", 3317 "7731367293", 3318 "8731367293", 3319 "9731367293", 3320 "-3731367293", 3321 "-4731367293", 3322 "-5731367293", 3323 "-6731367293", 3324 "-7731367293", 3325 "-8731367293", 3326 "-9731367293", 3327 (new com.ibm.icu.math.BigDecimal(imin)).multiply(two) 3328 .toString(), 3329 (new com.ibm.icu.math.BigDecimal(imax)).multiply(two) 3330 .toString(), 3331 (new com.ibm.icu.math.BigDecimal(imin)).multiply(ten) 3332 .toString(), 3333 (new com.ibm.icu.math.BigDecimal(imax)).multiply(ten) 3334 .toString(), "4731367293", "4831367293", "4931367293", 3335 "5031367293", "5131367293", "5231367293", "5331367293", 3336 "5431367293", "5531367293", "5631367293", "5731367293", 3337 "5831367293", "5931367293", "6031367293", "6131367293", 3338 "6231367293", "6331367293", "6431367293", "6531367293", 3339 "6631367293", "6731367293", "2200000000", "2300000000", 3340 "2400000000", "2500000000", "2600000000", "2700000000", 3341 "2800000000", "2900000000", "-2200000000", "-2300000000", 3342 "-2400000000", "-2500000000", "-2600000000", "-2700000000", 3343 "-2800000000", "-2900000000", "25E+8", "-25E+8", "-12345678901" }; // 220 3344 // 221 3345 // 222 3346 // 223 3347 // 224 3348 // 225 * 3349 // 226 3350 // 227 3351 // 228 3352 // 229 * 3353 // 230 3354 // 231 3355 // 232 * 3356 // 233 3357 // 234 3358 // 235 3359 // 236 * 3360 // 237 3361 // 238 3362 // 239 3363 // 240 3364 // 241 3365 // 242 * 3366 // 243 * 3367 // 244 * 3368 // 245 * 3369 // 246 * 3370 // 247 * 3371 // 248 * 3372 // 249 * 3373 // 250 * 3374 // 251 * 3375 // 252 * 3376 // 253 * 3377 // 254 * 3378 // 255 * 3379 // 256 * 3380 // 257 * 3381 // 258 * 3382 // 259 3383 // 260 3384 // 261 3385 // 262 3386 // 263 3387 // 264 3388 // 265 3389 // 266 3390 // 267 3391 // 268 3392 // 269 3393 // 270 3394 // 271 3395 // 272 3396 // 273 3397 // 274 3398 // 275 3399 // 276 3400 // 277 3401 // 278 3402 // 279 3403 // 280 3404 { 3405 int $104 = badstrings.length; 3406 i = 0; 3407 for (; $104 > 0; $104--, i++) { 3408 try { 3409 v = badstrings[i]; 3410 (new com.ibm.icu.math.BigDecimal(v)).intValueExact(); 3411 flag = false; 3412 } catch (java.lang.ArithmeticException $105) { 3413 ae = $105; 3414 norm = (new com.ibm.icu.math.BigDecimal(v)).toString(); 3415 flag = (ae.getMessage()).equals("Conversion overflow:" 3416 + " " + norm); 3417 } 3418 TestFmwk.assertTrue("inv" + (220 + i), flag); 3419 } 3420 }/* i */ 3421 3422 // now slip in some single bits... 3423 dimax = new com.ibm.icu.math.BigDecimal(imax); 3424 { 3425 i = 0; 3426 for (; i <= 49; i++) { 3427 try { 3428 num = two.pow(new com.ibm.icu.math.BigDecimal(i), mc50); 3429 dv = dimax.add(num, mc50); 3430 dv.intValueExact(); 3431 flag = false; 3432 } catch (java.lang.ArithmeticException $106) { 3433 ae = $106; 3434 norm = dv.toString(); 3435 flag = (ae.getMessage()).equals("Conversion overflow:" 3436 + " " + norm); 3437 } 3438 TestFmwk.assertTrue("inv" + (300 + i), flag); 3439 } 3440 }/* i */ 3441 dimin = new com.ibm.icu.math.BigDecimal(imin); 3442 { 3443 i = 50; 3444 for (; i <= 99; i++) { 3445 try { 3446 num = two.pow(new com.ibm.icu.math.BigDecimal(i), mc50); 3447 dv = dimin.subtract(num, mc50); 3448 dv.intValueExact(); 3449 flag = false; 3450 } catch (java.lang.ArithmeticException $107) { 3451 ae = $107; 3452 norm = dv.toString(); 3453 flag = (ae.getMessage()).equals("Conversion overflow:" 3454 + " " + norm); 3455 } 3456 TestFmwk.assertTrue("inv" + (300 + i), flag); 3457 } 3458 }/* i */ 3459 3460 // the following should all raise bad-decimal-part exceptions 3461 badstrings = new java.lang.String[] { "0.09", "0.9", "0.01", "0.1", 3462 "-0.01", "-0.1", "1.01", "-1.01", "-1.1", "-111.111", 3463 "+111.111", "1.09", "1.05", "1.04", "1.99", "1.9", "1.5", 3464 "1.4", "-1.09", "-1.05", "-1.04", "-1.99", "-1.9", "-1.5", 3465 "-1.4", "1E-1000", "-1E-1000", "11E-1", "1.5" }; // 400-403 3466 // 404-407 3467 // 408-411 3468 // 412-416 3469 // 417-420 3470 // 421-424 3471 // 425-428 3472 3473 { 3474 int $108 = badstrings.length; 3475 i = 0; 3476 for (; $108 > 0; $108--, i++) { 3477 try { 3478 v = badstrings[i]; 3479 (new com.ibm.icu.math.BigDecimal(v)).intValueExact(); 3480 flag = false; 3481 } catch (java.lang.ArithmeticException $109) { 3482 ae = $109; 3483 norm = (new com.ibm.icu.math.BigDecimal(v)).toString(); 3484 flag = (ae.getMessage()).equals("Decimal part non-zero:" 3485 + " " + norm); 3486 } 3487 TestFmwk.assertTrue("inv" + (400 + i), flag); 3488 } 3489 }/* i */ 3490 } 3491 3492 /* ----------------------------------------------------------------- */ 3493 3494 /** Test the {@link com.ibm.icu.math.BigDecimal#longValue} method. */ 3495 3496 @Test 3497 public void diaglongvalue() { 3498 boolean flag = false; 3499 java.lang.String v = null; 3500 java.lang.ArithmeticException ae = null; 3501 java.lang.String badstrings[]; 3502 int i = 0; 3503 java.lang.String norm = null; 3504 com.ibm.icu.math.BigDecimal dlmax; 3505 com.ibm.icu.math.BigDecimal num = null; 3506 com.ibm.icu.math.BigDecimal dv = null; 3507 com.ibm.icu.math.BigDecimal dlmin; 3508 3509 // longValue -- 3510 3511 TestFmwk.assertTrue("lov001", lmin==((new com.ibm.icu.math.BigDecimal(lmin)).longValue())); 3512 TestFmwk.assertTrue("lov002", ((99))==((new com.ibm.icu.math.BigDecimal("99")).longValue())); 3513 TestFmwk.assertTrue("lov003", ((1))==((new com.ibm.icu.math.BigDecimal("1")).longValue())); 3514 TestFmwk.assertTrue("lov004", ((0))==((new com.ibm.icu.math.BigDecimal("0")).longValue())); 3515 TestFmwk.assertTrue("lov005", ((-1))==((new com.ibm.icu.math.BigDecimal("-1")).longValue())); 3516 TestFmwk.assertTrue("lov006", ((-99))==((new com.ibm.icu.math.BigDecimal("-99")).longValue())); 3517 TestFmwk.assertTrue("lov007", lmax==((new com.ibm.icu.math.BigDecimal(lmax)).longValue())); 3518 TestFmwk.assertTrue("lov008", ((5))==((new com.ibm.icu.math.BigDecimal("5.0")).longValue())); 3519 TestFmwk.assertTrue("lov009", ((5))==((new com.ibm.icu.math.BigDecimal("5.3")).longValue())); 3520 TestFmwk.assertTrue("lov010", ((5))==((new com.ibm.icu.math.BigDecimal("5.5")).longValue())); 3521 TestFmwk.assertTrue("lov011", ((5))==((new com.ibm.icu.math.BigDecimal("5.7")).longValue())); 3522 TestFmwk.assertTrue("lov012", ((5))==((new com.ibm.icu.math.BigDecimal("5.9")).longValue())); 3523 TestFmwk.assertTrue("lov013", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.0")).longValue())); 3524 TestFmwk.assertTrue("lov014", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.3")).longValue())); 3525 TestFmwk.assertTrue("lov015", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.5")).longValue())); 3526 TestFmwk.assertTrue("lov016", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.7")).longValue())); 3527 TestFmwk.assertTrue("lov017", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.9")).longValue())); 3528 TestFmwk.assertTrue("lov018", ((new com.ibm.icu.math.BigDecimal("888888888899999999998")).longValue())==3445173361941522430L); // ugh 3529 TestFmwk.assertTrue("lov019", ((new com.ibm.icu.math.BigDecimal("-888888888899999999998")).longValue())==(-3445173361941522430L)); // ugh 3530 3531 // longValueExact -- 3532 3533 TestFmwk.assertTrue("lov101", lmin==((new com.ibm.icu.math.BigDecimal(lmin)).longValue())); 3534 TestFmwk.assertTrue("lov102", ((99))==((new com.ibm.icu.math.BigDecimal("99")).longValue())); 3535 TestFmwk.assertTrue("lov103", ((1))==((new com.ibm.icu.math.BigDecimal("1")).longValue())); 3536 TestFmwk.assertTrue("lov104", ((0))==((new com.ibm.icu.math.BigDecimal("0")).longValue())); 3537 TestFmwk.assertTrue("lov105", ((-1))==((new com.ibm.icu.math.BigDecimal("-1")).longValue())); 3538 TestFmwk.assertTrue("lov106", ((-99))==((new com.ibm.icu.math.BigDecimal("-99")).longValue())); 3539 TestFmwk.assertTrue("lov107", lmax==((new com.ibm.icu.math.BigDecimal(lmax)).longValue())); 3540 TestFmwk.assertTrue("lov108", ((5))==((new com.ibm.icu.math.BigDecimal("5.0")).longValue())); 3541 TestFmwk.assertTrue("lov109", ((-5))==((new com.ibm.icu.math.BigDecimal("-5.0")).longValue())); 3542 3543 try { 3544 v = "-888888888899999999998"; 3545 (new com.ibm.icu.math.BigDecimal(v)).longValueExact(); 3546 flag = false; 3547 } catch (java.lang.ArithmeticException $110) { 3548 ae = $110; 3549 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 3550 } 3551 TestFmwk.assertTrue("lov200", flag); 3552 try { 3553 v = "88888887487487479488888"; 3554 (new com.ibm.icu.math.BigDecimal(v)).longValueExact(); 3555 flag = false; 3556 } catch (java.lang.ArithmeticException $111) { 3557 ae = $111; 3558 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 3559 } 3560 TestFmwk.assertTrue("lov201", flag); 3561 try { 3562 v = "1.5"; 3563 (new com.ibm.icu.math.BigDecimal(v)).longValueExact(); 3564 flag = false; 3565 } catch (java.lang.ArithmeticException $112) { 3566 ae = $112; 3567 flag = (ae.getMessage()).equals("Decimal part non-zero:" + " " + v); 3568 } 3569 TestFmwk.assertTrue("lov202", flag); 3570 3571 badstrings = new java.lang.String[] { 3572 "1234567890110987654321", 3573 "-1234567890110987654321", 3574 (new com.ibm.icu.math.BigDecimal(lmax)).add(one).toString(), 3575 (new com.ibm.icu.math.BigDecimal(lmin)).subtract(one) 3576 .toString(), 3577 (new com.ibm.icu.math.BigDecimal(lmin)).multiply(two) 3578 .toString(), 3579 (new com.ibm.icu.math.BigDecimal(lmax)).multiply(two) 3580 .toString(), 3581 (new com.ibm.icu.math.BigDecimal(lmin)).multiply(ten) 3582 .toString(), 3583 (new com.ibm.icu.math.BigDecimal(lmax)).multiply(ten) 3584 .toString(), "9223372036854775818", 3585 "9323372036854775818", "9423372036854775818", 3586 "9523372036854775818", "9623372036854775818", 3587 "9723372036854775818", "9823372036854775818", 3588 "9923372036854775818", "-9223372036854775818", 3589 "-9323372036854775818", "-9423372036854775818", 3590 "-9523372036854775818", "-9623372036854775818", 3591 "-9723372036854775818", "-9823372036854775818", 3592 "-9923372036854775818", "12345678901234567890" }; // 220 3593 // 221 3594 // 222 3595 // 223 3596 // 224 3597 // 225 3598 // 226 3599 // 227 3600 // 228 3601 // 229 3602 // 230 3603 // 231 3604 // 232 3605 // 233 3606 // 234 3607 // 235 3608 // 236 3609 // 237 3610 // 238 3611 // 239 3612 // 240 3613 // 241 3614 // 242 3615 // 243 3616 // 244 3617 { 3618 int $113 = badstrings.length; 3619 i = 0; 3620 for (; $113 > 0; $113--, i++) { 3621 try { 3622 v = badstrings[i]; 3623 (new com.ibm.icu.math.BigDecimal(v)).longValueExact(); 3624 flag = false; 3625 } catch (java.lang.ArithmeticException $114) { 3626 ae = $114; 3627 norm = (new com.ibm.icu.math.BigDecimal(v)).toString(); 3628 flag = (ae.getMessage()).equals("Conversion overflow:" 3629 + " " + norm); 3630 } 3631 TestFmwk.assertTrue("lov" + (220 + i), flag); 3632 } 3633 }/* i */ 3634 3635 // now slip in some single bits... 3636 dlmax = new com.ibm.icu.math.BigDecimal(lmax); 3637 { 3638 i = 0; 3639 for (; i <= 99; i++) { 3640 try { 3641 num = two.pow(new com.ibm.icu.math.BigDecimal(i), mc50); 3642 dv = dlmax.add(num, mc50); 3643 dv.longValueExact(); 3644 flag = false; 3645 } catch (java.lang.ArithmeticException $115) { 3646 ae = $115; 3647 norm = dv.toString(); 3648 flag = (ae.getMessage()).equals("Conversion overflow:" 3649 + " " + norm); 3650 } 3651 TestFmwk.assertTrue("lov" + (300 + i), flag); 3652 } 3653 }/* i */ 3654 dlmin = new com.ibm.icu.math.BigDecimal(lmin); 3655 { 3656 i = 0; 3657 for (; i <= 99; i++) { 3658 try { 3659 num = two.pow(new com.ibm.icu.math.BigDecimal(i), mc50); 3660 dv = dlmin.subtract(num, mc50); 3661 dv.longValueExact(); 3662 flag = false; 3663 } catch (java.lang.ArithmeticException $116) { 3664 ae = $116; 3665 norm = dv.toString(); 3666 flag = (ae.getMessage()).equals("Conversion overflow:" 3667 + " " + norm); 3668 } 3669 TestFmwk.assertTrue("lov" + (400 + i), flag); 3670 } 3671 }/* i */ 3672 } 3673 3674 /* ----------------------------------------------------------------- */ 3675 3676 /** Test the {@link com.ibm.icu.math.BigDecimal#movePointLeft} method. */ 3677 3678 @Test 3679 public void diagmovepointleft() { 3680 TestFmwk.assertTrue("mpl001", ((new com.ibm.icu.math.BigDecimal("-1")).movePointLeft(-10).toString()).equals("-10000000000")); 3681 TestFmwk.assertTrue("mpl002", ((new com.ibm.icu.math.BigDecimal("-1")).movePointLeft(-5).toString()).equals("-100000")); 3682 TestFmwk.assertTrue("mpl003", ((new com.ibm.icu.math.BigDecimal("-1")).movePointLeft(-1).toString()).equals("-10")); 3683 TestFmwk.assertTrue("mpl004", ((new com.ibm.icu.math.BigDecimal("-1")).movePointLeft(0).toString()).equals("-1")); 3684 TestFmwk.assertTrue("mpl005", ((new com.ibm.icu.math.BigDecimal("-1")).movePointLeft(+1).toString()).equals("-0.1")); 3685 TestFmwk.assertTrue("mpl006", ((new com.ibm.icu.math.BigDecimal("-1")).movePointLeft(+5).toString()).equals("-0.00001")); 3686 TestFmwk.assertTrue("mpl007", ((new com.ibm.icu.math.BigDecimal("-1")).movePointLeft(+10).toString()).equals("-0.0000000001")); 3687 3688 TestFmwk.assertTrue("mpl010", ((new com.ibm.icu.math.BigDecimal("0")).movePointLeft(-10).toString()).equals("0")); 3689 TestFmwk.assertTrue("mpl010", ((new com.ibm.icu.math.BigDecimal("0")).movePointLeft(-5).toString()).equals("0")); 3690 TestFmwk.assertTrue("mpl010", ((new com.ibm.icu.math.BigDecimal("0")).movePointLeft(-1).toString()).equals("0")); 3691 TestFmwk.assertTrue("mpl010", ((new com.ibm.icu.math.BigDecimal("0")).movePointLeft(0).toString()).equals("0")); 3692 TestFmwk.assertTrue("mpl010", ((new com.ibm.icu.math.BigDecimal("0")).movePointLeft(+1).toString()).equals("0.0")); 3693 TestFmwk.assertTrue("mpl010", ((new com.ibm.icu.math.BigDecimal("0")).movePointLeft(+5).toString()).equals("0.00000")); 3694 TestFmwk.assertTrue("mpl010", ((new com.ibm.icu.math.BigDecimal("0")).movePointLeft(+10).toString()).equals("0.0000000000")); 3695 3696 TestFmwk.assertTrue("mpl020", ((new com.ibm.icu.math.BigDecimal("+1")).movePointLeft(-10).toString()).equals("10000000000")); 3697 TestFmwk.assertTrue("mpl021", ((new com.ibm.icu.math.BigDecimal("+1")).movePointLeft(-5).toString()).equals("100000")); 3698 TestFmwk.assertTrue("mpl022", ((new com.ibm.icu.math.BigDecimal("+1")).movePointLeft(-1).toString()).equals("10")); 3699 TestFmwk.assertTrue("mpl023", ((new com.ibm.icu.math.BigDecimal("+1")).movePointLeft(0).toString()).equals("1")); 3700 TestFmwk.assertTrue("mpl024", ((new com.ibm.icu.math.BigDecimal("+1")).movePointLeft(+1).toString()).equals("0.1")); 3701 TestFmwk.assertTrue("mpl025", ((new com.ibm.icu.math.BigDecimal("+1")).movePointLeft(+5).toString()).equals("0.00001")); 3702 TestFmwk.assertTrue("mpl026", ((new com.ibm.icu.math.BigDecimal("+1")).movePointLeft(+10).toString()).equals("0.0000000001")); 3703 3704 TestFmwk.assertTrue("mpl030", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointLeft(-10).toString()).equals("50000000000")); 3705 TestFmwk.assertTrue("mpl031", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointLeft(-5).toString()).equals("500000")); 3706 TestFmwk.assertTrue("mpl032", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointLeft(-1).toString()).equals("50")); 3707 TestFmwk.assertTrue("mpl033", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointLeft(0).toString()).equals("5")); 3708 TestFmwk.assertTrue("mpl034", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointLeft(+1).toString()).equals("0.5")); 3709 TestFmwk.assertTrue("mpl035", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointLeft(+5).toString()).equals("0.00005")); 3710 TestFmwk.assertTrue("mpl036", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointLeft(+10).toString()).equals("0.0000000005")); 3711 } 3712 3713 /* ----------------------------------------------------------------- */ 3714 3715 /** Test the {@link com.ibm.icu.math.BigDecimal#movePointRight} method. */ 3716 3717 @Test 3718 public void diagmovepointright() { 3719 TestFmwk.assertTrue("mpr001", ((new com.ibm.icu.math.BigDecimal("-1")).movePointRight(+10).toString()).equals("-10000000000")); 3720 TestFmwk.assertTrue("mpr002", ((new com.ibm.icu.math.BigDecimal("-1")).movePointRight(+5).toString()).equals("-100000")); 3721 TestFmwk.assertTrue("mpr003", ((new com.ibm.icu.math.BigDecimal("-1")).movePointRight(+1).toString()).equals("-10")); 3722 TestFmwk.assertTrue("mpr004", ((new com.ibm.icu.math.BigDecimal("-1")).movePointRight(0).toString()).equals("-1")); 3723 TestFmwk.assertTrue("mpr005", ((new com.ibm.icu.math.BigDecimal("-1")).movePointRight(-1).toString()).equals("-0.1")); 3724 TestFmwk.assertTrue("mpr006", ((new com.ibm.icu.math.BigDecimal("-1")).movePointRight(-5).toString()).equals("-0.00001")); 3725 TestFmwk.assertTrue("mpr007", ((new com.ibm.icu.math.BigDecimal("-1")).movePointRight(-10).toString()).equals("-0.0000000001")); 3726 3727 TestFmwk.assertTrue("mpr010", ((new com.ibm.icu.math.BigDecimal("0")).movePointRight(+10).toString()).equals("0")); 3728 TestFmwk.assertTrue("mpr011", ((new com.ibm.icu.math.BigDecimal("0")).movePointRight(+5).toString()).equals("0")); 3729 TestFmwk.assertTrue("mpr012", ((new com.ibm.icu.math.BigDecimal("0")).movePointRight(+1).toString()).equals("0")); 3730 TestFmwk.assertTrue("mpr013", ((new com.ibm.icu.math.BigDecimal("0")).movePointRight(0).toString()).equals("0")); 3731 TestFmwk.assertTrue("mpr014", ((new com.ibm.icu.math.BigDecimal("0")).movePointRight(-1).toString()).equals("0.0")); 3732 TestFmwk.assertTrue("mpr015", ((new com.ibm.icu.math.BigDecimal("0")).movePointRight(-5).toString()).equals("0.00000")); 3733 TestFmwk.assertTrue("mpr016", ((new com.ibm.icu.math.BigDecimal("0")).movePointRight(-10).toString()).equals("0.0000000000")); 3734 3735 TestFmwk.assertTrue("mpr020", ((new com.ibm.icu.math.BigDecimal("+1")).movePointRight(+10).toString()).equals("10000000000")); 3736 TestFmwk.assertTrue("mpr021", ((new com.ibm.icu.math.BigDecimal("+1")).movePointRight(+5).toString()).equals("100000")); 3737 TestFmwk.assertTrue("mpr022", ((new com.ibm.icu.math.BigDecimal("+1")).movePointRight(+1).toString()).equals("10")); 3738 TestFmwk.assertTrue("mpr023", ((new com.ibm.icu.math.BigDecimal("+1")).movePointRight(0).toString()).equals("1")); 3739 TestFmwk.assertTrue("mpr024", ((new com.ibm.icu.math.BigDecimal("+1")).movePointRight(-1).toString()).equals("0.1")); 3740 TestFmwk.assertTrue("mpr025", ((new com.ibm.icu.math.BigDecimal("+1")).movePointRight(-5).toString()).equals("0.00001")); 3741 TestFmwk.assertTrue("mpr026", ((new com.ibm.icu.math.BigDecimal("+1")).movePointRight(-10).toString()).equals("0.0000000001")); 3742 3743 TestFmwk.assertTrue("mpr030", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointRight(+10).toString()).equals("50000000000")); 3744 TestFmwk.assertTrue("mpr031", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointRight(+5).toString()).equals("500000")); 3745 TestFmwk.assertTrue("mpr032", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointRight(+1).toString()).equals("50")); 3746 TestFmwk.assertTrue("mpr033", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointRight(0).toString()).equals("5")); 3747 TestFmwk.assertTrue("mpr034", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointRight(-1).toString()).equals("0.5")); 3748 TestFmwk.assertTrue("mpr035", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointRight(-5).toString()).equals("0.00005")); 3749 TestFmwk.assertTrue("mpr036", ((new com.ibm.icu.math.BigDecimal("0.5E+1")).movePointRight(-10).toString()).equals("0.0000000005")); 3750 } 3751 3752 /* ----------------------------------------------------------------- */ 3753 3754 /** Test the {@link com.ibm.icu.math.BigDecimal#scale} method. */ 3755 3756 @Test 3757 public void diagscale() { 3758 TestFmwk.assertTrue("sca001", ((new com.ibm.icu.math.BigDecimal("-1")).scale())==0); 3759 TestFmwk.assertTrue("sca002", ((new com.ibm.icu.math.BigDecimal("-10")).scale())==0); 3760 TestFmwk.assertTrue("sca003", ((new com.ibm.icu.math.BigDecimal("+1")).scale())==0); 3761 TestFmwk.assertTrue("sca004", ((new com.ibm.icu.math.BigDecimal("+10")).scale())==0); 3762 TestFmwk.assertTrue("sca005", ((new com.ibm.icu.math.BigDecimal("1E+10")).scale())==0); 3763 TestFmwk.assertTrue("sca006", ((new com.ibm.icu.math.BigDecimal("1E-10")).scale())==10); 3764 TestFmwk.assertTrue("sca007", ((new com.ibm.icu.math.BigDecimal("0E-10")).scale())==0); 3765 TestFmwk.assertTrue("sca008", ((new com.ibm.icu.math.BigDecimal("0.000")).scale())==3); 3766 TestFmwk.assertTrue("sca009", ((new com.ibm.icu.math.BigDecimal("0.00")).scale())==2); 3767 TestFmwk.assertTrue("sca010", ((new com.ibm.icu.math.BigDecimal("0.0")).scale())==1); 3768 TestFmwk.assertTrue("sca011", ((new com.ibm.icu.math.BigDecimal("0.1")).scale())==1); 3769 TestFmwk.assertTrue("sca012", ((new com.ibm.icu.math.BigDecimal("0.12")).scale())==2); 3770 TestFmwk.assertTrue("sca013", ((new com.ibm.icu.math.BigDecimal("0.123")).scale())==3); 3771 TestFmwk.assertTrue("sca014", ((new com.ibm.icu.math.BigDecimal("-0.0")).scale())==1); 3772 TestFmwk.assertTrue("sca015", ((new com.ibm.icu.math.BigDecimal("-0.1")).scale())==1); 3773 TestFmwk.assertTrue("sca016", ((new com.ibm.icu.math.BigDecimal("-0.12")).scale())==2); 3774 TestFmwk.assertTrue("sca017", ((new com.ibm.icu.math.BigDecimal("-0.123")).scale())==3); 3775 } 3776 3777 /* ----------------------------------------------------------------- */ 3778 3779 /** Test the {@link com.ibm.icu.math.BigDecimal#setScale} method. */ 3780 3781 @Test 3782 public void diagsetscale() { 3783 boolean flag = false; 3784 java.lang.RuntimeException e = null; 3785 3786 TestFmwk.assertTrue("ssc001", ((new com.ibm.icu.math.BigDecimal("-1")).setScale(0).toString()).equals("-1")); 3787 TestFmwk.assertTrue("ssc002", ((new com.ibm.icu.math.BigDecimal("-1")).setScale(1).toString()).equals("-1.0")); 3788 TestFmwk.assertTrue("ssc003", ((new com.ibm.icu.math.BigDecimal("-1")).setScale(2).toString()).equals("-1.00")); 3789 TestFmwk.assertTrue("ssc004", ((new com.ibm.icu.math.BigDecimal("0")).setScale(0).toString()).equals("0")); 3790 TestFmwk.assertTrue("ssc005", ((new com.ibm.icu.math.BigDecimal("0")).setScale(1).toString()).equals("0.0")); 3791 TestFmwk.assertTrue("ssc006", ((new com.ibm.icu.math.BigDecimal("0")).setScale(2).toString()).equals("0.00")); 3792 TestFmwk.assertTrue("ssc007", ((new com.ibm.icu.math.BigDecimal("+1")).setScale(0).toString()).equals("1")); 3793 TestFmwk.assertTrue("ssc008", ((new com.ibm.icu.math.BigDecimal("+1")).setScale(1).toString()).equals("1.0")); 3794 TestFmwk.assertTrue("ssc009", ((new com.ibm.icu.math.BigDecimal("+1")).setScale(2).toString()).equals("1.00")); 3795 TestFmwk.assertTrue("ssc010", ((new com.ibm.icu.math.BigDecimal("-1")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("-1")); 3796 TestFmwk.assertTrue("ssc011", ((new com.ibm.icu.math.BigDecimal("-1")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("-1.0")); 3797 TestFmwk.assertTrue("ssc012", ((new com.ibm.icu.math.BigDecimal("-1")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("-1.00")); 3798 TestFmwk.assertTrue("ssc013", ((new com.ibm.icu.math.BigDecimal("0")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 3799 TestFmwk.assertTrue("ssc014", ((new com.ibm.icu.math.BigDecimal("0")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.0")); 3800 TestFmwk.assertTrue("ssc015", ((new com.ibm.icu.math.BigDecimal("0")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.00")); 3801 TestFmwk.assertTrue("ssc016", ((new com.ibm.icu.math.BigDecimal("+1")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1")); 3802 TestFmwk.assertTrue("ssc017", ((new com.ibm.icu.math.BigDecimal("+1")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.0")); 3803 TestFmwk.assertTrue("ssc018", ((new com.ibm.icu.math.BigDecimal("+1")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.00")); 3804 3805 TestFmwk.assertTrue("ssc020", ((new com.ibm.icu.math.BigDecimal("1.04")).setScale(3,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.040")); 3806 TestFmwk.assertTrue("ssc021", ((new com.ibm.icu.math.BigDecimal("1.04")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.04")); 3807 TestFmwk.assertTrue("ssc022", ((new com.ibm.icu.math.BigDecimal("1.04")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.0")); 3808 TestFmwk.assertTrue("ssc023", ((new com.ibm.icu.math.BigDecimal("1.04")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1")); 3809 TestFmwk.assertTrue("ssc024", ((new com.ibm.icu.math.BigDecimal("1.05")).setScale(3,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.050")); 3810 TestFmwk.assertTrue("ssc025", ((new com.ibm.icu.math.BigDecimal("1.05")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.05")); 3811 TestFmwk.assertTrue("ssc026", ((new com.ibm.icu.math.BigDecimal("1.05")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.1")); 3812 TestFmwk.assertTrue("ssc027", ((new com.ibm.icu.math.BigDecimal("1.05")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1")); 3813 TestFmwk.assertTrue("ssc028", ((new com.ibm.icu.math.BigDecimal("1.05")).setScale(3,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("1.050")); 3814 TestFmwk.assertTrue("ssc029", ((new com.ibm.icu.math.BigDecimal("1.05")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("1.05")); 3815 TestFmwk.assertTrue("ssc030", ((new com.ibm.icu.math.BigDecimal("1.05")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("1.0")); 3816 TestFmwk.assertTrue("ssc031", ((new com.ibm.icu.math.BigDecimal("1.05")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("1")); 3817 TestFmwk.assertTrue("ssc032", ((new com.ibm.icu.math.BigDecimal("1.06")).setScale(3,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.060")); 3818 TestFmwk.assertTrue("ssc033", ((new com.ibm.icu.math.BigDecimal("1.06")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.06")); 3819 TestFmwk.assertTrue("ssc034", ((new com.ibm.icu.math.BigDecimal("1.06")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.1")); 3820 TestFmwk.assertTrue("ssc035", ((new com.ibm.icu.math.BigDecimal("1.06")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1")); 3821 3822 TestFmwk.assertTrue("ssc040", ((new com.ibm.icu.math.BigDecimal("-10")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("-10.00")); 3823 TestFmwk.assertTrue("ssc041", ((new com.ibm.icu.math.BigDecimal("+1")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("1.00")); 3824 TestFmwk.assertTrue("ssc042", ((new com.ibm.icu.math.BigDecimal("+10")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("10.00")); 3825 TestFmwk.assertTrue("ssc043", ((new com.ibm.icu.math.BigDecimal("1E+10")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("10000000000.00")); 3826 TestFmwk.assertTrue("ssc044", ((new com.ibm.icu.math.BigDecimal("1E-10")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.00")); 3827 TestFmwk.assertTrue("ssc045", ((new com.ibm.icu.math.BigDecimal("1E-2")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.01")); 3828 TestFmwk.assertTrue("ssc046", ((new com.ibm.icu.math.BigDecimal("0E-10")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.00")); 3829 3830 // check rounding 3831 TestFmwk.assertTrue("ssc050", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(2,com.ibm.icu.math.MathContext.ROUND_CEILING).toString()).equals("0.01")); 3832 TestFmwk.assertTrue("ssc051", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(1,com.ibm.icu.math.MathContext.ROUND_CEILING).toString()).equals("0.1")); 3833 TestFmwk.assertTrue("ssc052", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(0,com.ibm.icu.math.MathContext.ROUND_CEILING).toString()).equals("1")); 3834 TestFmwk.assertTrue("ssc053", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(2,com.ibm.icu.math.MathContext.ROUND_DOWN).toString()).equals("0.00")); 3835 TestFmwk.assertTrue("ssc054", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(1,com.ibm.icu.math.MathContext.ROUND_DOWN).toString()).equals("0.0")); 3836 TestFmwk.assertTrue("ssc055", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(0,com.ibm.icu.math.MathContext.ROUND_DOWN).toString()).equals("0")); 3837 TestFmwk.assertTrue("ssc056", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(2,com.ibm.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0.00")); 3838 TestFmwk.assertTrue("ssc057", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(1,com.ibm.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0.0")); 3839 TestFmwk.assertTrue("ssc058", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(0,com.ibm.icu.math.MathContext.ROUND_FLOOR).toString()).equals("0")); 3840 TestFmwk.assertTrue("ssc059", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.00")); 3841 TestFmwk.assertTrue("ssc060", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0.0")); 3842 TestFmwk.assertTrue("ssc061", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN).toString()).equals("0")); 3843 TestFmwk.assertTrue("ssc062", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.00")); 3844 TestFmwk.assertTrue("ssc063", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.0")); 3845 TestFmwk.assertTrue("ssc064", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 3846 TestFmwk.assertTrue("ssc065", ((new com.ibm.icu.math.BigDecimal("0.015")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.02")); 3847 TestFmwk.assertTrue("ssc066", ((new com.ibm.icu.math.BigDecimal("0.015")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0.0")); 3848 TestFmwk.assertTrue("ssc067", ((new com.ibm.icu.math.BigDecimal("0.015")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN).toString()).equals("0")); 3849 TestFmwk.assertTrue("ssc068", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.01")); 3850 TestFmwk.assertTrue("ssc069", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.0")); 3851 TestFmwk.assertTrue("ssc070", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 3852 TestFmwk.assertTrue("ssc071", ((new com.ibm.icu.math.BigDecimal("0.095")).setScale(2,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.10")); 3853 TestFmwk.assertTrue("ssc072", ((new com.ibm.icu.math.BigDecimal("0.095")).setScale(1,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0.1")); 3854 TestFmwk.assertTrue("ssc073", ((new com.ibm.icu.math.BigDecimal("0.095")).setScale(0,com.ibm.icu.math.MathContext.ROUND_HALF_UP).toString()).equals("0")); 3855 TestFmwk.assertTrue("ssc074", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(2,com.ibm.icu.math.MathContext.ROUND_UP).toString()).equals("0.01")); 3856 TestFmwk.assertTrue("ssc075", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(1,com.ibm.icu.math.MathContext.ROUND_UP).toString()).equals("0.1")); 3857 TestFmwk.assertTrue("ssc076", ((new com.ibm.icu.math.BigDecimal("0.005")).setScale(0,com.ibm.icu.math.MathContext.ROUND_UP).toString()).equals("1")); 3858 3859 try { 3860 (new com.ibm.icu.math.BigDecimal(1)).setScale(-8); 3861 flag = false; 3862 } catch (java.lang.RuntimeException $117) { 3863 e = $117; 3864 flag = (e.getMessage()).equals("Negative scale: -8"); 3865 }/* checkscale */ 3866 TestFmwk.assertTrue("ssc100", flag); 3867 try { 3868 (new com.ibm.icu.math.BigDecimal(1.0001D)).setScale(3); 3869 flag = false; 3870 } catch (java.lang.RuntimeException $118) { 3871 e = $118; 3872 flag = (e.getMessage()).equals("Rounding necessary"); 3873 }/* checkrunn */ 3874 TestFmwk.assertTrue("ssc101", flag); 3875 try { 3876 (new com.ibm.icu.math.BigDecimal(1E-8D)).setScale(3); 3877 flag = false; 3878 } catch (java.lang.RuntimeException $119) { 3879 e = $119; 3880 flag = (e.getMessage()).equals("Rounding necessary"); 3881 }/* checkrunn */ 3882 TestFmwk.assertTrue("ssc102", flag); 3883 } 3884 3885 /* ----------------------------------------------------------------- */ 3886 3887 /** Test the <code>BigDecimal.shortValue()</code> method. */ 3888 3889 @Test 3890 public void diagshortvalue() { 3891 boolean flag = false; 3892 java.lang.String v = null; 3893 java.lang.ArithmeticException ae = null; 3894 java.lang.String badstrings[]; 3895 int i = 0; 3896 java.lang.String norm = null; 3897 3898 TestFmwk.assertTrue("shv002", (((short)0))==((new com.ibm.icu.math.BigDecimal("0")).shortValue())); 3899 TestFmwk.assertTrue("shv003", (((short)1))==((new com.ibm.icu.math.BigDecimal("1")).shortValue())); 3900 TestFmwk.assertTrue("shv004", (((short)99))==((new com.ibm.icu.math.BigDecimal("99")).shortValue())); 3901 TestFmwk.assertTrue("shv006", ((smax))==((new com.ibm.icu.math.BigDecimal(smax)).shortValue())); 3902 TestFmwk.assertTrue("shv007", ((smin))==((new com.ibm.icu.math.BigDecimal(smin)).shortValue())); 3903 TestFmwk.assertTrue("shv008", ((sneg))==((new com.ibm.icu.math.BigDecimal(sneg)).shortValue())); 3904 TestFmwk.assertTrue("shv009", ((szer))==((new com.ibm.icu.math.BigDecimal(szer)).shortValue())); 3905 TestFmwk.assertTrue("shv010", ((spos))==((new com.ibm.icu.math.BigDecimal(spos)).shortValue())); 3906 TestFmwk.assertTrue("shv011", ((smin))==((new com.ibm.icu.math.BigDecimal(smax+1)).shortValue())); 3907 TestFmwk.assertTrue("shv012", ((smax))==((new com.ibm.icu.math.BigDecimal(smin-1)).shortValue())); 3908 3909 TestFmwk.assertTrue("shv022", (((short)0))==((new com.ibm.icu.math.BigDecimal("0")).shortValueExact())); 3910 TestFmwk.assertTrue("shv023", (((short)1))==((new com.ibm.icu.math.BigDecimal("1")).shortValueExact())); 3911 TestFmwk.assertTrue("shv024", (((short)99))==((new com.ibm.icu.math.BigDecimal("99")).shortValueExact())); 3912 TestFmwk.assertTrue("shv026", ((smax))==((new com.ibm.icu.math.BigDecimal(smax)).shortValueExact())); 3913 TestFmwk.assertTrue("shv027", ((smin))==((new com.ibm.icu.math.BigDecimal(smin)).shortValueExact())); 3914 TestFmwk.assertTrue("shv028", ((sneg))==((new com.ibm.icu.math.BigDecimal(sneg)).shortValueExact())); 3915 TestFmwk.assertTrue("shv029", ((szer))==((new com.ibm.icu.math.BigDecimal(szer)).shortValueExact())); 3916 TestFmwk.assertTrue("shv030", ((spos))==((new com.ibm.icu.math.BigDecimal(spos)).shortValueExact())); 3917 try { 3918 v = "-88888888888"; 3919 (new com.ibm.icu.math.BigDecimal(v)).shortValueExact(); 3920 flag = false; 3921 } catch (java.lang.ArithmeticException $120) { 3922 ae = $120; 3923 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 3924 } 3925 TestFmwk.assertTrue("shv100", flag); 3926 try { 3927 v = "88888888888"; 3928 (new com.ibm.icu.math.BigDecimal(v)).shortValueExact(); 3929 flag = false; 3930 } catch (java.lang.ArithmeticException $121) { 3931 ae = $121; 3932 flag = (ae.getMessage()).equals("Conversion overflow:" + " " + v); 3933 } 3934 TestFmwk.assertTrue("shv101", flag); 3935 try { 3936 v = "1.5"; 3937 (new com.ibm.icu.math.BigDecimal(v)).shortValueExact(); 3938 flag = false; 3939 } catch (java.lang.ArithmeticException $122) { 3940 ae = $122; 3941 flag = (ae.getMessage()).equals("Decimal part non-zero:" + " " + v); 3942 } 3943 TestFmwk.assertTrue("shv102", flag); 3944 3945 badstrings = new java.lang.String[] { 3946 "123456", 3947 (new com.ibm.icu.math.BigDecimal(smax)).add(one).toString(), 3948 (new com.ibm.icu.math.BigDecimal(smin)).subtract(one) 3949 .toString(), 3950 "71111", 3951 "81111", 3952 "91111", 3953 "-71111", 3954 "-81111", 3955 "-91111", 3956 (new com.ibm.icu.math.BigDecimal(smin)).multiply(two) 3957 .toString(), 3958 (new com.ibm.icu.math.BigDecimal(smax)).multiply(two) 3959 .toString(), 3960 (new com.ibm.icu.math.BigDecimal(smin)).multiply(ten) 3961 .toString(), 3962 (new com.ibm.icu.math.BigDecimal(smax)).multiply(ten) 3963 .toString(), "-123456" }; // 220 3964 // 221 3965 // 222 3966 // 223 3967 // 224 3968 // 225 3969 // 226 3970 // 227 3971 // 228 3972 // 229 3973 // 230 3974 // 231 3975 // 232 3976 // 233 3977 { 3978 int $123 = badstrings.length; 3979 i = 0; 3980 for (; $123 > 0; $123--, i++) { 3981 try { 3982 v = badstrings[i]; 3983 (new com.ibm.icu.math.BigDecimal(v)).shortValueExact(); 3984 flag = false; 3985 } catch (java.lang.ArithmeticException $124) { 3986 ae = $124; 3987 norm = (new com.ibm.icu.math.BigDecimal(v)).toString(); 3988 flag = (ae.getMessage()).equals("Conversion overflow:" 3989 + " " + norm); 3990 } 3991 TestFmwk.assertTrue("shv" + (220 + i), flag); 3992 } 3993 }/* i */ 3994 } 3995 3996 /* ----------------------------------------------------------------- */ 3997 3998 /** Test the {@link com.ibm.icu.math.BigDecimal#signum} method. */ 3999 4000 @Test 4001 public void diagsignum() { 4002 // necessarily checks some obscure constructions, too 4003 TestFmwk.assertTrue("sig001", (-1)==((new com.ibm.icu.math.BigDecimal("-1")).signum())); 4004 TestFmwk.assertTrue("sig002", (-1)==((new com.ibm.icu.math.BigDecimal("-0.0010")).signum())); 4005 TestFmwk.assertTrue("sig003", (-1)==((new com.ibm.icu.math.BigDecimal("-0.001")).signum())); 4006 TestFmwk.assertTrue("sig004", 0==((new com.ibm.icu.math.BigDecimal("-0.00")).signum())); 4007 TestFmwk.assertTrue("sig005", 0==((new com.ibm.icu.math.BigDecimal("-0")).signum())); 4008 TestFmwk.assertTrue("sig006", 0==((new com.ibm.icu.math.BigDecimal("0")).signum())); 4009 TestFmwk.assertTrue("sig007", 0==((new com.ibm.icu.math.BigDecimal("00")).signum())); 4010 TestFmwk.assertTrue("sig008", 0==((new com.ibm.icu.math.BigDecimal("00.0")).signum())); 4011 TestFmwk.assertTrue("sig009", 1==((new com.ibm.icu.math.BigDecimal("00.01")).signum())); 4012 TestFmwk.assertTrue("sig010", 1==((new com.ibm.icu.math.BigDecimal("00.01")).signum())); 4013 TestFmwk.assertTrue("sig011", 1==((new com.ibm.icu.math.BigDecimal("00.010")).signum())); 4014 TestFmwk.assertTrue("sig012", 1==((new com.ibm.icu.math.BigDecimal("01.01")).signum())); 4015 TestFmwk.assertTrue("sig013", 1==((new com.ibm.icu.math.BigDecimal("+0.01")).signum())); 4016 TestFmwk.assertTrue("sig014", 1==((new com.ibm.icu.math.BigDecimal("+0.001")).signum())); 4017 TestFmwk.assertTrue("sig015", 1==((new com.ibm.icu.math.BigDecimal("1")).signum())); 4018 TestFmwk.assertTrue("sig016", 1==((new com.ibm.icu.math.BigDecimal("1e+12")).signum())); 4019 TestFmwk.assertTrue("sig017", 0==((new com.ibm.icu.math.BigDecimal("00e+12")).signum())); 4020 } 4021 4022 /* ----------------------------------------------------------------- */ 4023 4024 /** Test the {@link com.ibm.icu.math.BigDecimal#toBigDecimal} method. */ 4025 4026 @Test 4027 public void diagtobigdecimal() { 4028 TestFmwk.assertTrue("tbd001", ((new com.ibm.icu.math.BigDecimal("0")).toBigDecimal().toString()).equals("0")); 4029 TestFmwk.assertTrue("tbd002", ((new com.ibm.icu.math.BigDecimal("-1")).toBigDecimal().toString()).equals("-1")); 4030 TestFmwk.assertTrue("tbd003", ((new com.ibm.icu.math.BigDecimal("+1")).toBigDecimal().toString()).equals("1")); 4031 TestFmwk.assertTrue("tbd004", ((new com.ibm.icu.math.BigDecimal("1")).toBigDecimal().toString()).equals("1")); 4032 TestFmwk.assertTrue("tbd005", ((new com.ibm.icu.math.BigDecimal("1E+2")).toBigDecimal().toString()).equals("100")); 4033 TestFmwk.assertTrue("tbd006", ((new com.ibm.icu.math.BigDecimal("1E-2")).toBigDecimal().toString()).equals("0.01")); 4034 if (!isJDK15OrLater) { 4035 TestFmwk.assertTrue("tbd007", ((new com.ibm.icu.math.BigDecimal("1E-8")).toBigDecimal().toString()).equals("0.00000001")); 4036 } 4037 if (!isJDK15OrLater) { 4038 TestFmwk.assertTrue("tbd008", ((new com.ibm.icu.math.BigDecimal("1E-9")).toBigDecimal().toString()).equals("0.000000001")); 4039 } 4040 TestFmwk.assertTrue("tbd009", ((new com.ibm.icu.math.BigDecimal("1E10")).toBigDecimal().toString()).equals("10000000000")); 4041 TestFmwk.assertTrue("tbd010", ((new com.ibm.icu.math.BigDecimal("1E12")).toBigDecimal().toString()).equals("1000000000000")); 4042 } 4043 4044 /* ----------------------------------------------------------------- */ 4045 4046 /** Test the {@link com.ibm.icu.math.BigDecimal#toBigInteger} method. */ 4047 4048 @Test 4049 public void diagtobiginteger() { 4050 boolean flag = false; 4051 java.lang.String badstrings[]; 4052 int i = 0; 4053 TestFmwk.assertTrue("tbi001", ((new com.ibm.icu.math.BigDecimal("-1")).toBigInteger().toString()).equals("-1")); 4054 TestFmwk.assertTrue("tbi002", ((new com.ibm.icu.math.BigDecimal("0")).toBigInteger().toString()).equals("0")); 4055 TestFmwk.assertTrue("tbi003", ((new com.ibm.icu.math.BigDecimal("+1")).toBigInteger().toString()).equals("1")); 4056 TestFmwk.assertTrue("tbi004", ((new com.ibm.icu.math.BigDecimal("10")).toBigInteger().toString()).equals("10")); 4057 TestFmwk.assertTrue("tbi005", ((new com.ibm.icu.math.BigDecimal("1000")).toBigInteger().toString()).equals("1000")); 4058 TestFmwk.assertTrue("tbi006", ((new com.ibm.icu.math.BigDecimal("-1E+0")).toBigInteger().toString()).equals("-1")); 4059 TestFmwk.assertTrue("tbi007", ((new com.ibm.icu.math.BigDecimal("0E+0")).toBigInteger().toString()).equals("0")); 4060 TestFmwk.assertTrue("tbi008", ((new com.ibm.icu.math.BigDecimal("+1E+0")).toBigInteger().toString()).equals("1")); 4061 TestFmwk.assertTrue("tbi009", ((new com.ibm.icu.math.BigDecimal("10E+0")).toBigInteger().toString()).equals("10")); 4062 TestFmwk.assertTrue("tbi010", ((new com.ibm.icu.math.BigDecimal("1E+3")).toBigInteger().toString()).equals("1000")); 4063 TestFmwk.assertTrue("tbi011", ((new com.ibm.icu.math.BigDecimal("0.00")).toBigInteger().toString()).equals("0")); 4064 TestFmwk.assertTrue("tbi012", ((new com.ibm.icu.math.BigDecimal("0.01")).toBigInteger().toString()).equals("0")); 4065 TestFmwk.assertTrue("tbi013", ((new com.ibm.icu.math.BigDecimal("0.0")).toBigInteger().toString()).equals("0")); 4066 TestFmwk.assertTrue("tbi014", ((new com.ibm.icu.math.BigDecimal("0.1")).toBigInteger().toString()).equals("0")); 4067 TestFmwk.assertTrue("tbi015", ((new com.ibm.icu.math.BigDecimal("-0.00")).toBigInteger().toString()).equals("0")); 4068 TestFmwk.assertTrue("tbi016", ((new com.ibm.icu.math.BigDecimal("-0.01")).toBigInteger().toString()).equals("0")); 4069 TestFmwk.assertTrue("tbi017", ((new com.ibm.icu.math.BigDecimal("-0.0")).toBigInteger().toString()).equals("0")); 4070 TestFmwk.assertTrue("tbi018", ((new com.ibm.icu.math.BigDecimal("-0.1")).toBigInteger().toString()).equals("0")); 4071 TestFmwk.assertTrue("tbi019", ((new com.ibm.icu.math.BigDecimal("1.00")).toBigInteger().toString()).equals("1")); 4072 TestFmwk.assertTrue("tbi020", ((new com.ibm.icu.math.BigDecimal("1.01")).toBigInteger().toString()).equals("1")); 4073 TestFmwk.assertTrue("tbi021", ((new com.ibm.icu.math.BigDecimal("1.0")).toBigInteger().toString()).equals("1")); 4074 TestFmwk.assertTrue("tbi022", ((new com.ibm.icu.math.BigDecimal("1.1")).toBigInteger().toString()).equals("1")); 4075 TestFmwk.assertTrue("tbi023", ((new com.ibm.icu.math.BigDecimal("-1.00")).toBigInteger().toString()).equals("-1")); 4076 TestFmwk.assertTrue("tbi024", ((new com.ibm.icu.math.BigDecimal("-1.01")).toBigInteger().toString()).equals("-1")); 4077 TestFmwk.assertTrue("tbi025", ((new com.ibm.icu.math.BigDecimal("-1.0")).toBigInteger().toString()).equals("-1")); 4078 TestFmwk.assertTrue("tbi026", ((new com.ibm.icu.math.BigDecimal("-1.1")).toBigInteger().toString()).equals("-1")); 4079 TestFmwk.assertTrue("tbi027", ((new com.ibm.icu.math.BigDecimal("-111.111")).toBigInteger().toString()).equals("-111")); 4080 TestFmwk.assertTrue("tbi028", ((new com.ibm.icu.math.BigDecimal("+111.111")).toBigInteger().toString()).equals("111")); 4081 TestFmwk.assertTrue("tbi029", ((new com.ibm.icu.math.BigDecimal("0.09")).toBigInteger().toString()).equals("0")); 4082 TestFmwk.assertTrue("tbi030", ((new com.ibm.icu.math.BigDecimal("0.9")).toBigInteger().toString()).equals("0")); 4083 TestFmwk.assertTrue("tbi031", ((new com.ibm.icu.math.BigDecimal("1.09")).toBigInteger().toString()).equals("1")); 4084 TestFmwk.assertTrue("tbi032", ((new com.ibm.icu.math.BigDecimal("1.05")).toBigInteger().toString()).equals("1")); 4085 TestFmwk.assertTrue("tbi033", ((new com.ibm.icu.math.BigDecimal("1.04")).toBigInteger().toString()).equals("1")); 4086 TestFmwk.assertTrue("tbi034", ((new com.ibm.icu.math.BigDecimal("1.99")).toBigInteger().toString()).equals("1")); 4087 TestFmwk.assertTrue("tbi034", ((new com.ibm.icu.math.BigDecimal("1.9")).toBigInteger().toString()).equals("1")); 4088 TestFmwk.assertTrue("tbi035", ((new com.ibm.icu.math.BigDecimal("1.5")).toBigInteger().toString()).equals("1")); 4089 TestFmwk.assertTrue("tbi036", ((new com.ibm.icu.math.BigDecimal("1.4")).toBigInteger().toString()).equals("1")); 4090 TestFmwk.assertTrue("tbi037", ((new com.ibm.icu.math.BigDecimal("-1.09")).toBigInteger().toString()).equals("-1")); 4091 TestFmwk.assertTrue("tbi038", ((new com.ibm.icu.math.BigDecimal("-1.05")).toBigInteger().toString()).equals("-1")); 4092 TestFmwk.assertTrue("tbi039", ((new com.ibm.icu.math.BigDecimal("-1.04")).toBigInteger().toString()).equals("-1")); 4093 TestFmwk.assertTrue("tbi040", ((new com.ibm.icu.math.BigDecimal("-1.99")).toBigInteger().toString()).equals("-1")); 4094 TestFmwk.assertTrue("tbi041", ((new com.ibm.icu.math.BigDecimal("-1.9")).toBigInteger().toString()).equals("-1")); 4095 TestFmwk.assertTrue("tbi042", ((new com.ibm.icu.math.BigDecimal("-1.5")).toBigInteger().toString()).equals("-1")); 4096 TestFmwk.assertTrue("tbi043", ((new com.ibm.icu.math.BigDecimal("-1.4")).toBigInteger().toString()).equals("-1")); 4097 TestFmwk.assertTrue("tbi044", ((new com.ibm.icu.math.BigDecimal("1E-1000")).toBigInteger().toString()).equals("0")); 4098 TestFmwk.assertTrue("tbi045", ((new com.ibm.icu.math.BigDecimal("-1E-1000")).toBigInteger().toString()).equals("0")); 4099 4100 // Exact variety -- 4101 TestFmwk.assertTrue("tbi101", ((new com.ibm.icu.math.BigDecimal("-1")).toBigIntegerExact().toString()).equals("-1")); 4102 TestFmwk.assertTrue("tbi102", ((new com.ibm.icu.math.BigDecimal("0")).toBigIntegerExact().toString()).equals("0")); 4103 TestFmwk.assertTrue("tbi103", ((new com.ibm.icu.math.BigDecimal("+1")).toBigIntegerExact().toString()).equals("1")); 4104 TestFmwk.assertTrue("tbi104", ((new com.ibm.icu.math.BigDecimal("10")).toBigIntegerExact().toString()).equals("10")); 4105 TestFmwk.assertTrue("tbi105", ((new com.ibm.icu.math.BigDecimal("1000")).toBigIntegerExact().toString()).equals("1000")); 4106 TestFmwk.assertTrue("tbi106", ((new com.ibm.icu.math.BigDecimal("-1E+0")).toBigIntegerExact().toString()).equals("-1")); 4107 TestFmwk.assertTrue("tbi107", ((new com.ibm.icu.math.BigDecimal("0E+0")).toBigIntegerExact().toString()).equals("0")); 4108 TestFmwk.assertTrue("tbi108", ((new com.ibm.icu.math.BigDecimal("+1E+0")).toBigIntegerExact().toString()).equals("1")); 4109 TestFmwk.assertTrue("tbi109", ((new com.ibm.icu.math.BigDecimal("10E+0")).toBigIntegerExact().toString()).equals("10")); 4110 TestFmwk.assertTrue("tbi110", ((new com.ibm.icu.math.BigDecimal("1E+3")).toBigIntegerExact().toString()).equals("1000")); 4111 TestFmwk.assertTrue("tbi111", ((new com.ibm.icu.math.BigDecimal("0.00")).toBigIntegerExact().toString()).equals("0")); 4112 TestFmwk.assertTrue("tbi112", ((new com.ibm.icu.math.BigDecimal("0.0")).toBigIntegerExact().toString()).equals("0")); 4113 TestFmwk.assertTrue("tbi113", ((new com.ibm.icu.math.BigDecimal("-0.00")).toBigIntegerExact().toString()).equals("0")); 4114 TestFmwk.assertTrue("tbi114", ((new com.ibm.icu.math.BigDecimal("-0.0")).toBigIntegerExact().toString()).equals("0")); 4115 TestFmwk.assertTrue("tbi115", ((new com.ibm.icu.math.BigDecimal("1.00")).toBigIntegerExact().toString()).equals("1")); 4116 TestFmwk.assertTrue("tbi116", ((new com.ibm.icu.math.BigDecimal("1.0")).toBigIntegerExact().toString()).equals("1")); 4117 TestFmwk.assertTrue("tbi117", ((new com.ibm.icu.math.BigDecimal("-1.00")).toBigIntegerExact().toString()).equals("-1")); 4118 TestFmwk.assertTrue("tbi118", ((new com.ibm.icu.math.BigDecimal("-1.0")).toBigIntegerExact().toString()).equals("-1")); 4119 TestFmwk.assertTrue("tbi119", ((new com.ibm.icu.math.BigDecimal("1.00000000000000000000000000000")).toBigIntegerExact().toString()).equals("1")); 4120 4121 4122 // the following should all raise exceptions 4123 4124 badstrings = new java.lang.String[] { "0.09", "0.9", "0.01", "0.1", 4125 "-0.01", "-0.1", "1.01", "-1.01", "-1.1", "-111.111", 4126 "+111.111", "1.09", "1.05", "1.04", "1.99", "1.9", "1.5", 4127 "1.4", "-1.09", "-1.05", "-1.04", "-1.99", "-1.9", "-1.5", 4128 "-1.4", "1E-1000", "-1E-1000", "11E-1", "1.1", 4129 "127623156123656561356123512315631231551312356.000001", 4130 "0.000000000000000000000000000000000000000000000001" }; // 300-303 4131 // 304-307 4132 // 308-311 4133 // 312-316 4134 // 317-320 4135 // 321-324 4136 // 325-328 4137 // 329 4138 // 330 4139 4140 { 4141 int $125 = badstrings.length; 4142 i = 0; 4143 for (; $125 > 0; $125--, i++) { 4144 try { 4145 (new com.ibm.icu.math.BigDecimal(badstrings[i])) 4146 .toBigIntegerExact(); 4147 flag = false; 4148 } catch (java.lang.ArithmeticException $126) { 4149 flag = true; 4150 } 4151 TestFmwk.assertTrue("tbi" + (300 + i), flag); 4152 } 4153 }/* i */ 4154 } 4155 4156 /* ----------------------------------------------------------------- */ 4157 4158 /** Test the {@link com.ibm.icu.math.BigDecimal#toCharArray} method. */ 4159 4160 @Test 4161 public void diagtochararray() { 4162 java.lang.String str; 4163 char car[]; 4164 com.ibm.icu.math.BigDecimal d; 4165 char ca[]; 4166 // the function of this has been tested above, this is simply an 4167 // existence proof and type-check 4168 str = "-123.45"; 4169 car = (str).toCharArray(); 4170 d = new com.ibm.icu.math.BigDecimal(str); 4171 ca = d.toCharArray(); 4172 TestFmwk.assertTrue("tca001", ca.length == car.length); 4173 TestFmwk.assertTrue("tca002", (new java.lang.String(ca)) 4174 .equals((new java.lang.String(car)))); 4175 TestFmwk.assertTrue("tca003", (d.toCharArray() instanceof char[])); 4176 TestFmwk.assertTrue("tca004", (ca instanceof char[])); 4177 } 4178 4179 /* ----------------------------------------------------------------- */ 4180 4181 /** Test the {@link com.ibm.icu.math.BigDecimal#toString} method. */ 4182 4183 @Test 4184 public void diagtostring() { 4185 java.lang.String str; 4186 char car[]; 4187 com.ibm.icu.math.BigDecimal d; 4188 char ca[]; 4189 java.lang.String cs; 4190 // the function of this has been tested above, this is simply an 4191 // existence proof and type-check 4192 str = "123.45"; 4193 car = (str).toCharArray(); 4194 d = new com.ibm.icu.math.BigDecimal(car, 0, car.length); 4195 ca = d.toCharArray(); 4196 cs = d.toString(); 4197 TestFmwk.assertTrue("tos001", (str.toCharArray().length) == ca.length); 4198 TestFmwk.assertTrue("tos002", (str.length()) == (cs.length())); 4199 TestFmwk.assertTrue("tos003", str.equals((new java.lang.String(ca)))); 4200 TestFmwk.assertTrue("tos004", str.equals(cs)); 4201 TestFmwk.assertTrue("tos005", (cs instanceof java.lang.String)); 4202 TestFmwk.assertTrue("tos006", (d.toString() instanceof java.lang.String)); 4203 } 4204 4205 /* ----------------------------------------------------------------- */ 4206 4207 /** Test the {@link com.ibm.icu.math.BigDecimal#unscaledValue} method. */ 4208 4209 @Test 4210 public void diagunscaledvalue() { 4211 // just like toBigInteger, but scaly bits are preserved [without dots] 4212 TestFmwk.assertTrue("uns001", ((new com.ibm.icu.math.BigDecimal("-1")).unscaledValue().toString()).equals("-1")); 4213 TestFmwk.assertTrue("uns002", ((new com.ibm.icu.math.BigDecimal("0")).unscaledValue().toString()).equals("0")); 4214 TestFmwk.assertTrue("uns003", ((new com.ibm.icu.math.BigDecimal("+1")).unscaledValue().toString()).equals("1")); 4215 TestFmwk.assertTrue("uns004", ((new com.ibm.icu.math.BigDecimal("10")).unscaledValue().toString()).equals("10")); 4216 TestFmwk.assertTrue("uns005", ((new com.ibm.icu.math.BigDecimal("1000")).unscaledValue().toString()).equals("1000")); 4217 TestFmwk.assertTrue("uns006", ((new com.ibm.icu.math.BigDecimal("-1E+0")).unscaledValue().toString()).equals("-1")); 4218 TestFmwk.assertTrue("uns007", ((new com.ibm.icu.math.BigDecimal("0E+0")).unscaledValue().toString()).equals("0")); 4219 TestFmwk.assertTrue("uns008", ((new com.ibm.icu.math.BigDecimal("+1E+0")).unscaledValue().toString()).equals("1")); 4220 TestFmwk.assertTrue("uns009", ((new com.ibm.icu.math.BigDecimal("10E+0")).unscaledValue().toString()).equals("10")); 4221 TestFmwk.assertTrue("uns010", ((new com.ibm.icu.math.BigDecimal("1E+3")).unscaledValue().toString()).equals("1000")); 4222 TestFmwk.assertTrue("uns011", ((new com.ibm.icu.math.BigDecimal("0.00")).unscaledValue().toString()).equals("0")); 4223 TestFmwk.assertTrue("uns012", ((new com.ibm.icu.math.BigDecimal("0.01")).unscaledValue().toString()).equals("1")); 4224 TestFmwk.assertTrue("uns013", ((new com.ibm.icu.math.BigDecimal("0.0")).unscaledValue().toString()).equals("0")); 4225 TestFmwk.assertTrue("uns014", ((new com.ibm.icu.math.BigDecimal("0.1")).unscaledValue().toString()).equals("1")); 4226 TestFmwk.assertTrue("uns015", ((new com.ibm.icu.math.BigDecimal("-0.00")).unscaledValue().toString()).equals("0")); 4227 TestFmwk.assertTrue("uns016", ((new com.ibm.icu.math.BigDecimal("-0.01")).unscaledValue().toString()).equals("-1")); 4228 TestFmwk.assertTrue("uns017", ((new com.ibm.icu.math.BigDecimal("-0.0")).unscaledValue().toString()).equals("0")); 4229 TestFmwk.assertTrue("uns018", ((new com.ibm.icu.math.BigDecimal("-0.1")).unscaledValue().toString()).equals("-1")); 4230 TestFmwk.assertTrue("uns019", ((new com.ibm.icu.math.BigDecimal("1.00")).unscaledValue().toString()).equals("100")); 4231 TestFmwk.assertTrue("uns020", ((new com.ibm.icu.math.BigDecimal("1.01")).unscaledValue().toString()).equals("101")); 4232 TestFmwk.assertTrue("uns021", ((new com.ibm.icu.math.BigDecimal("1.0")).unscaledValue().toString()).equals("10")); 4233 TestFmwk.assertTrue("uns022", ((new com.ibm.icu.math.BigDecimal("1.1")).unscaledValue().toString()).equals("11")); 4234 TestFmwk.assertTrue("uns023", ((new com.ibm.icu.math.BigDecimal("-1.00")).unscaledValue().toString()).equals("-100")); 4235 TestFmwk.assertTrue("uns024", ((new com.ibm.icu.math.BigDecimal("-1.01")).unscaledValue().toString()).equals("-101")); 4236 TestFmwk.assertTrue("uns025", ((new com.ibm.icu.math.BigDecimal("-1.0")).unscaledValue().toString()).equals("-10")); 4237 TestFmwk.assertTrue("uns026", ((new com.ibm.icu.math.BigDecimal("-1.1")).unscaledValue().toString()).equals("-11")); 4238 TestFmwk.assertTrue("uns027", ((new com.ibm.icu.math.BigDecimal("-111.111")).unscaledValue().toString()).equals("-111111")); 4239 TestFmwk.assertTrue("uns028", ((new com.ibm.icu.math.BigDecimal("+111.111")).unscaledValue().toString()).equals("111111")); 4240 } 4241 4242 /* ----------------------------------------------------------------- */ 4243 4244 /** 4245 * Test the {@link com.ibm.icu.math.BigDecimal#valueOf} method [long and 4246 * double]. 4247 */ 4248 4249 @Test 4250 public void diagvalueof() { 4251 boolean flag = false; 4252 java.lang.NumberFormatException e = null; 4253 double dzer; 4254 double dpos; 4255 double dneg; 4256 double dpos5; 4257 double dneg5; 4258 double dmin; 4259 double dmax; 4260 double d; 4261 4262 // valueOf(long [,scale]) -- 4263 4264 TestFmwk.assertTrue("val001", (com.ibm.icu.math.BigDecimal.valueOf(((byte)-2)).toString()).equals("-2")); 4265 TestFmwk.assertTrue("val002", (com.ibm.icu.math.BigDecimal.valueOf(((byte)-1)).toString()).equals("-1")); 4266 TestFmwk.assertTrue("val003", (com.ibm.icu.math.BigDecimal.valueOf(((byte)-0)).toString()).equals("0")); 4267 TestFmwk.assertTrue("val004", (com.ibm.icu.math.BigDecimal.valueOf(((byte)+1)).toString()).equals("1")); 4268 TestFmwk.assertTrue("val005", (com.ibm.icu.math.BigDecimal.valueOf(((byte)+2)).toString()).equals("2")); 4269 TestFmwk.assertTrue("val006", (com.ibm.icu.math.BigDecimal.valueOf(((byte)10)).toString()).equals("10")); 4270 TestFmwk.assertTrue("val007", (com.ibm.icu.math.BigDecimal.valueOf(((byte)11)).toString()).equals("11")); 4271 TestFmwk.assertTrue("val008", (com.ibm.icu.math.BigDecimal.valueOf(lmin).toString()).equals("-9223372036854775808")); 4272 TestFmwk.assertTrue("val009", (com.ibm.icu.math.BigDecimal.valueOf(lmax).toString()).equals("9223372036854775807")); 4273 TestFmwk.assertTrue("val010", (com.ibm.icu.math.BigDecimal.valueOf(lneg).toString()).equals("-1")); 4274 TestFmwk.assertTrue("val011", (com.ibm.icu.math.BigDecimal.valueOf(lzer).toString()).equals("0")); 4275 TestFmwk.assertTrue("val012", (com.ibm.icu.math.BigDecimal.valueOf(lpos).toString()).equals("1")); 4276 TestFmwk.assertTrue("val013", (com.ibm.icu.math.BigDecimal.valueOf(lmin,0).toString()).equals("-9223372036854775808")); 4277 TestFmwk.assertTrue("val014", (com.ibm.icu.math.BigDecimal.valueOf(lmax,0).toString()).equals("9223372036854775807")); 4278 TestFmwk.assertTrue("val015", (com.ibm.icu.math.BigDecimal.valueOf(lneg,0).toString()).equals("-1")); 4279 TestFmwk.assertTrue("val016", (com.ibm.icu.math.BigDecimal.valueOf(lpos,0).toString()).equals("1")); 4280 4281 TestFmwk.assertTrue("val017", (com.ibm.icu.math.BigDecimal.valueOf(lzer,0).toString()).equals("0")); 4282 TestFmwk.assertTrue("val018", (com.ibm.icu.math.BigDecimal.valueOf(lzer,1).toString()).equals("0.0")); 4283 TestFmwk.assertTrue("val019", (com.ibm.icu.math.BigDecimal.valueOf(lzer,2).toString()).equals("0.00")); 4284 TestFmwk.assertTrue("val020", (com.ibm.icu.math.BigDecimal.valueOf(lzer,3).toString()).equals("0.000")); 4285 TestFmwk.assertTrue("val021", (com.ibm.icu.math.BigDecimal.valueOf(lzer,10).toString()).equals("0.0000000000")); 4286 4287 TestFmwk.assertTrue("val022", (com.ibm.icu.math.BigDecimal.valueOf(lmin,7).toString()).equals("-922337203685.4775808")); 4288 TestFmwk.assertTrue("val023", (com.ibm.icu.math.BigDecimal.valueOf(lmax,11).toString()).equals("92233720.36854775807")); 4289 4290 try { 4291 com.ibm.icu.math.BigDecimal.valueOf(23, -8); 4292 flag = false; 4293 } catch (java.lang.NumberFormatException $127) { 4294 e = $127; 4295 flag = (e.getMessage()).equals("Negative scale: -8"); 4296 }/* checkscale */ 4297 TestFmwk.assertTrue("val100", flag); 4298 4299 // valueOf(double) -- 4300 4301 dzer = 0; 4302 dpos = 1; 4303 dpos = dpos / (10); 4304 dneg = -dpos; 4305 TestFmwk.assertTrue("val201", (com.ibm.icu.math.BigDecimal.valueOf(dneg).toString()).equals("-0.1")); 4306 TestFmwk.assertTrue("val202", (com.ibm.icu.math.BigDecimal.valueOf(dzer).toString()).equals("0.0")); // cf. constructor 4307 TestFmwk.assertTrue("val203", (com.ibm.icu.math.BigDecimal.valueOf(dpos).toString()).equals("0.1")); 4308 dpos5 = 0.5D; 4309 dneg5 = -dpos5; 4310 TestFmwk.assertTrue("val204", (com.ibm.icu.math.BigDecimal.valueOf(dneg5).toString()).equals("-0.5")); 4311 TestFmwk.assertTrue("val205", (com.ibm.icu.math.BigDecimal.valueOf(dpos5).toString()).equals("0.5")); 4312 dmin = java.lang.Double.MIN_VALUE; 4313 dmax = java.lang.Double.MAX_VALUE; 4314 TestFmwk.assertTrue("val206", (com.ibm.icu.math.BigDecimal.valueOf(dmin).toString()).equals("4.9E-324")); 4315 TestFmwk.assertTrue("val207", (com.ibm.icu.math.BigDecimal.valueOf(dmax).toString()).equals("1.7976931348623157E+308")); 4316 4317 // nasties 4318 d = 9; 4319 d = d / (10); 4320 TestFmwk.assertTrue("val210", (com.ibm.icu.math.BigDecimal.valueOf(d).toString()).equals("0.9")); 4321 d = d / (10); 4322 TestFmwk.assertTrue("val211", (com.ibm.icu.math.BigDecimal.valueOf(d).toString()).equals("0.09")); 4323 d = d / (10); 4324 // The primitive double 0.009 is different in OpenJDK. In Oracle/IBM java <= 6, there is a trailing 0 (e.g 0.0090). 4325 String s = com.ibm.icu.math.BigDecimal.valueOf(d).toString(); 4326 TestFmwk.assertTrue("val212", s.equals("0.0090") || s.equals("0.009")); 4327 d = d / (10); 4328 TestFmwk.assertTrue("val213", (com.ibm.icu.math.BigDecimal.valueOf(d).toString()).equals("9.0E-4")); 4329 d = d / (10); 4330 TestFmwk.assertTrue("val214", (com.ibm.icu.math.BigDecimal.valueOf(d).toString()).equals("8.999999999999999E-5")); 4331 d = d / (10); 4332 TestFmwk.assertTrue("val215", (com.ibm.icu.math.BigDecimal.valueOf(d).toString()).equals("8.999999999999999E-6")); 4333 d = d / (10); 4334 TestFmwk.assertTrue("val216", (com.ibm.icu.math.BigDecimal.valueOf(d).toString()).equals("8.999999999999999E-7")); 4335 d = d / (10); 4336 TestFmwk.assertTrue("val217", (com.ibm.icu.math.BigDecimal.valueOf(d).toString()).equals("8.999999999999999E-8")); 4337 d = d / (10); 4338 TestFmwk.assertTrue("val218", (com.ibm.icu.math.BigDecimal.valueOf(d).toString()).equals("8.999999999999998E-9")); 4339 4340 try { 4341 com.ibm.icu.math.BigDecimal 4342 .valueOf(java.lang.Double.POSITIVE_INFINITY); 4343 flag = false; 4344 } catch (java.lang.NumberFormatException $128) { 4345 flag = true; 4346 }/* checkpin */ 4347 TestFmwk.assertTrue("val301", flag); 4348 try { 4349 com.ibm.icu.math.BigDecimal 4350 .valueOf(java.lang.Double.NEGATIVE_INFINITY); 4351 flag = false; 4352 } catch (java.lang.NumberFormatException $129) { 4353 flag = true; 4354 }/* checknin */ 4355 TestFmwk.assertTrue("val302", flag); 4356 try { 4357 com.ibm.icu.math.BigDecimal.valueOf(java.lang.Double.NaN); 4358 flag = false; 4359 } catch (java.lang.NumberFormatException $130) { 4360 flag = true; 4361 }/* checknan */ 4362 TestFmwk.assertTrue("val303", flag); 4363 } 4364 4365 /* ----------------------------------------------------------------- */ 4366 4367 /** Test the {@link com.ibm.icu.math.MathContext} class. */ 4368 4369 @Test 4370 public void diagmathcontext() { 4371 com.ibm.icu.math.MathContext mccon1; 4372 com.ibm.icu.math.MathContext mccon2; 4373 com.ibm.icu.math.MathContext mccon3; 4374 com.ibm.icu.math.MathContext mccon4; 4375 com.ibm.icu.math.MathContext mcrmc; 4376 com.ibm.icu.math.MathContext mcrmd; 4377 com.ibm.icu.math.MathContext mcrmf; 4378 com.ibm.icu.math.MathContext mcrmhd; 4379 com.ibm.icu.math.MathContext mcrmhe; 4380 com.ibm.icu.math.MathContext mcrmhu; 4381 com.ibm.icu.math.MathContext mcrmun; 4382 com.ibm.icu.math.MathContext mcrmu; 4383 boolean flag = false; 4384 java.lang.IllegalArgumentException e = null; 4385 // these tests are mostly existence checks 4386 TestFmwk.assertTrue("mcn001", (com.ibm.icu.math.MathContext.DEFAULT.getDigits())==9); 4387 TestFmwk.assertTrue("mcn002", (com.ibm.icu.math.MathContext.DEFAULT.getForm())==com.ibm.icu.math.MathContext.SCIENTIFIC); 4388 TestFmwk.assertTrue("mcn003", (com.ibm.icu.math.MathContext.DEFAULT.getForm())!=com.ibm.icu.math.MathContext.ENGINEERING); 4389 TestFmwk.assertTrue("mcn004", (com.ibm.icu.math.MathContext.DEFAULT.getForm())!=com.ibm.icu.math.MathContext.PLAIN); 4390 TestFmwk.assertTrue("mcn005", (com.ibm.icu.math.MathContext.DEFAULT.getLostDigits()?1:0)==0); 4391 TestFmwk.assertTrue("mcn006", (com.ibm.icu.math.MathContext.DEFAULT.getRoundingMode())==com.ibm.icu.math.MathContext.ROUND_HALF_UP); 4392 4393 TestFmwk.assertTrue("mcn010", com.ibm.icu.math.MathContext.ROUND_CEILING>=0); 4394 TestFmwk.assertTrue("mcn011", com.ibm.icu.math.MathContext.ROUND_DOWN>=0); 4395 TestFmwk.assertTrue("mcn012", com.ibm.icu.math.MathContext.ROUND_FLOOR>=0); 4396 TestFmwk.assertTrue("mcn013", com.ibm.icu.math.MathContext.ROUND_HALF_DOWN>=0); 4397 TestFmwk.assertTrue("mcn014", com.ibm.icu.math.MathContext.ROUND_HALF_EVEN>=0); 4398 TestFmwk.assertTrue("mcn015", com.ibm.icu.math.MathContext.ROUND_HALF_UP>=0); 4399 TestFmwk.assertTrue("mcn016", com.ibm.icu.math.MathContext.ROUND_UNNECESSARY>=0); 4400 TestFmwk.assertTrue("mcn017", com.ibm.icu.math.MathContext.ROUND_UP>=0); 4401 4402 mccon1=new com.ibm.icu.math.MathContext(111); 4403 TestFmwk.assertTrue("mcn021", (mccon1.getDigits())==111); 4404 TestFmwk.assertTrue("mcn022", (mccon1.getForm())==com.ibm.icu.math.MathContext.SCIENTIFIC); 4405 TestFmwk.assertTrue("mcn023", (mccon1.getLostDigits()?1:0)==0); 4406 TestFmwk.assertTrue("mcn024", (mccon1.getRoundingMode())==com.ibm.icu.math.MathContext.ROUND_HALF_UP); 4407 4408 mccon2=new com.ibm.icu.math.MathContext(78,com.ibm.icu.math.MathContext.ENGINEERING); 4409 TestFmwk.assertTrue("mcn031", (mccon2.getDigits())==78); 4410 TestFmwk.assertTrue("mcn032", (mccon2.getForm())==com.ibm.icu.math.MathContext.ENGINEERING); 4411 TestFmwk.assertTrue("mcn033", (mccon2.getLostDigits()?1:0)==0); 4412 TestFmwk.assertTrue("mcn034", (mccon2.getRoundingMode())==com.ibm.icu.math.MathContext.ROUND_HALF_UP); 4413 4414 mccon3=new com.ibm.icu.math.MathContext(5,com.ibm.icu.math.MathContext.PLAIN,true); 4415 TestFmwk.assertTrue("mcn041", (mccon3.getDigits())==5); 4416 TestFmwk.assertTrue("mcn042", (mccon3.getForm())==com.ibm.icu.math.MathContext.PLAIN); 4417 TestFmwk.assertTrue("mcn043", (mccon3.getLostDigits()?1:0)==1); 4418 TestFmwk.assertTrue("mcn044", (mccon3.getRoundingMode())==com.ibm.icu.math.MathContext.ROUND_HALF_UP); 4419 4420 mccon4=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.SCIENTIFIC,false,com.ibm.icu.math.MathContext.ROUND_FLOOR); 4421 TestFmwk.assertTrue("mcn051", (mccon4.getDigits()) == 0); 4422 TestFmwk.assertTrue("mcn052", (mccon4.getForm()) == com.ibm.icu.math.MathContext.SCIENTIFIC); 4423 TestFmwk.assertTrue("mcn053", (mccon4.getLostDigits() ? 1 : 0) == 0); 4424 TestFmwk.assertTrue("mcn054", (mccon4.getRoundingMode()) == com.ibm.icu.math.MathContext.ROUND_FLOOR); 4425 4426 TestFmwk.assertTrue("mcn061", (mccon1.toString()).equals("digits=111 form=SCIENTIFIC lostDigits=0 roundingMode=ROUND_HALF_UP")); 4427 4428 TestFmwk.assertTrue("mcn062", (mccon2.toString()).equals("digits=78 form=ENGINEERING lostDigits=0 roundingMode=ROUND_HALF_UP")); 4429 4430 TestFmwk.assertTrue("mcn063", (mccon3.toString()).equals("digits=5 form=PLAIN lostDigits=1 roundingMode=ROUND_HALF_UP")); 4431 4432 TestFmwk.assertTrue("mcn064", (mccon4.toString()).equals("digits=0 form=SCIENTIFIC lostDigits=0 roundingMode=ROUND_FLOOR")); 4433 4434 // complete testing rounding modes round trips 4435 mcrmc=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.PLAIN,false,com.ibm.icu.math.MathContext.ROUND_CEILING); 4436 mcrmd=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.PLAIN,false,com.ibm.icu.math.MathContext.ROUND_DOWN); 4437 mcrmf=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.PLAIN,false,com.ibm.icu.math.MathContext.ROUND_FLOOR); 4438 mcrmhd=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.PLAIN,false,com.ibm.icu.math.MathContext.ROUND_HALF_DOWN); 4439 mcrmhe=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.PLAIN,false,com.ibm.icu.math.MathContext.ROUND_HALF_EVEN); 4440 mcrmhu=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.PLAIN,false,com.ibm.icu.math.MathContext.ROUND_HALF_UP); 4441 mcrmun=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.PLAIN,false,com.ibm.icu.math.MathContext.ROUND_UNNECESSARY); 4442 mcrmu=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.PLAIN,false,com.ibm.icu.math.MathContext.ROUND_UP); 4443 4444 TestFmwk.assertTrue("mcn071", (mcrmc.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_CEILING")); 4445 4446 TestFmwk.assertTrue("mcn072", (mcrmd.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_DOWN")); 4447 4448 TestFmwk.assertTrue("mcn073", (mcrmf.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_FLOOR")); 4449 4450 TestFmwk.assertTrue("mcn074", (mcrmhd.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_HALF_DOWN")); 4451 4452 TestFmwk.assertTrue("mcn075", (mcrmhe.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_HALF_EVEN")); 4453 4454 TestFmwk.assertTrue("mcn076", (mcrmhu.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_HALF_UP")); 4455 4456 TestFmwk.assertTrue("mcn077", (mcrmun.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_UNNECESSARY")); 4457 4458 TestFmwk.assertTrue("mcn078", (mcrmu.toString()).equals("digits=0 form=PLAIN lostDigits=0 roundingMode=ROUND_UP")); 4459 4460 // [get methods tested already] 4461 4462 // errors... 4463 4464 try { 4465 new com.ibm.icu.math.MathContext(-1); 4466 flag = false; 4467 } catch (java.lang.IllegalArgumentException $131) { 4468 e = $131; 4469 flag = (e.getMessage()).equals("Digits too small: -1"); 4470 }/* checkdig */ 4471 TestFmwk.assertTrue("mcn101", flag); 4472 try { 4473 new com.ibm.icu.math.MathContext(1000000000); 4474 flag = false; 4475 } catch (java.lang.IllegalArgumentException $132) { 4476 e = $132; 4477 flag = (e.getMessage()).equals("Digits too large: 1000000000"); 4478 }/* checkdigbig */ 4479 TestFmwk.assertTrue("mcn102", flag); 4480 4481 try { 4482 new com.ibm.icu.math.MathContext(0, 5); 4483 flag = false; 4484 } catch (java.lang.IllegalArgumentException $133) { 4485 e = $133; 4486 flag = (e.getMessage()).equals("Bad form value: 5"); 4487 }/* checkform */ 4488 TestFmwk.assertTrue("mcn111", flag); 4489 try { 4490 new com.ibm.icu.math.MathContext(0, -1); 4491 flag = false; 4492 } catch (java.lang.IllegalArgumentException $134) { 4493 e = $134; 4494 flag = (e.getMessage()).equals("Bad form value: -1"); 4495 }/* checkformneg */ 4496 TestFmwk.assertTrue("mcn112", flag); 4497 4498 // [lostDigits cannot be invalid] 4499 4500 try { 4501 new com.ibm.icu.math.MathContext(0, 4502 com.ibm.icu.math.MathContext.PLAIN, false, 12); 4503 flag = false; 4504 } catch (java.lang.IllegalArgumentException $135) { 4505 e = $135; 4506 flag = (e.getMessage()).equals("Bad roundingMode value: 12"); 4507 }/* checkround */ 4508 TestFmwk.assertTrue("mcn121", flag); 4509 try { 4510 new com.ibm.icu.math.MathContext(0, 4511 com.ibm.icu.math.MathContext.PLAIN, false, -1); 4512 flag = false; 4513 } catch (java.lang.IllegalArgumentException $136) { 4514 e = $136; 4515 flag = (e.getMessage()).equals("Bad roundingMode value: -1"); 4516 }/* checkroundneg */ 4517 TestFmwk.assertTrue("mcn122", flag); 4518 } 4519 4520 /* ----------------------------------------------------------------- */ 4521 4522 /** 4523 * Test general arithmetic (base operators). 4524 * <p> 4525 * Unlike the specific method tests, these tests were randomly generated by 4526 * an IBM Object Rexx procedure, then manually corrected for known 4527 * differences from ANSI X3-274. These differences are: 4528 * <ol> 4529 * <li>the trigger point in exponential notation is fixed in ANSI X3-274 4530 * but varies with DIGITS in Classic and Object Rexx 4531 * <li>some trailing zeros were missing (e.g., 1.3 + 1E-60 should show 4532 * seven trailing zeros) 4533 * <li>the power operator is less accurate in Object Rexx 4534 * <li>ANSI X3-274 [errata 1999] rounds input numbers to DIGITS (rather 4535 * than truncating to DIGITS+1). 4536 * </ol> 4537 */ 4538 4539 @Test 4540 public void diagmath() { 4541 com.ibm.icu.math.MathContext def; 4542 def = com.ibm.icu.math.MathContext.DEFAULT; 4543 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"); 4544 mathtest(2,def,"-410.832710","99.3588243E-502740862","-410.832710","-410.832710","-4.08198550E-502740858","-4.13483868E+502740862","","","1.36977786E+26"); 4545 mathtest(3,def,"80025.2340","-8.03097581","80017.2030","80033.2650","-642680.718","-9964.57167","-9964","4.59102916","5.94544517E-40"); 4546 mathtest(4,def,"81052020.2","-464525495","-383473475","545577515","-3.76507298E+16","-0.17448347","0","81052020.2",""); 4547 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"); 4548 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"); 4549 mathtest(7,def,"682.25316","54470185.6","54470867.9","-54469503.4","3.71624563E+10","0.0000125252586","0","682.25316","3.48578699E+154365541"); 4550 mathtest(8,def,"-257586757.","2082888.71","-255503868","-259669646","-5.36524548E+14","-123.668036","-123","-1391445.67","-1.26879515E+17519020"); 4551 mathtest(9,def,"319577540.E+242599761","60.7124561","3.19577540E+242599769","3.19577540E+242599769","1.94023374E+242599771","5.26378869E+242599767","","",""); 4552 mathtest(10,def,"-13769977.0","24371.3381","-13745605.7","-13794348.3","-3.35592765E+11","-565.007015","-565","-170.9735","-8.73734001E+173982"); 4553 mathtest(11,def,"-475.434972E-725464311","-3.22214066E-865476836","-4.75434972E-725464309","-4.75434972E-725464309","","1.47552519E+140012527","","",""); 4554 mathtest(12,def,"842.01250","197199893","197200735","-197199051","1.66044775E+11","0.00000426984258","0","842.01250","7.00674164E+576872502"); 4555 mathtest(13,def,"572.173103E+280128428","-7140.19428","5.72173103E+280128430","5.72173103E+280128430","-4.08542712E+280128434","-8.01341085E+280128426","","",""); 4556 mathtest(14,def,"674235.954E+476135291","9684.82245","6.74235954E+476135296","6.74235954E+476135296","6.52985550E+476135300","6.96177919E+476135292","","",""); 4557 mathtest(15,def,"-360557.921E+437116514","930428850","-3.60557921E+437116519","-3.60557921E+437116519","-3.35473492E+437116528","-3.87517993E+437116510","","",""); 4558 mathtest(16,def,"957165918E-394595705","1676.59073E-829618944","9.57165918E-394595697","9.57165918E-394595697","","5.70900161E+435023244","","","9.16166595E-789191393"); 4559 mathtest(17,def,"-2610864.40","31245912.7","28635048.3","-33856777.1","-8.15788411E+13","-0.0835585897","0","-2610864.40","-3.12008905E+200498284"); 4560 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"); 4561 mathtest(19,def,"-41085.0268","3115477.61","3074392.58","-3156562.64","-1.27999481E+11","-0.0131873927","0","-41085.0268","4.73844173E+14373829"); 4562 mathtest(20,def,"-723420285.","2681660.35","-720738625","-726101945","-1.93996749E+15","-269.765813","-269","-2053650.85","4.14324113E+23757873"); 4563 mathtest(21,def,"63542018.0E-817732230","-8836243.22","-8836243.22","8836243.22","-5.61472726E-817732216","-7.19106711E-817732230","0","6.35420180E-817732223",""); 4564 mathtest(22,def,"-96051.7108","-291201.955","-387253.666","195150.244","2.79704460E+10","0.329845694","0","-96051.7108","3.53617153E-1450916"); 4565 mathtest(23,def,"108490.853","91685996.5","91794487.4","-91577505.7","9.94709197E+12","0.00118328706","0","108490.853","6.98124265E+461675038"); 4566 mathtest(24,def,"-27489.1735","-9835835.4E-506411649","-27489.1735","-27489.1735","2.70378986E-506411638","2.79479804E+506411646","","","4.05866472E-45"); 4567 mathtest(25,def,"-89220406.6","993391.008E-611041175","-89220406.6","-89220406.6","-8.86307496E-611041162","-8.98139865E+611041176","","","3.19625913E+79"); 4568 mathtest(26,def,"4.75502020","-17089144.9","-17089140.2","17089149.7","-81259229.2","-2.78247989E-7","0","4.75502020","1.0630191E-11571955"); 4569 mathtest(27,def,"68027916.2","-796883.839","67231032.4","68824800.0","-5.42103470E+13","-85.3674185","-85","292789.885","8.29415374E-6241744"); 4570 mathtest(28,def,"-8.01969439E+788605478","92154156.0","-8.01969439E+788605478","-8.01969439E+788605478","-7.39048168E+788605486","-8.70247717E+788605470","","",""); 4571 mathtest(29,def,"-8012.98341","96188.8651","88175.8817","-104201.849","-770759780","-0.0833046881","0","-8012.98341","-1.16010156E+375502"); 4572 mathtest(30,def,"21761476E+592330677","-9.70744506","2.17614760E+592330684","2.17614760E+592330684","-2.11248333E+592330685","-2.24173053E+592330683","","",""); 4573 mathtest(31,def,"-9840778.51","-17907.219","-9858685.73","-9822871.29","1.76220976E+11","549.542534","549","-9715.279","-6.62997437E-125225"); 4574 mathtest(32,def,"-4.1097614","-819.225776E-145214751","-4.10976140","-4.10976140","3.36682247E-145214748","5.01664074E+145214748","","","0.0000122876018"); 4575 mathtest(33,def,"-448.880985","-394.087374E-442511435","-448.880985","-448.880985","1.76898329E-442511430","1.13903925E+442511435","","","2.46306099E-11"); 4576 mathtest(34,def,"779.445304E+882688544","-797868519","7.79445304E+882688546","7.79445304E+882688546","-6.21894870E+882688555","-9.7690946E+882688537","","",""); 4577 mathtest(35,def,"799995477","-6.23675208E+156309440","-6.23675208E+156309440","6.23675208E+156309440","-4.98937346E+156309449","-1.28271169E-156309432","0","799995477","3.81482667E-54"); 4578 mathtest(36,def,"-51932.8170","591840275E-278480289","-51932.8170","-51932.8170","-3.07359327E-278480276","-8.7748028E+278480284","","","1.96178443E+28"); 4579 mathtest(37,def,"70.3552392","-4228656.73","-4228586.38","4228727.09","-297508156","-0.0000166377277","0","70.3552392","9.14742382E-7811584"); 4580 mathtest(38,def,"1588359.34","-12232799.2","-10644439.9","13821158.5","-1.94300809E+13","-0.129844307","0","1588359.34","1.56910086E-75854960"); 4581 mathtest(39,def,"2842.16206","-3.23234345","2838.92972","2845.39440","-9186.84392","-879.288388","-879","0.93216745","4.35565514E-11"); 4582 mathtest(40,def,"29960.2305","45.2735747E-95205475","29960.2305","29960.2305","1.35640673E-95205469","6.61759773E+95205477","","","2.413936E+22"); 4583 mathtest(41,def,"2916565.77","1151935.43E-787118724","2916565.77","2916565.77","3.35969544E-787118712","2.53188303E+787118724","","","2916565.77"); 4584 mathtest(42,def,"-52723012.9E-967143787","79.4088237","79.4088237","-79.4088237","-4.18667244E-967143778","-6.63944011E-967143782","0","-5.27230129E-967143780",""); 4585 mathtest(43,def,"-167473465","793646.597","-166679819","-168267112","-1.32914746E+14","-211.017682","-211","-14033.033","-1.19053789E+6526910"); 4586 mathtest(44,def,"-31769071.0","133.4360","-31768937.6","-31769204.4","-4.23913776E+9","-238084.707","-238084","-94.3760","-5.84252432E+997"); 4587 mathtest(45,def,"45960.6383","-93352.7468","-47392.1085","139313.385","-4.29055183E+9","-0.492333004","0","45960.6383","1.88335323E-435248"); 4588 mathtest(46,def,"606.175648","5.28528458E-981983620","606.175648","606.175648","3.20381081E-981983617","1.14691203E+981983622","","","8.18450516E+13"); 4589 mathtest(47,def,"171578.617E+643006110","-407774.293","1.71578617E+643006115","1.71578617E+643006115","-6.99653492E+643006120","-4.20768597E+643006109","","",""); 4590 mathtest(48,def,"-682286332.","-464.871699","-682286797","-682285867","3.17175606E+11","1467687.39","1467687","-182.709787","-1.6050843E-4108"); 4591 mathtest(49,def,"492088.428","653.72170","492742.150","491434.706","321688884","752.74911","752","489.70960","3.94658596E+3722"); 4592 mathtest(50,def,"74303782.5","1141.68058","74304924.2","74302640.8","8.48311855E+10","65082.812","65082","926.99244","4.94849869E+8988"); 4593 mathtest(51,def,"74.7794084E+119375329","-34799355.6","7.47794084E+119375330","7.47794084E+119375330","-2.60227522E+119375338","-2.14887337E+119375323","","",""); 4594 mathtest(52,def,"-9432.08369","33735.5058","24303.4221","-43167.5895","-318196114","-0.279589218","0","-9432.08369","2.309567E+134087"); 4595 mathtest(53,def,"4249198.78E-112433155","418673051.","418673051","-418673051","1.77902502E-112433140","1.01492054E-112433157","0","4.24919878E-112433149",""); 4596 mathtest(54,def,"-2960933.02","-207933.38","-3168866.40","-2752999.64","6.15676811E+11","14.2398158","14","-49865.70","-2.75680397E-1345624"); 4597 mathtest(55,def,"29317.7519E+945600035","1.43555750","2.93177519E+945600039","2.93177519E+945600039","4.20873186E+945600039","2.04225549E+945600039","","","2.93177519E+945600039"); 4598 mathtest(56,def,"-51.1693770","-638055.414","-638106.583","638004.245","32648898.0","0.0000801958198","0","-51.1693770","-3.48266075E-1090443"); 4599 mathtest(57,def,"-756343055.","-68.9248344E+217100975","-6.89248344E+217100976","6.89248344E+217100976","5.21308198E+217100985","1.09734475E-217100968","0","-756343055","-7.06265897E-63"); 4600 mathtest(58,def,"2538.80406E+694185197","-3386499.65","2.53880406E+694185200","2.53880406E+694185200","-8.59765906E+694185206","-7.49683839E+694185193","","",""); 4601 mathtest(59,def,"-54344.0672","-8086.45235","-62430.5196","-46257.6149","439450710","6.72038427","6","-5825.35310","3.62916861E-38289"); 4602 mathtest(60,def,"3.31600054","217481648","217481651","-217481645","721169262","1.5247266E-8","0","3.31600054","3.73134969E+113224119"); 4603 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"); 4604 mathtest(62,def,"832689481","348040024E-882122501","832689481","832689481","2.89809267E-882122484","2.3925107E+882122501","","","5.77363381E+26"); 4605 mathtest(63,def,"14.5512326E+257500811","60.9979577E-647314724","1.45512326E+257500812","1.45512326E+257500812","8.87595471E-389813911","2.38552784E+904815534","","",""); 4606 mathtest(64,def,"-901.278844","449461667.","449460766","-449462568","-4.05090292E+11","-0.00000200524074","0","-901.278844",""); 4607 mathtest(65,def,"-5.32627675","-738860216E-238273224","-5.32627675","-5.32627675","3.93537399E-238273215","7.20877459E+238273215","","","-0.00000822306838"); 4608 mathtest(66,def,"-505383463.","3.18756328","-505383460","-505383466","-1.61094177E+9","-158548527","-158548527","-0.23671144","-1.29081226E+26"); 4609 mathtest(67,def,"769241.44E-720927320","-145382631.","-145382631","145382631","-1.11834344E-720927306","-5.29115091E-720927323","0","7.6924144E-720927315",""); 4610 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"); 4611 mathtest(69,def,"58.4721075","-712186829","-712186771","712186887","-4.16430648E+10","-8.21022028E-8","0","58.4721075",""); 4612 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"); 4613 mathtest(71,def,"45.5361397","-76579063.9","-76579018.4","76579109.4","-3.48711495E+9","-5.94629098E-7","0","45.5361397","3.98335374E-126995367"); 4614 mathtest(72,def,"594420.54E+685263039","-952420.179","5.94420540E+685263044","5.94420540E+685263044","-5.66138117E+685263050","-6.24115861E+685263038","","",""); 4615 mathtest(73,def,"-841310701.","9398110.4","-831912591","-850708811","-7.90673085E+15","-89.5191337","-89","-4878875.4","1.30001466E+83877722"); 4616 mathtest(74,def,"904392146E-140100276","168116093.","168116093","-168116093","1.52042874E-140100259","5.37956914E-140100276","0","9.04392146E-140100268",""); 4617 mathtest(75,def,"-907324792E+685539670","-15.6902171","-9.07324792E+685539678","-9.07324792E+685539678","1.42361230E+685539680","5.78274211E+685539677","","",""); 4618 mathtest(76,def,"987013606.","-26818.3572E+560907442","-2.68183572E+560907446","2.68183572E+560907446","-2.64700834E+560907455","-3.68036565E-560907438","0","987013606","1.0399934E-27"); 4619 mathtest(77,def,"-741317564","630.241530E-212782946","-741317564","-741317564","-4.67209116E-212782935","-1.1762436E+212782952","","","1.65968527E+53"); 4620 mathtest(78,def,"61867907.2","-139204670","-77336763","201072577","-8.61230161E+15","-0.444438446","0","61867907.2",""); 4621 mathtest(79,def,"-273.622743E+531282717","-4543.68684","-2.73622743E+531282719","-2.73622743E+531282719","1.24325606E+531282723","6.02204229E+531282715","","",""); 4622 mathtest(80,def,"-383588949.","-428640583.","-812229532","45051634","1.64421791E+17","0.89489648","0","-383588949",""); 4623 mathtest(81,def,"-56182.2686","32.7741649","-56149.4944","-56215.0428","-1841326.94","-1714.22426","-1714","-7.3499614","-5.45476402E+156"); 4624 mathtest(82,def,"-6366384.30","332014.980","-6034369.32","-6698399.28","-2.11373496E+12","-19.1749911","-19","-58099.680","-3.05392399E+2258994"); 4625 mathtest(83,def,"-1.27897702","-8213776.03E-686519123","-1.27897702","-1.27897702","1.05052308E-686519116","1.55711212E+686519116","","","0.139668371"); 4626 mathtest(84,def,"65.4059036","401162145E+884155506","4.01162145E+884155514","-4.01162145E+884155514","2.62383726E+884155516","1.63041066E-884155513","0","65.4059036","18300704.1"); 4627 mathtest(85,def,"-20630916.8","158987411.E-480500612","-20630916.8","-20630916.8","-3.28005605E-480500597","-1.29764468E+480500611","","","4.25634728E+14"); 4628 mathtest(86,def,"-4.72705853","-97626742.4","-97626747.1","97626737.7","461487325","4.84197097E-8","0","-4.72705853","2.92654449E-65858120"); 4629 mathtest(87,def,"8.43528169","-4573.45752","-4565.02224","4581.89280","-38578.4025","-0.00184439927","0","8.43528169","8.84248688E-4236"); 4630 mathtest(88,def,"1.91075189","-704247089.","-704247087","704247091","-1.34564146E+9","-2.71318394E-9","0","1.91075189","6.84547494E-198037309"); 4631 mathtest(89,def,"31997198E-551746308","326.892584","326.892584","-326.892584","1.04596467E-551746298","9.78829119E-551746304","0","3.1997198E-551746301",""); 4632 mathtest(90,def,"127589.213","84184304.","84311893.2","-84056714.8","1.07410091E+13","0.00151559385","0","127589.213","2.87917042E+429829394"); 4633 mathtest(91,def,"714494248","-7025063.59","707469185","721519312","-5.01936753E+15","-101.706446","-101","4962825.41","1.65018516E-62199908"); 4634 mathtest(92,def,"-52987680.2E+279533503","-42014114.8","-5.29876802E+279533510","-5.29876802E+279533510","2.22623048E+279533518","1.26118759E+279533503","","",""); 4635 mathtest(93,def,"-8795.0513","-225294.394E-884414238","-8795.05130","-8795.05130","1.98147575E-884414229","3.90380388E+884414236","","","1.2927759E-8"); 4636 mathtest(94,def,"83280.1394","161566354.","161649634","-161483074","1.34552685E+13","0.000515454718","0","83280.1394","5.30774809E+794993940"); 4637 mathtest(95,def,"112.877897","-9.96481666","102.913080","122.842714","-1124.80755","-11.3276441","-11","3.26491374","2.97790545E-21"); 4638 mathtest(96,def,"-572542.121E+847487397","433.843420","-5.72542121E+847487402","-5.72542121E+847487402","-2.48393632E+847487405","-1.3196976E+847487400","","",""); 4639 mathtest(97,def,"4709649.89","20949266.4","25658916.3","-16239616.5","9.86637102E+13","0.224812163","0","4709649.89","4.85293644E+139794213"); 4640 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"); 4641 mathtest(99,def,"-213230447.","864.815822E+127783046","8.64815822E+127783048","-8.64815822E+127783048","-1.84405064E+127783057","-2.46561686E-127783041","0","-213230447","-9.11261361E+74"); 4642 mathtest(100,def,"-89.1168786E+403375873","6464.05744","-8.91168786E+403375874","-8.91168786E+403375874","-5.76056622E+403375878","-1.37865233E+403375871","","",""); 4643 mathtest(101,def,"61774.4958","-14000.7706","47773.7252","75775.2664","-864890545","-4.41222112","-4","5771.4134","7.59030407E-67077"); 4644 mathtest(102,def,"1.60731414","7.04330293E-427033419","1.60731414","1.60731414","1.13208004E-427033418","2.28204602E+427033418","","","27.7143921"); 4645 mathtest(103,def,"7955012.51","-230117662.","-222162650","238072675","-1.83058888E+15","-0.0345693261","0","7955012.51",""); 4646 mathtest(104,def,"4086661.08","1.77621994","4086662.86","4086659.30","7258808.90","2300762.98","2300762","1.73840572","1.67007988E+13"); 4647 mathtest(105,def,"-610.076931","-207.658306","-817.735237","-402.418625","126687.542","2.93788841","2","-194.760319","4.36518377E-580"); 4648 mathtest(106,def,"-98.6353697","-99253.3899E-716309653","-98.6353697","-98.6353697","9.78989481E-716309647","9.93773309E+716309649","","","1.14729007E-20"); 4649 mathtest(107,def,"-959923730","409.125542E-900295528","-959923730","-959923730","-3.92729316E-900295517","-2.3462816E+900295534","","","8.49076677E+35"); 4650 mathtest(108,def,"379965133","-8.15869657","379965125","379965141","-3.10002023E+9","-46571793.6","-46571793","5.19214999","2.30170697E-69"); 4651 mathtest(109,def,"833.646797","1389499.46E-443407251","833.646797","833.646797","1.15835177E-443407242","5.99961944E+443407247","","","833.646797"); 4652 mathtest(110,def,"2314933.4E-646489194","-7401538.17","-7401538.17","7401538.17","-1.71340679E-646489181","-3.12763826E-646489195","0","2.3149334E-646489188",""); 4653 mathtest(111,def,"808525347","-5959.74667E+58232168","-5.95974667E+58232171","5.95974667E+58232171","-4.81860624E+58232180","-1.35664382E-58232163","0","808525347","3.5796302E-54"); 4654 mathtest(112,def,"-17220490.6E+726428704","19.9855688","-1.72204906E+726428711","-1.72204906E+726428711","-3.44161300E+726428712","-8.61646259E+726428709","","",""); 4655 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"); 4656 mathtest(114,def,"16411470E+578192008","497470.005E-377473621","1.64114700E+578192015","1.64114700E+578192015","8.16421406E+200718399","3.29898684E+955665630","","",""); 4657 mathtest(115,def,"-107.353544E+609689808","-659.50136E-456711743","-1.07353544E+609689810","-1.07353544E+609689810","7.07998083E+152978069","","","",""); 4658 mathtest(116,def,"786.134163","-53.0292275E-664419768","786.134163","786.134163","-4.16880874E-664419764","-1.48245449E+664419769","","","3.33055532E-15"); 4659 mathtest(117,def,"23.5414714","5000786.91","5000810.45","-5000763.37","117725882","0.0000047075534","0","23.5414714","4.4895618E+6860247"); 4660 mathtest(118,def,"-69775.6113","561292120.","561222344","-561361896","-3.91645008E+13","-0.000124312473","0","-69775.6113",""); 4661 mathtest(119,def,"919043.871","-71606613.7","-70687569.8","72525657.6","-6.58096194E+13","-0.0128346227","0","919043.871","3.05862429E-427014317"); 4662 mathtest(120,def,"-27667.1915","-293455.107E-789181924","-27667.1915","-27667.1915","8.11907864E-789181915","9.42808315E+789181922","","","-4.72176938E-14"); 4663 mathtest(121,def,"-908603625.","-982.409273E+449441134","-9.82409273E+449441136","9.82409273E+449441136","8.92620627E+449441145","9.2487281E-449441129","0","-908603625","2.60768632E-90"); 4664 mathtest(122,def,"847.113351","5.71511268","852.828464","841.398238","4841.34825","148.223386","148","1.27667436","3.69529538E+17"); 4665 mathtest(123,def,"-992140475","3.82918218","-992140471","-992140479","-3.79908663E+9","-259099836","-259099836","-0.14787752","9.68930595E+35"); 4666 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"); 4667 mathtest(125,def,"3799470.64","-264.703992","3799205.94","3799735.34","-1.00573505E+9","-14353.6583","-14353","174.242824","2.3625466E-1744"); 4668 mathtest(126,def,"-8.11070247","-931284056.E-654288974","-8.11070247","-8.11070247","7.55336789E-654288965","8.70916067E+654288965","","","-6.58375662E-9"); 4669 mathtest(127,def,"-242660177.","-6.09832715E-943742415","-242660177","-242660177","1.47982115E-943742406","3.97912692E+943742422","","","4.89788901E-51"); 4670 mathtest(128,def,"76.1463803","-45.6758006E-636907996","76.1463803","76.1463803","-3.47804688E-636907993","-1.66710554E+636907996","","","3.90619287E-10"); 4671 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"); 4672 mathtest(130,def,"6203606.54","-195.92748E-833512061","6203606.54","6203606.54","-1.21545700E-833512052","-3.1662769E+833512065","","","2.59843292E-14"); 4673 mathtest(131,def,"-163274837.","95.0448550E+887876533","9.50448550E+887876534","-9.50448550E+887876534","-1.55184332E+887876543","-1.71787139E-887876527","0","-163274837","1.34645731E+82"); 4674 mathtest(132,def,"2.38638190","-807986179.","-807986177","807986181","-1.92816359E+9","-2.95349347E-9","0","2.38638190","1.19029305E-305208656"); 4675 mathtest(133,def,"-109022296E-811981158","7.19685680","7.19685680","-7.19685680","-7.84617852E-811981150","-1.51485988E-811981151","0","-1.09022296E-811981150",""); 4676 mathtest(134,def,"-559250.780E-273710421","-393780811.","-393780811","393780811","2.20222226E-273710407","1.42020831E-273710424","0","-5.59250780E-273710416",""); 4677 mathtest(135,def,"-88021.9966E+555334642","7599686.64E+818884053","7.59968664E+818884059","-7.59968664E+818884059","","-1.15823192E-263549413","0","-8.80219966E+555334646",""); 4678 mathtest(136,def,"194.317648E-197450009","-930.979064","-930.979064","930.979064","-1.80905662E-197450004","-2.08723972E-197450010","0","1.94317648E-197450007",""); 4679 mathtest(137,def,"9495479.65","7405697.96","16901177.6","2089781.69","7.03206543E+13","1.28218565","1","2089781.69","1.0135446E+51673383"); 4680 mathtest(138,def,"-1656.28925","-163050511E-682882380","-1656.28925","-1656.28925","2.70058809E-682882369","1.01581359E+682882375","","","3.64525265E-7"); 4681 mathtest(139,def,"95581.3784E+64262149","-99.2879365","9.55813784E+64262153","9.55813784E+64262153","-9.49007783E+64262155","-9.62668596E+64262151","","",""); 4682 mathtest(140,def,"643761.452","3.73446939","643765.186","643757.718","2404107.44","172383.647","172383","2.41514363","1.71751236E+23"); 4683 mathtest(141,def,"7960.49866E-129827423","3220.22850","3220.22850","-3220.22850","2.56346247E-129827416","2.47202913E-129827423","0","7.96049866E-129827420",""); 4684 mathtest(142,def,"-6356.64112E-707203818","1805054.98","1805054.98","-1805054.98","-1.14740867E-707203808","-3.52157756E-707203821","0","-6.35664112E-707203815",""); 4685 mathtest(143,def,"2.3904042","8476.52006","8478.91046","-8474.12966","20262.3092","0.000282003013","0","2.3904042","2.00251752E+3208"); 4686 mathtest(144,def,"-713298.658","-957.782729","-714256.441","-712340.875","683185135","744.739528","744","-708.307624","3.68122321E-5608"); 4687 mathtest(145,def,"607779233.E-820497365","-20.1188742E-857318323","6.07779233E-820497357","6.07779233E-820497357","","-3.02094057E+36820965","","",""); 4688 mathtest(146,def,"-205888251","-908.792922E+250680613","-9.08792922E+250680615","9.08792922E+250680615","1.87109785E+250680624","2.26551336E-250680608","0","-205888251","-1.5042358E-75"); 4689 mathtest(147,def,"51542399.1","-23212.2414","51519186.9","51565611.3","-1.19641461E+12","-2220.4835","-2220","11223.1920","1.71641348E-179015"); 4690 mathtest(148,def,"4.44287230","158923023","158923027","-158923019","706074697","2.79561275E-8","0","4.44287230","7.12573416E+102928693"); 4691 mathtest(149,def,"-79123682.6","-3.8571770","-79123686.5","-79123678.8","305194049","20513365.8","20513365","-2.9293950","2.55137345E-32"); 4692 mathtest(150,def,"-80.3324347E-569715030","883142.351","883142.351","-883142.351","-7.09449752E-569715023","-9.09620455E-569715035","0","-8.03324347E-569715029",""); 4693 mathtest(151,def,"13637.483","-52798.5631","-39161.0801","66436.0461","-720039507","-0.258292692","0","13637.483","1.47163791E-218310"); 4694 mathtest(152,def,"6.42934843E-276476458","84057440.0E-388039782","6.42934843E-276476458","6.42934843E-276476458","5.40434570E-664516232","7.64875593E+111563316","","",""); 4695 mathtest(153,def,"-5.64133087","-17401297.","-17401302.6","17401291.4","98166473.9","3.24190253E-7","0","-5.64133087","-1.25908916E-13075014"); 4696 mathtest(154,def,"95469.7057E+865733824","198.829749","9.54697057E+865733828","9.54697057E+865733828","1.89822176E+865733831","4.80158056E+865733826","","",""); 4697 mathtest(155,def,"-416466.209","-930153427","-930569893","929736961","3.87377472E+14","0.000447739262","0","-416466.209",""); 4698 mathtest(156,def,"-1541733.85","-1.99208708","-1541735.84","-1541731.86","3071268.08","773928.944","773928","-1.88034976","4.20708401E-13"); 4699 mathtest(157,def,"-39152691.8","-645131748.","-684284440","605979056","2.52586445E+16","0.0606894513","0","-39152691.8",""); 4700 mathtest(158,def,"113.939979","-58282550.4","-58282436.5","58282664.3","-6.64071257E+9","-0.0000019549587","0","113.939979","2.106557E-119868330"); 4701 mathtest(159,def,"-324971.736","-9517.15154","-334488.888","-315454.585","3.09280526E+9","34.1459033","34","-1388.58364","-5.82795263E-52457"); 4702 mathtest(160,def,"-76.9436744","-9548122.75E-273599728","-76.9436744","-76.9436744","7.34667648E-273599720","8.05851332E+273599722","","","1.37489895E-19"); 4703 mathtest(161,def,"-430393.282","-70.2551505","-430463.537","-430323.027","30237344.8","6126.14561","6126","-10.2300370","4.26006409E-395"); 4704 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"); 4705 mathtest(163,def,"23.1543212E-655822712","5848.20853","5848.20853","-5848.20853","1.35411299E-655822707","3.95921607E-655822715","0","2.31543212E-655822711",""); 4706 mathtest(164,def,"-174.261308E-82902077","-200096204.","-200096204","200096204","3.48690262E-82902067","8.70887626E-82902084","0","-1.74261308E-82902075",""); 4707 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"); 4708 mathtest(166,def,"424768856.","-971.71757","424767884","424769828","-4.12755361E+11","-437132.012","-437132","11.19076","2.72651473E-8387"); 4709 mathtest(167,def,"7181.2767","999117.918","1006299.19","-991936.641","7.17494223E+9","0.00718761677","0","7181.2767","3.09655124E+3852800"); 4710 mathtest(168,def,"8096417.07E-433694528","-68.4863363","-68.4863363","68.4863363","-5.54493942E-433694520","-1.18219451E-433694523","0","8.09641707E-433694522",""); 4711 mathtest(169,def,"1236287.5","-7119.97299E-176200498","1236287.50","1236287.50","-8.80233361E-176200489","-1.73636544E+176200500","","","2.26549784E-43"); 4712 mathtest(170,def,"-752995833E-654401067","-15.2736930E+803939983","-1.52736930E+803939984","1.52736930E+803939984","1.15010272E+149538926","","0","-7.52995833E-654401059",""); 4713 mathtest(171,def,"702992.459","-312.689474","702679.770","703305.148","-219818342","-2248.21274","-2248","66.521448","8.02493322E-1831"); 4714 mathtest(172,def,"-4414.38805","-17680.4630E-584364536","-4414.38805","-4414.38805","7.80484246E-584364529","2.49676044E+584364535","","","5.13167312E-8"); 4715 mathtest(173,def,"9.46350807","7826.65424","7836.11775","-7817.19073","74067.6056","0.00120913839","0","9.46350807","3.63271495E+7639"); 4716 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"); 4717 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"); 4718 mathtest(176,def,"66.2319284E+730468479","25.9391685E+221147044","6.62319284E+730468480","6.62319284E+730468480","1.71800115E+951615526","2.55335588E+509321435","","",""); 4719 mathtest(177,def,"317997088.E-90968742","-977426.461","-977426.461","977426.461","-3.10818768E-90968728","-3.2534119E-90968740","0","3.17997088E-90968734",""); 4720 mathtest(178,def,"227473386","-6759.61390","227466626","227480146","-1.53763226E+12","-33651.8312","-33651","5618.65110","1.40992627E-56493"); 4721 mathtest(179,def,"-392019.462","-245456.503","-637475.965","-146562.959","9.62237263E+10","1.59710359","1","-146562.959","-3.08656533E-1372917"); 4722 mathtest(180,def,"-3619556.28E+587673583","-3.45236972","-3.61955628E+587673589","-3.61955628E+587673589","1.24960465E+587673590","1.04842661E+587673589","","",""); 4723 mathtest(181,def,"-249.400704E-923930848","831102.919","831102.919","-831102.919","-2.07277653E-923930840","-3.00084019E-923930852","0","-2.49400704E-923930846",""); 4724 mathtest(182,def,"65234.2739E+154949914","-694581895","6.52342739E+154949918","6.52342739E+154949918","-4.53105456E+154949927","-9.39187652E+154949909","","",""); 4725 mathtest(183,def,"45.2316213","-88775083.4","-88775038.2","88775128.6","-4.01544095E+9","-5.09508069E-7","0","45.2316213","1.92314254E-146962015"); 4726 mathtest(184,def,"331100375.","442.343378","331100817","331099933","1.46460058E+11","748514.37","748514","163.759708","6.64011043E+3765"); 4727 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"); 4728 mathtest(186,def,"-5738.13069E+789464078","33969715.0","-5.73813069E+789464081","-5.73813069E+789464081","-1.94922664E+789464089","-1.68919012E+789464074","","",""); 4729 mathtest(187,def,"-7413.03911","2.70630320E-254858264","-7413.03911","-7413.03911","-2.00619315E-254858260","-2.73917539E+254858267","","","-4.07369842E+11"); 4730 mathtest(188,def,"-417696.182","27400.6002","-390295.582","-445096.782","-1.14451261E+10","-15.2440523","-15","-6687.1790","-1.58020334E+154017"); 4731 mathtest(189,def,"68.8538735E+655647287","3198.17933E-132454826","6.88538735E+655647288","6.88538735E+655647288","2.20207035E+523192466","2.15290846E+788102111","","",""); 4732 mathtest(190,def,"-6817.04246","434420.439","427603.397","-441237.481","-2.96146258E+9","-0.0156922692","0","-6817.04246","5.94143518E+1665390"); 4733 mathtest(191,def,"8578.27511","647042.341E-490924334","8578.27511","8578.27511","5.55050721E-490924325","1.3257672E+490924332","","","3.98473846E+23"); 4734 mathtest(192,def,"4124.11615E+733109424","597385828E+375928745","4.12411615E+733109427","4.12411615E+733109427","","6.9036056E+357180673","","",""); 4735 mathtest(193,def,"102.714400","-919017.468","-918914.754","919120.182","-94396327.8","-0.000111765449","0","102.714400","4.04295689E-1848724"); 4736 mathtest(194,def,"-4614.33015E+996778733","-433.560812E+22860599","-4.61433015E+996778736","-4.61433015E+996778736","","1.06428672E+973918135","","",""); 4737 mathtest(195,def,"457455170.","3709230.48E+677010879","3.70923048E+677010885","-3.70923048E+677010885","1.69680666E+677010894","1.23328861E-677010877","0","457455170","4.37919376E+34"); 4738 mathtest(196,def,"-2522468.15","-48482043.5","-51004511.7","45959575.4","1.22294411E+14","0.0520289156","0","-2522468.15","1.42348178E-310373595"); 4739 mathtest(197,def,"-659811384","62777.6118","-659748606","-659874162","-4.14213829E+13","-10510.2976","-10510","-18683.9820","3.4393524E+553665"); 4740 mathtest(198,def,"4424.94176","-825848.20","-821423.258","830273.142","-3.65433019E+9","-0.00535805704","0","4424.94176","3.42152775E-3010966"); 4741 mathtest(199,def,"43.6441884","-6509.89663E-614169377","43.6441884","43.6441884","-2.84119155E-614169372","-6.70428286E+614169374","","","3.31524056E-12"); 4742 mathtest(200,def,"897.388381E-843864876","84195.1369","84195.1369","-84195.1369","7.55557376E-843864869","1.06584348E-843864878","0","8.97388381E-843864874",""); 4743 mathtest(201,def,"796199825","496.76834","796200322","796199328","3.95526865E+11","1602758.79","1602758","393.91828","6.42647264E+4423"); 4744 mathtest(202,def,"573583582","1598.69521","573585181","573581983","9.16985325E+11","358782.323","358782","517.16578","9.91156302E+14004"); 4745 mathtest(203,def,"-783144270.","6347.71496","-783137922","-783150618","-4.97117660E+12","-123374.202","-123374","-1284.52496","1.28110803E+56458"); 4746 mathtest(204,def,"26909234.7","52411.5081","26961646.2","26856823.2","1.41035357E+12","513.422255","513","22131.0447","9.75836528E+389415"); 4747 mathtest(205,def,"8.21915282","24859.7841E-843282959","8.21915282","8.21915282","2.04326365E-843282954","3.30620443E+843282955","","","67.5544731"); 4748 mathtest(206,def,"-688.387710","82783.5207E-831870858","-688.387710","-688.387710","-5.69871582E-831870851","-8.31551623E+831870855","","","5.04272012E+22"); 4749 mathtest(207,def,"-9792232.","-1749.01166","-9793981.01","-9790482.99","1.71267279E+10","5598.72311","5598","-1264.72732","-8.86985674E-12228"); 4750 mathtest(208,def,"-130.765600","8.67437427","-122.091226","-139.439974","-1134.30976","-15.0749317","-15","-0.64998595","-1.11799947E+19"); 4751 mathtest(209,def,"917.259102","-368640.426","-367723.167","369557.685","-338138786","-0.00248822169","0","917.259102","8.67104255E-1092094"); 4752 mathtest(210,def,"-4.9725631","-294563717.","-294563722","294563712","1.46473667E+9","1.6881112E-8","0","-4.9725631","-6.27962584E-205187284"); 4753 mathtest(211,def,"-60962887.2E-514249661","-243021.407","-243021.407","243021.407","1.48152866E-514249648","2.5085398E-514249659","0","-6.09628872E-514249654",""); 4754 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"); 4755 mathtest(213,def,"681.666010","626886700","626887382","-626886018","4.27327356E+11","0.00000108738311","0","681.666010",""); 4756 mathtest(214,def,"6.42652138","53465894.5","53465900.9","-53465888.1","343599714","1.2019852E-7","0","6.42652138","4.61155532E+43199157"); 4757 mathtest(215,def,"561546656","651408.476","562198064","560895248","3.65796251E+14","862.049968","862","32549.688","8.6052377E+5699419"); 4758 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"); 4759 mathtest(217,def,"54486.2112","10.7565078","54496.9677","54475.4547","586081.356","5065.41828","5065","4.4991930","1.25647168E+52"); 4760 mathtest(218,def,"16576482.5","-2217720.83","14358761.7","18794203.3","-3.67620105E+13","-7.47455779","-7","1052436.69","1.38259374E-16010820"); 4761 mathtest(219,def,"61.2793787E-392070111","6.22575651","6.22575651","-6.22575651","3.81510491E-392070109","9.84288072E-392070111","0","6.12793787E-392070110",""); 4762 mathtest(220,def,"5115136.39","-653674372.","-648559236","658789508","-3.34363357E+15","-0.00782520565","0","5115136.39",""); 4763 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",""); 4764 mathtest(222,def,"-387781.3E+284108380","-218085.592","-3.87781300E+284108385","-3.87781300E+284108385","8.45695144E+284108390","1.77811517E+284108380","","",""); 4765 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"); 4766 mathtest(224,def,"-20837.2900E-168652772","-8236.78305E-712819173","-2.08372900E-168652768","-2.08372900E-168652768","1.71632237E-881471937","2.52978497E+544166401","","",""); 4767 mathtest(225,def,"-98573.8722E+829022366","309011.007","-9.85738722E+829022370","-9.85738722E+829022370","-3.04604115E+829022376","-3.18997932E+829022365","","",""); 4768 mathtest(226,def,"49730750.7","-5315.10636E-299586991","49730750.7","49730750.7","-2.64324229E-299586980","-9.35649211E+299586994","","","3.28756936E-39"); 4769 mathtest(227,def,"1539523.40","-962388.581","577134.82","2501911.98","-1.48161974E+12","-1.59969001","-1","577134.819","3.10144834E-5954673"); 4770 mathtest(228,def,"81596.2121","-37600.9653","43995.2468","119197.177","-3.06809634E+9","-2.17005631","-2","6394.2815","1.97878299E-184684"); 4771 mathtest(229,def,"590146199","-1425404.61","588720794","591571604","-8.41197113E+14","-414.020128","-414","28690.46","2.04650994E-12502170"); 4772 mathtest(230,def,"196.05543","505.936305","701.991735","-309.880875","99191.5598","0.387510104","0","196.05543","8.78437397E+1159"); 4773 mathtest(231,def,"77.8058449","-642.275274","-564.469429","720.081119","-49972.7704","-0.121140963","0","77.8058449","9.33582626E-1215"); 4774 mathtest(232,def,"1468.60684","10068.138","11536.7448","-8599.5312","14786136.3","0.145866777","0","1468.60684","2.54122484E+31884"); 4775 mathtest(233,def,"4.98774767E-387968632","4.41731439E-578812376","4.98774767E-387968632","4.98774767E-387968632","2.20324496E-966781007","1.12913577E+190843744","","",""); 4776 mathtest(234,def,"981.091059","-92238.9930","-91257.9020","93220.0841","-90494851.3","-0.0106364025","0","981.091059","5.29943342E-275953"); 4777 mathtest(235,def,"-3606.24992","8290224.70","8286618.45","-8293830.95","-2.98966222E+10","-0.000435000262","0","-3606.24992","-1.23747107E+29488793"); 4778 mathtest(236,def,"-8978571.35","92243.4796","-8886327.87","-9070814.83","-8.28214663E+11","-97.3355666","-97","-30953.8288","-4.95762813E+641384"); 4779 mathtest(237,def,"-61968.1992E+810060478","474294671.E+179263414","-6.19681992E+810060482","-6.19681992E+810060482","-2.93911867E+989323905","-1.30653374E+630797060","","",""); 4780 mathtest(238,def,"61298431.6E-754429041","-2584862.79","-2584862.79","2584862.79","-1.58448035E-754429027","-2.37143851E-754429040","0","6.12984316E-754429034",""); 4781 mathtest(239,def,"621039.064","-5351539.62","-4730500.56","5972578.68","-3.32351516E+12","-0.116048672","0","621039.064","2.41163312E-31002108"); 4782 mathtest(240,def,"-19.6007605","-57905696.","-57905715.6","57905676.4","1.13499568E+9","3.38494515E-7","0","-19.6007605","1.05663646E-74829963"); 4783 mathtest(241,def,"3626.13109E+687030346","189.896004","3.62613109E+687030349","3.62613109E+687030349","6.88587804E+687030351","1.90953523E+687030347","","",""); 4784 mathtest(242,def,"-249334.026","-7.54735834E-14137188","-249334.026","-249334.026","1.88181324E-14137182","3.30359332E+14137192","","","6.69495408E-44"); 4785 mathtest(243,def,"417613928.","-925213.216","416688715","418539141","-3.86381925E+14","-451.370474","-451","342767.584","8.38430085E-7976054"); 4786 mathtest(244,def,"23.8320309","-50074996.1","-50074972.3","50075019.9","-1.19338885E+9","-4.75926765E-7","0","23.8320309","5.81466387E-68961335"); 4787 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"); 4788 mathtest(246,def,"-8907163.61E-741867246","773651.288E-472033282","7.73651288E-472033277","-7.73651288E-472033277","","-1.15131504E-269833963","0","-8.90716361E-741867240",""); 4789 mathtest(247,def,"514021711.E+463536646","617441659.","5.14021711E+463536654","5.14021711E+463536654","3.17378418E+463536663","8.32502478E+463536645","","",""); 4790 mathtest(248,def,"998175750","2.39285478","998175752","998175748","2.38848961E+9","417148487","417148486","1.30513692","9.96354828E+17"); 4791 mathtest(249,def,"873575426.","647853.152E+497450781","6.47853152E+497450786","-6.47853152E+497450786","5.65948593E+497450795","1.3484158E-497450778","0","873575426","4.44429064E+53"); 4792 mathtest(250,def,"4352626.8","-130338048.E-744560911","4352626.80","4352626.80","-5.67312881E-744560897","-3.33949055E+744560909","","","2.29746322E-7"); 4793 mathtest(251,def,"437.286960","7.37560835","444.662568","429.911352","3225.25735","59.2882565","59","2.12606735","3.05749452E+18"); 4794 mathtest(252,def,"8498280.45E+220511522","588617612","8.49828045E+220511528","8.49828045E+220511528","5.00223754E+220511537","1.44376931E+220511520","","",""); 4795 mathtest(253,def,"-5320387.77","-7673237.46","-12993625.2","2352849.69","4.08245987E+13","0.693369363","0","-5320387.77","-1.30113745E-51609757"); 4796 mathtest(254,def,"587655375","-4.9748366","587655370","587655380","-2.92348947E+9","-118125563","-118125563","0.7919942","1.42687667E-44"); 4797 mathtest(255,def,"1266098.44","-2661.64904E-642601142","1266098.44","1266098.44","-3.36990970E-642601133","-4.75681963E+642601144","","","4.92717036E-19"); 4798 mathtest(256,def,"3.92737463E+482873483","-685.522747","3.92737463E+482873483","3.92737463E+482873483","-2.69230464E+482873486","-5.72902161E+482873480","","",""); 4799 mathtest(257,def,"22826494.1","986189474.","1.00901597E+9","-963362980","2.25112482E+16","0.0231461547","0","22826494.1",""); 4800 mathtest(258,def,"-647342.380","-498816386","-499463728","498169044","3.22904986E+14","0.00129775685","0","-647342.380",""); 4801 mathtest(259,def,"393092373.","-25.7226822","393092347","393092399","-1.01113902E+10","-15281935.6","-15281935","15.5939430","3.49252839E-224"); 4802 mathtest(260,def,"2.96253492","20.7444888","23.7070237","-17.7819539","61.4562725","0.142810698","0","2.96253492","8.03402246E+9"); 4803 mathtest(261,def,"53553.3750E+386955423","-732470876","5.35533750E+386955427","5.35533750E+386955427","-3.92262875E+386955436","-7.31133165E+386955418","","",""); 4804 mathtest(262,def,"-696451.406E-286535917","-73086090.8","-73086090.8","73086090.8","5.09009107E-286535904","9.52919219E-286535920","0","-6.96451406E-286535912",""); 4805 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"); 4806 mathtest(264,def,"-205123006.E-213752799","-78638468.6","-78638468.6","78638468.6","1.61305591E-213752783","2.60843083E-213752799","0","-2.05123006E-213752791",""); 4807 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"); 4808 mathtest(266,def,"3068999.37","2.21006212","3069001.58","3068997.16","6782679.25","1388648.46","1388648","1.02718624","9.41875713E+12"); 4809 mathtest(267,def,"625524274.","55.2468624","625524329","625524219","3.45582535E+10","11322349.3","11322349","16.7522224","6.21482943E+483"); 4810 mathtest(268,def,"61269134.9","-845761303.","-784492168","907030438","-5.18190634E+16","-0.0724425848","0","61269134.9",""); 4811 mathtest(269,def,"-2840.12099","-2856.76731E-82743650","-2840.12099","-2840.12099","8.11356480E-82743644","9.94173022E+82743649","","","-4.36505254E-11"); 4812 mathtest(270,def,"8.9538781","-7.56603391","1.38784419","16.5199120","-67.7453453","-1.18343087","-1","1.38784419","2.42053061E-8"); 4813 mathtest(271,def,"-56233547.2","509752530","453518983","-565986077","-2.86651930E+16","-0.110315386","0","-56233547.2",""); 4814 mathtest(272,def,"-3167.47853E-854859497","-110852115","-110852115","110852115","3.51121694E-854859486","2.85739116E-854859502","0","-3.16747853E-854859494",""); 4815 mathtest(273,def,"-5652.52092","-632243244.","-632248897","632237592","3.57376816E+12","0.00000894042123","0","-5652.52092",""); 4816 mathtest(274,def,"-946.009928","820090.66E-589278015","-946.009928","-946.009928","-7.75813906E-589278007","-1.15354311E+589278012","","","6.41454053E+23"); 4817 mathtest(275,def,"-367.757758","-959.626016","-1327.38377","591.868258","352909.912","0.383230292","0","-367.757758","1.14982199E-2463"); 4818 mathtest(276,def,"809926721.E-744611554","-67.6560549","-67.6560549","67.6560549","-5.47964467E-744611544","-1.19712378E-744611547","0","8.09926721E-744611546",""); 4819 mathtest(277,def,"-1725.08555","75586.3031","73861.2176","-77311.3887","-130392839","-0.0228227269","0","-1725.08555","3.70540587E+244657"); 4820 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"); 4821 mathtest(279,def,"-91.1431113","12147507.0","12147415.9","-12147598.1","-1.10716158E+9","-0.00000750303015","0","-91.1431113","-1.52417006E+23805759"); 4822 mathtest(280,def,"-1136778.91E+697783878","-801552569.","-1.13677891E+697783884","-1.13677891E+697783884","9.11188056E+697783892","1.41822128E+697783875","","",""); 4823 mathtest(281,def,"73123773.0E+433334149","63.3548930","7.31237730E+433334156","7.31237730E+433334156","4.63274881E+433334158","1.15419298E+433334155","","",""); 4824 mathtest(282,def,"-9765484.8","7979.90802E-234029715","-9765484.80","-9765484.80","-7.79276705E-234029705","-1.22375907E+234029718","","","8.27085614E+55"); 4825 mathtest(283,def,"-695010288","-8.26582820","-695010296","-695010280","5.74483564E+9","84082353.4","84082353","-3.45024540","1.83683495E-71"); 4826 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"); 4827 mathtest(285,def,"2862.95921","-32601248.6E-605861333","2862.95921","2862.95921","-9.33360449E-605861323","-8.78174712E+605861328","","","4.26142175E-11"); 4828 mathtest(286,def,"-13.133518E+246090516","-8.71269925E-945092108","-1.31335180E+246090517","-1.31335180E+246090517","1.14428392E-699001590","","","",""); 4829 mathtest(287,def,"-34671.2232","817710.762","783039.539","-852381.985","-2.83510323E+10","-0.0424003508","0","-34671.2232","-5.30788828E+3712382"); 4830 mathtest(288,def,"-22464769","62.4366060","-22464706.6","-22464831.4","-1.40262393E+9","-359801.252","-359801","-15.7245940","6.21042536E+455"); 4831 mathtest(289,def,"-9458.60887E-563051963","5676056.01","5676056.01","-5676056.01","-5.36875937E-563051953","-1.66640513E-563051966","0","-9.45860887E-563051960",""); 4832 mathtest(290,def,"-591.924123E-95331874","-134.596188","-134.596188","134.596188","7.96707305E-95331870","4.39777777E-95331874","0","-5.91924123E-95331872",""); 4833 mathtest(291,def,"-182566085.E+68870646","-960345993.","-1.82566085E+68870654","-1.82566085E+68870654","1.75326608E+68870663","1.9010449E+68870645","","",""); 4834 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"); 4835 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"); 4836 mathtest(294,def,"-2.09044362E-876527908","-6515463.33","-6515463.33","6515463.33","1.36202087E-876527901","3.20843433E-876527915","0","-2.09044362E-876527908",""); 4837 mathtest(295,def,"-194343.344","1.95929977","-194341.385","-194345.303","-380776.869","-99190.2041","-99190","-0.39981370","3.77693354E+10"); 4838 mathtest(296,def,"-326002.927","4215.99030","-321786.937","-330218.917","-1.37442518E+9","-77.3253503","-77","-1371.67390","5.51875821E+23243"); 4839 mathtest(297,def,"-12037.8590E+876429044","314.81827","-1.20378590E+876429048","-1.20378590E+876429048","-3.78973794E+876429050","-3.82374854E+876429045","","",""); 4840 mathtest(298,def,"21036045.4E-162804809","-91.7149219","-91.7149219","91.7149219","-1.92931926E-162804800","-2.2936339E-162804804","0","2.10360454E-162804802",""); 4841 mathtest(299,def,"-947019.534","9916.29280","-937103.241","-956935.827","-9.39092299E+9","-95.5013686","-95","-4971.71800","3.76029022E+59261"); 4842 mathtest(300,def,"-5985.84136","-12.4090184E-12364204","-5985.84136","-5985.84136","7.42784156E-12364200","4.82378313E+12364206","","","-0.000167060893"); 4843 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"); 4844 mathtest(302,def,"-94.1947070E-938257103","15003.240","15003.2400","-15003.2400","-1.41322580E-938257097","-6.27829102E-938257106","0","-9.41947070E-938257102",""); 4845 mathtest(303,def,"-4846233.6","-8289769.76","-13136003.4","3443536.16","4.01741607E+13","0.584604125","0","-4846233.6","4.25077524E-55420465"); 4846 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"); 4847 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"); 4848 mathtest(306,def,"22780314.3","8805279.83","31585594.1","13975034.5","2.00587042E+14","2.58711986","2","5169754.64","2.39132169E+64785373"); 4849 mathtest(307,def,"596745.184","197602423.","198199168","-197005678","1.17918294E+14","0.00301992848","0","596745.184",""); 4850 mathtest(308,def,"171.340497","-480349.924","-480178.584","480521.264","-82303394.7","-0.000356699332","0","171.340497","2.17914102E-1073035"); 4851 mathtest(309,def,"824.65555","-379287.530","-378462.875","380112.186","-312781567","-0.00217422268","0","824.65555","6.35829256E-1106108"); 4852 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"); 4853 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",""); 4854 mathtest(312,def,"-850.123915E+662955309","6774849.81E-846576865","-8.50123915E+662955311","-8.50123915E+662955311","-5.75946184E-183621547","","","",""); 4855 mathtest(313,def,"-23349.7724","2921.35355","-20428.4189","-26271.1260","-68212940.5","-7.99279238","-7","-2900.29755","-5.6705546E+12759"); 4856 mathtest(314,def,"18886653.3","568707476.","587594129","-549820823","1.07409809E+16","0.0332097855","0","18886653.3",""); 4857 mathtest(315,def,"-90552818.0","-542.03563E-986606878","-90552818.0","-90552818.0","4.90828538E-986606868","1.67060638E+986606883","","","-1.64244241E-40"); 4858 mathtest(316,def,"41501126.1E+791838765","-69.6651675E+204268348","4.15011261E+791838772","4.15011261E+791838772","-2.89118290E+996107122","-5.95722763E+587570422","","",""); 4859 mathtest(317,def,"76783193.3E-271488154","3765.01829E-520346003","7.67831933E-271488147","7.67831933E-271488147","2.89090127E-791834146","2.03938434E+248857853","","",""); 4860 mathtest(318,def,"4192.9928","987822007E-146560989","4192.99280","4192.99280","4.14193056E-146560977","4.24468454E+146560983","","","1.67973653E+36"); 4861 mathtest(319,def,"-891845.629","48277955.","47386109.4","-49169800.6","-4.30564831E+13","-0.0184731443","0","-891845.629","-6.32964147E+287267817"); 4862 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"); 4863 mathtest(321,def,"4.49868636","-341880896E-447251873","4.49868636","4.49868636","-1.53801492E-447251864","-1.31586363E+447251865","","","0.010983553"); 4864 mathtest(322,def,"807615.58","-314286480","-313478865","315094096","-2.53822658E+14","-0.00256967968","0","807615.58",""); 4865 mathtest(323,def,"-37.7457954","53277.8129E-859225538","-37.7457954","-37.7457954","-2.01101343E-859225532","-7.08471188E+859225534","","","-76620134.1"); 4866 mathtest(324,def,"-28671081.","98.8819623","-28670982.1","-28671179.9","-2.83505275E+9","-289952.589","-289952","-58.2671904","-1.93625566E+738"); 4867 mathtest(325,def,"-89752.2106E-469496896","99.9879961","99.9879961","-99.9879961","-8.97414368E-469496890","-8.97629857E-469496894","0","-8.97522106E-469496892",""); 4868 mathtest(326,def,"-497983567E-13538052","39.4578742","39.4578742","-39.4578742","-1.96493729E-13538042","-1.26206385E-13538045","0","-4.97983567E-13538044","-1.55376543E-527983689"); 4869 mathtest(327,def,"845739221E-654202565","-33313.1551","-33313.1551","33313.1551","-2.81742418E-654202552","-2.53875449E-654202561","0","8.45739221E-654202557",""); 4870 mathtest(328,def,"742.332067E+537827843","-4532.70023E-855387414","7.42332067E+537827845","7.42332067E+537827845","-3.36476873E-317559565","","","",""); 4871 mathtest(329,def,"-893.48654","670389960","670389067","-670390853","-5.98984406E+11","-0.00000133278628","0","-893.48654",""); 4872 mathtest(330,def,"1.37697162","-915.737474E-351578724","1.37697162","1.37697162","-1.26094451E-351578721","-1.50367508E+351578721","","","0.0561920784"); 4873 mathtest(331,def,"-65.2839808E+550288403","-121389.306","-6.52839808E+550288404","-6.52839808E+550288404","7.92477712E+550288409","5.37806689E+550288399","","",""); 4874 mathtest(332,def,"-30346603.E+346067390","792661.544","-3.03466030E+346067397","-3.03466030E+346067397","-2.40545852E+346067403","-3.82844396E+346067391","","",""); 4875 mathtest(333,def,"-61170.7065","-453731131.","-453792302","453669960","2.77550538E+13","0.000134817081","0","-61170.7065",""); 4876 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"); 4877 mathtest(335,def,"300703925.","-3156736.8","297547188","303860662","-9.49243146E+14","-95.2578387","-95","813929.0","4.18609114E-26763256"); 4878 mathtest(336,def,"192138216E+353011592","-473.080633","1.92138216E+353011600","1.92138216E+353011600","-9.08968688E+353011602","-4.06142637E+353011597","","",""); 4879 mathtest(337,def,"8607.64794","-34740.3367","-26132.6888","43347.9846","-299032588","-0.247770999","0","8607.64794","1.29604519E-136698"); 4880 mathtest(338,def,"-67913.8241","-93815.4229","-161729.247","25901.5988","6.37136413E+9","0.723908948","0","-67913.8241","-6.96355203E-453311"); 4881 mathtest(339,def,"34.5559455","-998799398.","-998799364","998799433","-3.45144576E+10","-3.45974833E-8","0","34.5559455",""); 4882 mathtest(340,def,"387995.328","990199543.E-124623607","387995.328","387995.328","3.84192796E-124623593","3.91835495E+124623603","","","7.73152138E+55"); 4883 mathtest(341,def,"-471.09166E-83521919","-441222368","-441222368","441222368","2.07856178E-83521908","1.06769669E-83521925","0","-4.7109166E-83521917",""); 4884 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"); 4885 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"); 4886 mathtest(344,def,"23.2745547","2.23194245E-221062592","23.2745547","23.2745547","5.19474666E-221062591","1.04279368E+221062593","","","541.704896"); 4887 mathtest(345,def,"671.083363E-218324205","-787150031","-787150031","787150031","-5.28243290E-218324194","-8.52548227E-218324212","0","6.71083363E-218324203",""); 4888 mathtest(346,def,"365167.80","-80263.6516","284904.148","445431.452","-2.93097011E+10","-4.54960362","-4","44113.1936","1.27052227E-446468"); 4889 mathtest(347,def,"-1.43297604E-65129780","56.598733E-135581942","-1.43297604E-65129780","-1.43297604E-65129780","-8.11046283E-200711721","-2.53181646E+70452160","","","8.65831881E-390778680"); 4890 mathtest(348,def,"416998859.","260.220323E-349285593","416998859","416998859","1.08511578E-349285582","1.60248383E+349285599","","","7.25111178E+25"); 4891 mathtest(349,def,"7267.17611E+862630607","4021.56861","7.26717611E+862630610","7.26717611E+862630610","2.92254473E+862630614","1.80705014E+862630607","","",""); 4892 mathtest(350,def,"12.2142434E+593908740","5.27236571E-396050748","1.22142434E+593908741","1.22142434E+593908741","6.43979581E+197857993","2.3166533E+989959488","","",""); 4893 mathtest(351,def,"-28.591932","-1.79153238E-817064576","-28.5919320","-28.5919320","5.12233720E-817064575","1.59594838E+817064577","","","0.00122324372"); 4894 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"); 4895 mathtest(353,def,"1.7270628","-1325026.67","-1325024.94","1325028.40","-2288404.27","-0.00000130341739","0","1.7270628","2.09260036E-314440"); 4896 mathtest(354,def,"33402118.","-5534.83745","33396583.2","33407652.8","-1.84875294E+11","-6034.8869","-6034","4908.82670","8.14473913E-41645"); 4897 mathtest(355,def,"-439842.506","-775110.807","-1214953.31","335268.301","3.40926680E+11","0.567457584","0","-439842.506","-1.84678472E-4374182"); 4898 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"); 4899 mathtest(357,def,"-14161.9142","8306.49493","-5855.4193","-22468.4091","-117635869","-1.70492059","-1","-5855.41927","1.65573372E+34479"); 4900 mathtest(358,def,"-6417227.13","16679.8842","-6400547.25","-6433907.01","-1.07038605E+11","-384.728518","-384","-12151.5972","3.58767978E+113546"); 4901 mathtest(359,def,"514825024.","-25.0446345E-103809457","514825024","514825024","-1.28936046E-103809447","-2.05563002E+103809464","","","7.32860062E-27"); 4902 mathtest(360,def,"525948196","219450390","745398586","306497806","1.15419537E+17","2.39666102","2","87047416",""); 4903 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"); 4904 mathtest(362,def,"330590422","74.359928E+535377965","7.43599280E+535377966","-7.43599280E+535377966","2.45826800E+535377975","4.44581418E-535377959","0","330590422","4.31550742E+59"); 4905 mathtest(363,def,"-3.48593871E-940579904","-20265.9640E-322988987","-2.02659640E-322988983","2.02659640E-322988983","","1.72009519E-617590921","0","-3.48593871E-940579904",""); 4906 mathtest(364,def,"-328103480.","-721.949371E-923938665","-328103480","-328103480","2.36874101E-923938654","4.54468822E+923938670","","","-2.4430038E-60"); 4907 mathtest(365,def,"-1857.01448","19081578.1","19079721.1","-19083435.1","-3.54347668E+10","-0.0000973197537","0","-1857.01448","8.44397087E+62374153"); 4908 mathtest(366,def,"347.28720E+145930771","-62821.9906E-676564106","3.47287200E+145930773","3.47287200E+145930773","-2.18172732E-530633328","-5.52811518E+822494874","","","5.69990135E-875584642"); 4909 mathtest(367,def,"-643.211399E+441807003","-50733419.2","-6.43211399E+441807005","-6.43211399E+441807005","3.26323135E+441807013","1.26782584E+441806998","","",""); 4910 mathtest(368,def,"-53991661.4E-843339554","20718.7346","20718.7346","-20718.7346","-1.11863890E-843339542","-2.60593431E-843339551","0","-5.39916614E-843339547",""); 4911 mathtest(369,def,"-900181424","-105763982.","-1.00594541E+9","-794417442","9.52067719E+16","8.51122856","8","-54069568","1.32627061E-947045602"); 4912 mathtest(370,def,"94218.7462E+563233951","19262.6382E+765263890","1.92626382E+765263894","-1.92626382E+765263894","","4.89126906E-202029939","0","9.42187462E+563233955",""); 4913 mathtest(371,def,"28549.271E+921331828","-2150590.40","2.85492710E+921331832","2.85492710E+921331832","-6.13977881E+921331838","-1.32750853E+921331826","","",""); 4914 mathtest(372,def,"810.7080E+779625763","5957.94044","8.10708000E+779625765","8.10708000E+779625765","4.83014998E+779625769","1.36071854E+779625762","","",""); 4915 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"); 4916 mathtest(374,def,"40216102.2E+292724544","661.025962","4.02161022E+292724551","4.02161022E+292724551","2.65838876E+292724554","6.08389148E+292724548","","",""); 4917 mathtest(375,def,"22785024.3E+783719168","399.505989E+137478666","2.27850243E+783719175","2.27850243E+783719175","9.10275367E+921197843","5.70329981E+646240506","","",""); 4918 mathtest(376,def,"515.591819E+821371364","-692137914.E-149498690","5.15591819E+821371366","5.15591819E+821371366","-3.56860646E+671872685","-7.44926421E+970870047","","",""); 4919 mathtest(377,def,"-536883072E+477911251","624996.301","-5.36883072E+477911259","-5.36883072E+477911259","-3.35549934E+477911265","-8.59017999E+477911253","","",""); 4920 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",""); 4921 mathtest(379,def,"762.071184","9851631.37","9852393.44","-9850869.30","7.50764438E+9","0.0000773548213","0","762.071184","4.02198436E+28392356"); 4922 mathtest(380,def,"5626.12471","72989818.3","72995444.4","-72984192.2","4.10649820E+11","0.0000770809524","0","5626.12471","1.79814757E+273727098"); 4923 mathtest(381,def,"-47207260.1","-2073.3152","-47209333.4","-47205186.8","9.78755299E+10","22768.9741","22768","-2019.6264","-6.02238319E-15909"); 4924 mathtest(382,def,"207.740860","-51.0390090","156.701851","258.779869","-10602.8876","-4.07023694","-4","3.5848240","6.40297515E-119"); 4925 mathtest(383,def,"-572.812464E-745934021","-182805872.E+604508681","-1.82805872E+604508689","1.82805872E+604508689","1.04713482E-141425329","","0","-5.72812464E-745934019",""); 4926 mathtest(384,def,"-6418504E+3531407","8459416.1","-6.41850400E+3531413","-6.41850400E+3531413","-5.42967961E+3531420","-7.58740784E+3531406","","",""); 4927 mathtest(385,def,"280689.531","-128212543","-127931854","128493233","-3.59879186E+13","-0.00218925173","0","280689.531","1.42173809E-698530938"); 4928 mathtest(386,def,"15.803551E-783422793","239108038E-489186308","2.39108038E-489186300","-2.39108038E-489186300","","6.60937672E-294236493","0","1.5803551E-783422792",""); 4929 mathtest(387,def,"26.515922","-9418242.96E-105481628","26.5159220","26.5159220","-2.49733396E-105481620","-2.81537885E+105481622","","","1.54326108E-13"); 4930 mathtest(388,def,"-88.1094557","-54029934.1","-54030022.2","54029846.0","4.76054809E+9","0.0000016307526","0","-88.1094557","5.05289826E-105089439"); 4931 mathtest(389,def,"6770.68602E-498420397","-6.11248908E-729616908","6.77068602E-498420394","6.77068602E-498420394","","-1.10768067E+231196514","","",""); 4932 mathtest(390,def,"-892973818.E-781904441","555201299.","555201299","-555201299","-4.95780224E-781904424","-1.60837847E-781904441","0","-8.92973818E-781904433",""); 4933 mathtest(391,def,"670175802E+135430680","27355195.4","6.70175802E+135430688","6.70175802E+135430688","1.83327900E+135430696","2.44990318E+135430681","","",""); 4934 mathtest(392,def,"-440950.26","205.477469E-677345561","-440950.260","-440950.260","-9.06053434E-677345554","-2.14597864E+677345564","","","1.94437132E+11"); 4935 mathtest(393,def,"-8.2335779","573665010E+742722075","5.73665010E+742722083","-5.73665010E+742722083","-4.72331555E+742722084","-1.43525886E-742722083","0","-8.2335779","311552.753"); 4936 mathtest(394,def,"452943.863","7022.23629","459966.099","445921.627","3.18067883E+9","64.5013703","64","3520.74044","5.54158976E+39716"); 4937 mathtest(395,def,"62874.1079","-52719654.1","-52656780.0","52782528.2","-3.31470122E+12","-0.0011926123","0","62874.1079","1.18819936E-252973775"); 4938 mathtest(396,def,"-7428.41741E+609772037","-46024819.3","-7.42841741E+609772040","-7.42841741E+609772040","3.41891569E+609772048","1.61400251E+609772033","","",""); 4939 mathtest(397,def,"2.27959297","41937.019","41939.2986","-41934.7394","95599.3337","0.0000543575348","0","2.27959297","2.89712423E+15007"); 4940 mathtest(398,def,"508692408E-671967782","8491989.20","8491989.20","-8491989.20","4.31981043E-671967767","5.99026207E-671967781","0","5.08692408E-671967774",""); 4941 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",""); 4942 mathtest(400,def,"97.0649652","-92.4485649E-151989098","97.0649652","97.0649652","-8.97351673E-151989095","-1.0499348E+151989098","","","1.30748728E-18"); 4943 mathtest(401,def,"297544.536E+360279473","8.80275007","2.97544536E+360279478","2.97544536E+360279478","2.61921019E+360279479","3.38013159E+360279477","","",""); 4944 mathtest(402,def,"-28861028.","82818.820E+138368758","8.28188200E+138368762","-8.28188200E+138368762","-2.39023628E+138368770","-3.48483932E-138368756","0","-28861028","4.81387013E+59"); 4945 mathtest(403,def,"36.2496238E+68828039","49243.00","3.62496238E+68828040","3.62496238E+68828040","1.78504022E+68828045","7.36137599E+68828035","","",""); 4946 mathtest(404,def,"22.447828E-476014683","-56067.5520","-56067.5520","56067.5520","-1.25859476E-476014677","-4.00371109E-476014687","0","2.2447828E-476014682",""); 4947 mathtest(405,def,"282688.791E+75011952","5.99789051","2.82688791E+75011957","2.82688791E+75011957","1.69553642E+75011958","4.7131369E+75011956","","","5.10330507E+450071744"); 4948 mathtest(406,def,"-981.860310E-737387002","-994046289","-994046289","994046289","9.76014597E-737386991","9.87741035E-737387009","0","-9.81860310E-737387000",""); 4949 mathtest(407,def,"-702.91210","-6444903.55","-6445606.46","6444200.64","4.53020069E+9","0.000109064797","0","-702.91210","1.70866703E-18348004"); 4950 mathtest(408,def,"972456720E-17536823","16371.2590","16371.2590","-16371.2590","1.59203408E-17536810","5.94002404E-17536819","0","9.72456720E-17536815",""); 4951 mathtest(409,def,"71471.2045","-74303278.4","-74231807.2","74374749.6","-5.31054481E+12","-0.00096188494","0","71471.2045","2.14535374E-360677853"); 4952 mathtest(410,def,"643.103951E+439708441","788251925.","6.43103951E+439708443","6.43103951E+439708443","5.06927927E+439708452","8.15860933E+439708434","","",""); 4953 mathtest(411,def,"4.30838663","-7.43110827","-3.12272164","11.7394949","-32.0160875","-0.579777131","0","4.30838663","0.0000362908645"); 4954 mathtest(412,def,"823.678025","-513.581840E-324453141","823.678025","823.678025","-4.23026076E-324453136","-1.60379118E+324453141","","","2.63762228E-15"); 4955 mathtest(413,def,"4461.81162","3.22081680","4465.03244","4458.59080","14370.6778","1385.30438","1385","0.98035200","8.8824688E+10"); 4956 mathtest(414,def,"-4458527.10","-99072605","-103531132","94614077.9","4.41717894E+14","0.0450026231","0","-4458527.10","-6.23928099E-658752715"); 4957 mathtest(415,def,"-577964618","487424368.","-90540250","-1.06538899E+9","-2.81714039E+17","-1.18575241","-1","-90540250",""); 4958 mathtest(416,def,"-867.036184","-57.1768608","-924.213045","-809.859323","49574.4072","15.1641096","15","-9.3832720","-3.40312837E-168"); 4959 mathtest(417,def,"771871921E-330504770","5.34285236","5.34285236","-5.34285236","4.12399771E-330504761","1.44468136E-330504762","0","7.71871921E-330504762",""); 4960 mathtest(418,def,"-338683.062E-728777518","166441931","166441931","-166441931","-5.63710628E-728777505","-2.03484218E-728777521","0","-3.38683062E-728777513",""); 4961 mathtest(419,def,"-512568743","-416376887.E-965945295","-512568743","-512568743","2.13421778E-965945278","1.23102112E+965945295","","","1.44874358E-35"); 4962 mathtest(420,def,"7447181.99","5318438.52","12765620.5","2128743.47","3.96073796E+13","1.40025723","1","2128743.47","1.21634782E+36548270"); 4963 mathtest(421,def,"54789.8207","93165435.2","93220225.0","-93110645.4","5.10451749E+12","0.000588091716","0","54789.8207","3.80769825E+441483035"); 4964 mathtest(422,def,"41488.5960","146.797094","41635.3931","41341.7989","6090405.33","282.625459","282","91.815492","6.84738153E+678"); 4965 mathtest(423,def,"785741.663E+56754529","-461.531732","7.85741663E+56754534","7.85741663E+56754534","-3.62644711E+56754537","-1.70246509E+56754532","","",""); 4966 mathtest(424,def,"-4.95436786","-3132.4233","-3137.37767","3127.46893","15519.1773","0.0015816406","0","-4.95436786","1.98062422E-2177"); 4967 mathtest(425,def,"77321.8478E+404626874","82.4797688","7.73218478E+404626878","7.73218478E+404626878","6.37748813E+404626880","9.3746441E+404626876","","",""); 4968 mathtest(426,def,"-7.99307725","-29153.7273","-29161.7204","29145.7342","233027.994","0.000274169994","0","-7.99307725","1.88688028E-26318"); 4969 mathtest(427,def,"-61.6337401E+474999517","5254.87092","-6.16337401E+474999518","-6.16337401E+474999518","-3.23877349E+474999522","-1.1728878E+474999515","","",""); 4970 mathtest(428,def,"-16.4043088","35.0064812","18.6021724","-51.4107900","-574.257128","-0.468607762","0","-16.4043088","-3.33831843E+42"); 4971 mathtest(429,def,"-8.41156520","-56508958.9","-56508967.3","56508950.5","475328792","1.48853657E-7","0","-8.41156520","-8.86365458E-52263827"); 4972 mathtest(430,def,"-360165.79E+503559835","-196688.515","-3.60165790E+503559840","-3.60165790E+503559840","7.08404744E+503559845","1.83114805E+503559835","","",""); 4973 mathtest(431,def,"-653236480.E+565648495","-930.445274","-6.53236480E+565648503","-6.53236480E+565648503","6.07800796E+565648506","7.02068674E+565648500","","",""); 4974 mathtest(432,def,"-3.73342903","855.029289","851.295860","-858.762718","-3192.19117","-0.00436643408","0","-3.73342903","-1.41988961E+489"); 4975 mathtest(433,def,"-5.14890532E+562048011","10847127.8E-390918910","-5.14890532E+562048011","-5.14890532E+562048011","-5.58508340E+171129108","-4.74679142E+952966914","","","-5.14890532E+562048011"); 4976 mathtest(434,def,"653311907","-810.036965E+744537823","-8.10036965E+744537825","8.10036965E+744537825","-5.29206794E+744537834","-8.06521104E-744537818","0","653311907","3.01325171E-71"); 4977 mathtest(435,def,"-1.31557907","98.9139300E-579281802","-1.31557907","-1.31557907","-1.30129096E-579281800","-1.33002406E+579281800","","","15.529932"); 4978 mathtest(436,def,"-875192389","-72071565.6","-947263955","-803120823","6.30764857E+16","12.1433797","12","-10333601.8","1.25564408E-644471405"); 4979 mathtest(437,def,"-72838078.8","-391.398423","-72838470.2","-72837687.4","2.85087092E+10","186097.017","186097","-6.474969","-6.574057E-3075"); 4980 mathtest(438,def,"29186560.9","-79.7419988","29186481.2","29186640.6","-2.32739470E+9","-366012.407","-366012","32.4352144","6.10050869E-598"); 4981 mathtest(439,def,"-329801660E-730249465","-6489.9256","-6489.92560","6489.92560","2.14038824E-730249453","5.08174793E-730249461","0","-3.29801660E-730249457",""); 4982 mathtest(440,def,"91.8429117E+103164883","7131455.16","9.18429117E+103164884","9.18429117E+103164884","6.54973607E+103164891","1.28785654E+103164878","","",""); 4983 mathtest(441,def,"3943866.38E+150855113","-31927007.3","3.94386638E+150855119","3.94386638E+150855119","-1.25915851E+150855127","-1.23527594E+150855112","","",""); 4984 mathtest(442,def,"-7002.0468E-795962156","-5937891.05","-5937891.05","5937891.05","4.15773910E-795962146","1.17921443E-795962159","0","-7.0020468E-795962153",""); 4985 mathtest(443,def,"696504605.","54506.4617","696559111","696450099","3.79640016E+13","12778.386","12778","21037.3974","2.6008532E+481992"); 4986 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"); 4987 mathtest(445,def,"-261.279392","-613.079357","-874.358749","351.799965","160185.002","0.426175484","0","-261.279392","-2.06318841E-1482"); 4988 mathtest(446,def,"-591407763","-80145822.8","-671553586","-511261940","4.73988618E+16","7.37914644","7","-30387003.4","-2.79334522E-703030105"); 4989 mathtest(447,def,"615630407","-69.4661869","615630338","615630476","-4.27654969E+10","-8862303.15","-8862303","10.4375693","3.44283102E-607"); 4990 mathtest(448,def,"1078757.50","27402569.0E-713742082","1078757.50","1078757.50","2.95607268E-713742069","3.93670207E+713742080","","","1.25536924E+18"); 4991 mathtest(449,def,"-4865.60358E-401116515","66952.5315","66952.5315","-66952.5315","-3.25764477E-401116507","-7.26724363E-401116517","0","-4.86560358E-401116512",""); 4992 mathtest(450,def,"-87805.3921E-934896690","-1875.14745","-1875.14745","1875.14745","1.64648057E-934896682","4.68258601E-934896689","0","-8.78053921E-934896686",""); 4993 mathtest(451,def,"-232540609.E+602702520","68.0834223","-2.32540609E+602702528","-2.32540609E+602702528","-1.58321605E+602702530","-3.41552468E+602702526","","",""); 4994 mathtest(452,def,"-320610803.","-863871235.","-1.18448204E+9","543260432","2.76966450E+17","0.37113263","0","-320610803",""); 4995 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"); 4996 mathtest(454,def,"-439.747348","74.9494457E-353117582","-439.747348","-439.747348","-3.29588200E-353117578","-5.86725284E+353117582","","","-3.17996693E+18"); 4997 mathtest(455,def,"-89702231.9","1.28993993","-89702230.6","-89702233.2","-115710491","-69539852.1","-69539852","-0.07890964","-89702231.9"); 4998 mathtest(456,def,"-5856939.14","-6743375.34","-12600314.5","886436.20","3.94955390E+13","0.868547107","0","-5856939.14","-3.29213248E-45636942"); 4999 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"); 5000 mathtest(458,def,"87.4798787E-80124704","108497.32","108497.320","-108497.320","9.49133239E-80124698","8.06286079E-80124708","0","8.74798787E-80124703",""); 5001 mathtest(459,def,"-694562052","310681.319E+549445264","3.10681319E+549445269","-3.10681319E+549445269","-2.15787454E+549445278","-2.23560932E-549445261","0","-694562052","-3.35068155E+26"); 5002 mathtest(460,def,"-9744135.85","1797016.04","-7947119.81","-11541151.9","-1.75103684E+13","-5.42239782","-5","-759055.65","3.83848006E+12558883"); 5003 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"); 5004 mathtest(462,def,"365347.52","-3655414.47","-3290066.95","4020761.99","-1.33549661E+12","-0.099946948","0","365347.52","1.02663257E-20333994"); 5005 mathtest(463,def,"-19706333.6E-816923050","-383858032.","-383858032","383858032","7.56443443E-816923035","5.1337557E-816923052","0","-1.97063336E-816923043",""); 5006 mathtest(464,def,"-86346.2616","-98.8063785","-86445.0680","-86247.4552","8531561.41","873.893598","873","-88.2931695","-2.05064086E-489"); 5007 mathtest(465,def,"-445588.160E-496592215","328.822976","328.822976","-328.822976","-1.46519625E-496592207","-1.35510044E-496592212","0","-4.45588160E-496592210",""); 5008 mathtest(466,def,"-9709213.71","-34.6690137","-9709248.38","-9709179.04","336608863","280054.512","280054","-17.7472602","-2.80903974E-245"); 5009 mathtest(467,def,"742395536.","-43533.6889","742352002","742439070","-3.23192163E+13","-17053.3569","-17053","15539.1883","5.7622734E-386175"); 5010 mathtest(468,def,"-878849193.","-5842982.47E-972537342","-878849193","-878849193","5.13510043E-972537327","1.50411061E+972537344","","","2.17027042E-54"); 5011 mathtest(469,def,"-78014142.1","-624658.522","-78638800.6","-77389483.6","4.87321987E+13","124.890863","124","-556485.372","-7.86063865E-4929918"); 5012 mathtest(470,def,"857039.371","454.379672","857493.751","856584.991","389421268","1886.17454","1886","79.309608","3.82253101E+2693"); 5013 mathtest(471,def,"166534010.","-173.012236","166533837","166534183","-2.88124214E+10","-962556.255","-962556","44.164784","4.78620664E-1423"); 5014 mathtest(472,def,"-810.879063","43776.610","42965.7309","-44587.4891","-35497536.5","-0.0185231123","0","-810.879063","-2.34758691E+127345"); 5015 mathtest(473,def,"-327.127935","93458944","93458616.9","-93459271.1","-3.05730314E+10","-0.00000350023145","0","-327.127935","2.29323021E+235022854"); 5016 mathtest(474,def,"539295218.","-9587941.10E-309643098","539295218","539295218","-5.17073079E-309643083","-5.62472394E+309643099","","","4.80545269E-88"); 5017 mathtest(475,def,"-3862702.65","879616.733","-2983085.92","-4742319.38","-3.39769789E+12","-4.3913474","-4","-344235.718","-3.50650167E+5793941"); 5018 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"); 5019 mathtest(477,def,"546875205.","447.52857E+557357101","4.47528570E+557357103","-4.47528570E+557357103","2.44742278E+557357112","1.22198948E-557357095","0","546875205","8.94443542E+34"); 5020 mathtest(478,def,"177623437","-7779116.14","169844321","185402553","-1.38175335E+15","-22.83337","-22","6482881.92","2.90085309E-64173820"); 5021 mathtest(479,def,"377204735.","13768.1401","377218503","377190967","5.19340764E+12","27396.9274","27396","12768.8204","2.06065297E+118082"); 5022 mathtest(480,def,"-2435.49239","-11732.0640E-23331504","-2435.49239","-2435.49239","2.85733526E-23331497","2.07592832E+23331503","","","-0.00041059459"); 5023 mathtest(481,def,"-6128465.14E-137123294","-5742264.27","-5742264.27","5742264.27","3.51912664E-137123281","1.06725585E-137123294","0","-6.12846514E-137123288",""); 5024 mathtest(482,def,"-2898065.44","-5.11638105","-2898070.56","-2898060.32","14827607.1","566428.773","566428","-3.95461060","-4.89169151E-33"); 5025 mathtest(483,def,"1851395.31E+594383160","-550301.475","1.85139531E+594383166","1.85139531E+594383166","-1.01882557E+594383172","-3.36432918E+594383160","","",""); 5026 mathtest(484,def,"536412589.E+379583977","899.601161","5.36412589E+379583985","5.36412589E+379583985","4.82557388E+379583988","5.96278231E+379583982","","",""); 5027 mathtest(485,def,"185.85297","867419480.","867419666","-867419294","1.61212487E+11","2.14259622E-7","0","185.85297",""); 5028 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"); 5029 mathtest(487,def,"-8.11587021E-245942806","4553.06753E+943412048","4.55306753E+943412051","-4.55306753E+943412051","-3.69521051E+697469246","","0","-8.11587021E-245942806",""); 5030 mathtest(488,def,"-405765.352","854963231","854557466","-855368996","-3.46914456E+14","-0.000474599769","0","-405765.352",""); 5031 mathtest(489,def,"-159.609757","-43356.7567","-43516.3665","43197.1470","6920161.40","0.00368131219","0","-159.609757","-8.95397849E-95519"); 5032 mathtest(490,def,"-564240.241E-501316672","-557.781977","-557.781977","557.781977","3.14723037E-501316664","1.01157847E-501316669","0","-5.64240241E-501316667",""); 5033 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"); 5034 mathtest(492,def,"-4426.59663","95.1096765","-4331.48695","-4521.70631","-421012.173","-46.5420217","-46","-51.5515110","-2.38037379E+346"); 5035 mathtest(493,def,"6037.28310","578264.105","584301.388","-572226.822","3.49114411E+9","0.010440356","0","6037.28310","3.57279483E+2186324"); 5036 mathtest(494,def,"-66.9556692","-53.8519404","-120.807610","-13.1037288","3605.69271","1.24332881","1","-13.1037288","2.55554086E-99"); 5037 mathtest(495,def,"-92486.0222","-59935.8544","-152421.877","-32550.1678","5.54322876E+9","1.5430834","1","-32550.1678","1.83152656E-297647"); 5038 mathtest(496,def,"852136219.E+917787351","9246221.91","8.52136219E+917787359","8.52136219E+917787359","7.87904058E+917787366","9.21604767E+917787352","","",""); 5039 mathtest(497,def,"-2120096.16E-269253718","9437.00514","9437.00514","-9437.00514","-2.00073584E-269253708","-2.24657731E-269253716","0","-2.12009616E-269253712",""); 5040 mathtest(498,def,"-524653.169E-865784226","228054.698","228054.698","-228054.698","-1.19649620E-865784215","-2.30055848E-865784226","0","-5.24653169E-865784221",""); 5041 mathtest(499,def,"-288193133","-312268737.","-600461870","24075604","8.99937057E+16","0.922901011","0","-288193133",""); 5042 mathtest(500,def,"-373484759E-113589964","844101958E-852538240","-3.73484759E-113589956","-3.73484759E-113589956","-3.15259216E-966128187","-4.42464036E+738948275","","","3.78602147E-908719644"); 5043 } 5044 5045 /* mathtest -- general arithmetic test routine 5046 Arg1 is test number 5047 Arg2 is MathContext 5048 Arg3 is left hand side (LHS) 5049 Arg4 is right hand side (RHS) 5050 Arg5 is the expected result for add 5051 Arg6 is the expected result for subtract 5052 Arg7 is the expected result for multiply 5053 Arg8 is the expected result for divide 5054 Arg9 is the expected result for integerDivide 5055 Arg10 is the expected result for remainder 5056 Arg11 is the expected result for power 5057 5058 For power RHS, 0 is added to the number, any exponent is removed and 5059 the number is then rounded to an integer, using format(rhs+0,,0) 5060 5061 If an error should result for an operation, the 'expected result' is 5062 an empty string. 5063 */ 5064 5065 private void mathtest(int test, com.ibm.icu.math.MathContext mc, 5066 java.lang.String slhs, java.lang.String srhs, java.lang.String add, 5067 java.lang.String sub, java.lang.String mul, java.lang.String div, 5068 java.lang.String idv, java.lang.String rem, java.lang.String pow) { 5069 com.ibm.icu.math.BigDecimal lhs; 5070 com.ibm.icu.math.BigDecimal rhs; 5071 java.lang.String res = null; 5072 java.lang.String sn = null; 5073 int e = 0; 5074 5075 lhs = new com.ibm.icu.math.BigDecimal(slhs); 5076 rhs = new com.ibm.icu.math.BigDecimal(srhs); 5077 5078 try { 5079 res = lhs.add(rhs, mc).toString(); 5080 } catch (java.lang.ArithmeticException $137) { 5081 res = ""; 5082 } 5083 mathtestcheck(test, lhs, rhs, "add", res, add); 5084 5085 try { 5086 res = lhs.subtract(rhs, mc).toString(); 5087 } catch (java.lang.ArithmeticException $138) { 5088 res = ""; 5089 } 5090 mathtestcheck(test, lhs, rhs, "sub", res, sub); 5091 5092 try { 5093 res = lhs.multiply(rhs, mc).toString(); 5094 } catch (java.lang.ArithmeticException $139) { 5095 res = ""; 5096 } 5097 mathtestcheck(test, lhs, rhs, "mul", res, mul); 5098 5099 try { 5100 res = lhs.divide(rhs, mc).toString(); 5101 } catch (java.lang.ArithmeticException $140) { 5102 res = ""; 5103 } 5104 mathtestcheck(test, lhs, rhs, "div", res, div); 5105 5106 try { 5107 res = lhs.divideInteger(rhs, mc).toString(); 5108 } catch (java.lang.ArithmeticException $141) { 5109 res = ""; 5110 } 5111 mathtestcheck(test, lhs, rhs, "idv", res, idv); 5112 5113 try { 5114 res = lhs.remainder(rhs, mc).toString(); 5115 } catch (java.lang.ArithmeticException $142) { 5116 res = ""; 5117 } 5118 mathtestcheck(test, lhs, rhs, "rem", res, rem); 5119 5120 try { 5121 // prepare an integer from the rhs 5122 // in Rexx: 5123 // n=rhs+0 5124 // e=pos('E', n) 5125 // if e>0 then n=left(n,e-1) 5126 // n=format(n,,0) 5127 5128 sn = rhs.plus(mc).toString(); 5129 e = sn.indexOf("E", 0); 5130 if (e > 0) 5131 sn = sn.substring(0, e); 5132 sn = (new com.ibm.icu.math.BigDecimal(sn)).format(-1, 0); 5133 5134 res = lhs.pow(new com.ibm.icu.math.BigDecimal(sn), mc).toString(); 5135 } catch (java.lang.ArithmeticException $143) { 5136 res = ""; 5137 } 5138 mathtestcheck(test, lhs, rhs, "pow", res, pow); 5139 return; 5140 } 5141 5142 /* mathtestcheck -- check for general mathtest error 5143 Arg1 is test number 5144 Arg2 is left hand side (LHS) 5145 Arg3 is right hand side (RHS) 5146 Arg4 is the operation 5147 Arg5 is the actual result 5148 Arg6 is the expected result 5149 Show error message if a problem, otherwise return quietly 5150 */ 5151 5152 private void mathtestcheck(int test, com.ibm.icu.math.BigDecimal lhs, 5153 com.ibm.icu.math.BigDecimal rhs, java.lang.String op, 5154 java.lang.String got, java.lang.String want) { 5155 boolean flag; 5156 java.lang.String testnum; 5157 5158 flag = want.equals(got); 5159 5160 if ((!flag)) 5161 say(">" + test + ">" + " " + lhs.toString() + " " + op + " " 5162 + rhs.toString() + " " + "=" + " " + want + " " + "[got" 5163 + " " + got + "]"); 5164 5165 testnum = "gen" 5166 + right((new com.ibm.icu.math.BigDecimal(test + 1000)) 5167 .toString(), 3); 5168 5169 TestFmwk.assertTrue(testnum, flag); 5170 return; 5171 } 5172 5173 /* ------------------------------------------------------------------ */ 5174 /* Support routines and minor classes follow */ 5175 /* ------------------------------------------------------------------ */ 5176 5177 /* ----------------------------------------------------------------- */ 5178 /* Method called to summarise pending tests */ 5179 /* ----------------------------------------------------------------- */ 5180 /* Arg1 is section name */ 5181 5182 // private void summary(java.lang.String section) { 5183 // int bad; 5184 // int count; 5185 // int i = 0; 5186 // Test item = null; 5187 // bad = 0; 5188 // count = Tests.size(); 5189 // { 5190 // int $144 = count; 5191 // i = 0; 5192 // for (; $144 > 0; $144--, i++) { 5193 // item = (Test) (Tests.get(i)); 5194 // if ((!item.ok)) 5195 // { 5196 // bad++; 5197 // errln("Failed:" + " " + item.name); 5198 // } 5199 // } 5200 // }/*i*/ 5201 // totalcount = totalcount + count; 5202 // Tests = new java.util.ArrayList(100); // reinitialize 5203 // if (bad == 0) 5204 // say("OK" + " " + left(section, 14) + " " 5205 // + right("[" + count + " " + "tests]", 12)); 5206 // else 5207 // throw new DiagException(section + " " + "[failed" + " " + bad + " " 5208 // + "of" + " " + count + " " + "tests]", bad); 5209 // } 5210 5211 /* ----------------------------------------------------------------- */ 5212 /* right - Utility to do a 'right' on a Java String */ 5213 /* ----------------------------------------------------------------- */ 5214 /* Arg1 is string to right-justify */ 5215 /* Arg2 is desired length */ 5216 5217 private static java.lang.String right(java.lang.String s, int len) { 5218 int slen; 5219 slen = s.length(); 5220 if (slen == len) 5221 return s; // length just right 5222 if (slen > len) 5223 return s.substring(slen - len); // truncate on left 5224 // too short 5225 return (new java.lang.String(new char[len - slen])) 5226 .replace('\000', ' ').concat(s); 5227 } 5228 5229 /* ----------------------------------------------------------------- */ 5230 /* say - Utility to do a display */ 5231 /* ----------------------------------------------------------------- */ 5232 /* Arg1 is string to display, omitted if none */ 5233 /* [null or omitted gives blank line] */ 5234 // this version doesn't heed continuation final character 5235 private void say(java.lang.String s) { 5236 if (s == null) 5237 s = " "; 5238 logln(s); 5239 } 5240 5241 } 5242
