1 // Tags: JDK1.2

     2 

     3 /* This code was derived from test code from IBM's ICU project, which

     4    uses the following license...

     5 

     6 Copyright (c) 1995-2001 International Business Machines Corporation and others

     7    

     8 All rights reserved.

     9 

    10 Permission is hereby granted, free of charge, to any person obtaining

    11 a copy of this software and associated documentation files (the

    12 "Software"), to deal in the Software without restriction, including

    13 without limitation the rights to use, copy, modify, merge, publish,

    14 distribute, and/or sell copies of the Software, and to permit persons

    15 to whom the Software is furnished to do so, provided that the above

    16 copyright notice(s) and this permission notice appear in all copies of

    17 the Software and that both the above copyright notice(s) and this

    18 permission notice appear in supporting documentation.  

    19 

    20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT

    23 OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

    24 HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY

    25 SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER

    26 RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF

    27 CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

    28 CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

    29 

    30 Except as contained in this notice, the name of a copyright holder

    31 shall not be used in advertising or otherwise to promote the sale, use

    32 or other dealings in this Software without prior written authorization

    33 of the copyright holder. 

    34 

    35 All trademarks and registered trademarks mentioned herein are the

    36 property of their respective owners.

    37 

    38 */

    39 

    40 

    41 /* Generated from 'DiagBigDecimal.nrx' 27 Mar 2000 22:38:44 [v1.162] */

    42 /* Options: Binary Comments Crossref Format Java Logo Trace1 Verbose3 */

    43 package gnu.testlet.java.math.BigDecimal;

    44 

    45 import java.math.*;

    46 import gnu.testlet.Testlet;

    47 import gnu.testlet.TestHarness;

    48 

    49 /* ------------------------------------------------------------------ */

    50 /* Decimal diagnostic tests                                       mfc */

    51 /* Copyright (c) IBM Corporation 1996, 2000.  All Rights Reserved.    */

    52 /* ------------------------------------------------------------------ */

    53 /* DiagBigDecimal                                                     */

    54 /*                                                                    */

    55 /*   A class that tests the BigDecimal and MathContext classes.       */

    56 /*                                                                    */

    57 /*   The tests here are derived from or cover the same paths as:      */

    58 /*      -- ANSI X3-274 testcases                                      */

    59 /*      -- Java JCK testcases                                         */

    60 /*      -- NetRexx testcases                                          */

    61 /*      -- VM/CMS S/370 REXX implementation testcases [1981+]         */

    62 /*      -- IBM Vienna Laboratory Rexx compiler testcases [1988+]      */

    63 /*      -- New testcases                                              */

    64 /*                                                                    */

    65 /*   The authoritative sources for how the underlying technology      */

    66 /*   (arithmetic) should work are:                                    */

    67 /*      -- for digits=0 (fixed point): java.math.BigDecimal           */

    68 /*      -- for digits>0 (floating point): ANSI X3.274-1996 + errata   */

    69 /*                                                                    */

    70 /* ------------------------------------------------------------------ */

    71 /* Change list                                                        */

    72 /* 1997.09.05 Initial implementation, from DiagRexx [NetRexx tests]   */

    73 /* 1998.05.02 0.07 changes (e.g., compareTo)                          */

    74 /* 1998.06.06 Rounding modes and format additions                     */

    75 /* 1998.06.25 Rename from DiagDecimal; make stand-alone [add          */

    76 /*            DiagException as a Minor class]                         */

    77 /* 1998.06.27 Start adding testcases for DIGITS=0/FORM=PLAIN cases    */

    78 /*            Reorganize for faster trace compilation                 */

    79 /* 1998.06.28 new: valueof, scale, movePointX, unscaledValue, etc.    */

    80 /* 1998.07.07 Scaled divide                                           */

    81 /* 1998.07.08 setScale                                                */

    82 /* 1998.07.15 new scaffolding (Minor Test class) -- see diagabs       */

    83 /* 1998.12.14 add toBigDecimal and BigDecimal(java.math.BigDecimal)   */

    84 /* 1999.02.04 number preparation rounds instead of digits+1 trunc     */

    85 /* 1999.02.09 format method now only has two signatures               */

    86 /* 1999.02.27 no longer use Rexx class or RexxIO class                */

    87 /* 1999.03.05 add MathContext tests                                   */

    88 /* 1999.03.05 update for 0.96 [no null settings, etc.]                */

    89 /*            drop sundry constructors; no blanks; char[] gets ints   */

    90 /*            drop sundry converters, add Exact converters            */

    91 /* 1999.05.27 additional tests for scaled arithmetic                  */

    92 /* 1999.06.29 additional tests for exponent overflows                 */

    93 /* 1999.07.03 add 'continue' option                                   */

    94 /* 1999.07.10 additional tests for scaled arithmetic                  */

    95 /* 1999.07.18 randomly-generated tests added for base operators       */

    96 /* 1999.10.28 weird intValueExact bad cases                           */

    97 /* 1999.12.21 multiplication fast path failure and edge cases         */

    98 /* 2000.01.01 copyright update                                        */

    99 /* 2000.03.26 cosmetic updates; add extra format() testcases          */

   100 /* 2000.03.27 1.00 move to com.ibm.icu.math package; open source release; */

   101 /*                 change to javadoc comments                         */

   102 /* ------------------------------------------------------------------ */

   103 

   104 // note BINARY for conversions checking

   105 

   106 

   107 

   108 

   109 /**

   110  * The <code>DiagBigDecimal</code> class forms a standalone test suite

   111  * for the <code>com.ibm.icu.math.BigDecimal</code> and

   112  * <code>com.ibm.icu.math.MathContext</code> classes (or, by changing the

   113  * <code>package</code> statement, other classes of the same names and

   114  * definition in other packages).  It may also be used as a constructed

   115  * object to embed the tests in an external test harness.

   116  * <p>

   117  * The tests are collected into <i>groups</i>, each corresponding to a

   118  * tested method or a more general grouping.  By default, when run from

   119  * the static {@link #main(java.lang.String[])} method, the run will end

   120  * if any test fails in a group.  The <code>continue</code> argument may

   121  * be specified to force the tests to run to completion.

   122  * <p>

   123  * Two minor (inner) classes are used; {@link

   124  * DiagBigDecimal.DiagException} is used to signal the failure of a test

   125  * group, and {@link DiagBigDecimal.Test}, a dependent minor class, is

   126  * used to register tests so that a summary of failures (or success) can be

   127  * presented as each group is completed.

   128  *

   129  * @see     com.ibm.icu.math.BigDecimal

   130  * @see     com.ibm.icu.math.MathContext

   131  * @version 1.00 2000.03.27

   132  * @author  Mike Cowlishaw

   133  */

   134 

   135 public class DiagBigDecimal implements Testlet {

   136  private final boolean CHECK_EXCEPTION_MESSAGES = false;

   137 

   138  private static final java.lang.String xx0="DiagBigDecimal.nrx";

   139  

   140  /* properties shared */

   141  java.util.Vector Tests=new java.util.Vector(100); // scaffolding

   142  

   143  /* properties private */

   144  private int totalcount=0; // counts tests run

   145  

   146  /* properties constant private */

   147  

   148  /* Count of test groups */

   149  private static final int testcount=38;

   150  

   151  private static final BigDecimal zero=new BigDecimal (BigInteger.valueOf (0), 0);

   152  private static final BigDecimal one=new BigDecimal (BigInteger.valueOf (1), 0);

   153  private static final BigDecimal two=new BigDecimal (BigInteger.valueOf (2), 0);

   154  private static final BigDecimal ten=new BigDecimal (BigInteger.valueOf (10), 0);

   155  private static final BigDecimal tenlong=new BigDecimal((long)1234554321); // 10-digiter

   156  

   157  /* boundary primitive values */

   158  private static final byte bmin=-128;

   159  private static final byte bmax=127;

   160  private static final byte bzer=0;

   161  private static final byte bneg=-1;

   162  private static final byte bpos=1;

   163  private static final int imin=-2147483648;

   164  private static final int imax=2147483647;

   165  private static final int izer=0;

   166  private static final int ineg=-1;

   167  private static final int ipos=1;

   168  private static final long lmin=-9223372036854775808L;

   169  private static final long lmax=9223372036854775807L;

   170  private static final String lminString="-9223372036854775808";

   171  private static final String lmaxString="9223372036854775807";

   172  private static final long lzer=(long)0;

   173  private static final long lneg=(long)-1;

   174  private static final long lpos=(long)1;

   175  private static final short smin=-32768;

   176  private static final short smax=32767;

   177  private static final short szer=(short)0;

   178  private static final short sneg=(short)(-1);

   179  private static final short spos=(short)1;

   180  

   181  

   182  /* properties constant private unused */ // present but not referenced

   183  private static final java.lang.String copyright=" Copyright (c) IBM Corporation 1996, 2000.  All rights reserved. ";

   184 

   185  

   186  /** Constructs a <code>DiagBigDecimal</code> test suite.

   187    * <p>

   188    * Invoke its {@link #diagrun} method to run the tests.

   189    */

   190  

   191  public DiagBigDecimal(){super();

   192   return;

   193   }

   194 

   195  /** Run the tests in the test suite.

   196   *

   197   * @param isContinue The <code>boolean</code> which determines whether

   198   *                   to stop running after a group fails.  If 1 (true)

   199   *                   then the tests should be run to completion if

   200   *                   possible; if 0 (false) then the run will end if a

   201   *                   group fails.

   202   * @return an <code>int</code> which is 0 if all tests were

   203   * successful, >0 (the count of failures) if some failures were

   204   * detected, or <0 if an unexpected Exception was signalled.

   205   */

   206  

   207  public void diagrun(TestHarness harness){

   208   int num=0;

   209   RuntimeException de=null;

   210   java.lang.RuntimeException e=null;

   211   java.lang.String rest=null;

   212   

   213   try{num=1;num:for(;num<=testcount;num++){ // [testcount is constant set above]

   214    try{

   215     dotest(harness, num);

   216    }

   217    catch (RuntimeException xx1){de=xx1;

   218     say(harness);

   219     harness.verbose("**** Failed:"+" "+de.getMessage()+" "+"****");

   220     say(harness);

   221    }

   222   }

   223   }

   224   catch (java.lang.RuntimeException xx2){e=xx2; // any other exception is total failure; just show trace and quit

   225    say(harness);

   226    harness.verbose("**** Failed: unexpected exception ****");

   227    e.printStackTrace();

   228    return;

   229   }/*num*/

   230   

   231   return;

   232  }

   233 

   234  /* Run test by number -- method for development/private switching */

   235  

   236  private void dotest(TestHarness harness, int num){

   237   {/*select*/switch(num){

   238    /* -------------------------------------------------------------- */

   239    /* MathContext                                                    */

   240    /* -------------------------------------------------------------- */

   241   case 1:

   242    break;

   243    

   244    /* -------------------------------------------------------------- */

   245    /* Constructors                                                   */

   246    /* -------------------------------------------------------------- */

   247   case 2:

   248     /* diagconstructors(harness); */ break;

   249    

   250    /* -------------------------------------------------------------- */

   251    /* Operator methods                                               */

   252    /* -------------------------------------------------------------- */

   253   case 3:

   254    diagabs(harness);break;

   255   case 4:

   256    diagadd(harness);break;

   257   case 5:

   258    diagcompareto(harness);break;

   259   case 6:

   260    diagdivide(harness);break;

   261   case 7:

   262     break;

   263   case 8:

   264    diagmax(harness);break;

   265   case 9:

   266    diagmin(harness);break;

   267   case 10:

   268    diagmultiply(harness);break;

   269   case 11:

   270    diagnegate(harness);break;

   271   case 12:

   272     break;

   273   case 13:

   274     break;

   275   case 14:

   276     break;

   277   case 15:

   278    diagsubtract(harness);break;

   279   case 16:

   280     break;

   281    

   282    /* -------------------------------------------------------------- */

   283    /* Other methods                                                  */

   284    /* -------------------------------------------------------------- */

   285   case 17:

   286    diagbyteValue(harness);break;

   287   case 18:

   288    diagcomparetoObj(harness);break;

   289   case 19:

   290    diagdoublevalue(harness);break;

   291   case 20:

   292    diagequals(harness);break;

   293   case 21:

   294    diagfloatvalue(harness);break;

   295   case 22:

   296     break;

   297   case 23:

   298    diaghashcode(harness);break;

   299   case 24:

   300    diagintvalue(harness);break;

   301   case 25:

   302    diaglongvalue(harness);break;

   303   case 26:

   304    diagmovepointleft(harness);break;

   305   case 27:

   306    diagmovepointright(harness);break;

   307   case 28:

   308    diagscale(harness);break;

   309   case 29:

   310    diagsetscale(harness);break;

   311   case 30:

   312    diagshortvalue(harness);break;

   313   case 31:

   314    diagsignum(harness);break;

   315   case 32:

   316     break;

   317   case 33:

   318    diagtobiginteger(harness);break;

   319   case 34:

   320     break;

   321   case 35:

   322    diagtostring(harness);break;

   323   case 36:

   324     break;

   325   case 37:

   326    diagvalueof(harness);break;

   327    

   328    /* -------------------------------------------------------------- */

   329    /* Mutation test [must be the last test]                          */

   330    /* -------------------------------------------------------------- */

   331   case 38:

   332    diagmutation(harness);break;

   333    // if any more, increase testcount above

   334   default:{

   335    say("*** dotest case not found:"+" "+num+" "+"***", harness);

   336   }}

   337   }

   338   return;

   339   }

   340 

   341  /*--------------------------------------------------------------------*/

   342  /* Diagnostic group methods                                           */

   343  /*--------------------------------------------------------------------*/

   344  

   345  /** Test constructors (and {@link #toString()} for equalities). */

   346  

   347  public void diagconstructors(TestHarness harness){

   348   boolean flag=false;

   349   java.lang.String num;

   350   java.math.BigInteger bip;

   351   java.math.BigInteger biz;

   352   java.math.BigInteger bin;

   353   BigDecimal bda;

   354   BigDecimal bdb;

   355   BigDecimal bmc;

   356   BigDecimal bmd;

   357   BigDecimal bme;

   358   java.lang.RuntimeException e=null;

   359   char ca[];

   360   double dzer;

   361   double dpos;

   362   double dneg;

   363   double dpos5;

   364   double dneg5;

   365   double dmin;

   366   double dmax;

   367   double d;

   368   java.lang.String badstrings[];

   369   int i=0;

   370   

   371   // constants [statically-called constructors]

   372   harness.check ((zero.toString()).equals("0"), "con001");

   373   harness.check ((one.toString()).equals("1"), "con002");

   374   harness.check ((ten.toString()).equals("10"), "con003");

   375   harness.check ((zero.intValue())==0, "con004");

   376   harness.check ((one.intValue())==1, "con005");

   377   harness.check ((ten.intValue())==10, "con006");

   378   

   379   // [java.math.] BigDecimal

   380   harness.check (((new BigDecimal(new BigDecimal("0").toString())).toString()).equals("0"), "cbd001");

   381   harness.check (((new BigDecimal(new BigDecimal("1").toString())).toString()).equals("1"), "cbd002");

   382   harness.check (((new BigDecimal(new BigDecimal("10").toString())).toString()).equals("10"), "cbd003");

   383   harness.check (((new BigDecimal(new BigDecimal("1000").toString())).toString()).equals("1000"), "cbd004");

   384   harness.check (((new BigDecimal(new BigDecimal("10.0").toString())).toString()).equals("10.0"), "cbd005");

   385   harness.check (((new BigDecimal(new BigDecimal("10.1").toString())).toString()).equals("10.1"), "cbd006");

   386   harness.check (((new BigDecimal(new BigDecimal("-1.1").toString())).toString()).equals("-1.1"), "cbd007");

   387   harness.check (((new BigDecimal(new BigDecimal("-9.0").toString())).toString()).equals("-9.0"), "cbd008");

   388   harness.check (((new BigDecimal(new BigDecimal("0.9").toString())).toString()).equals("0.9"), "cbd009");

   389   

   390   num="123456789.123456789";

   391   harness.check (((new BigDecimal(new BigDecimal(num).toString())).toString()).equals(num), "cbd010");

   392   num="123456789.000000000";

   393   harness.check (((new BigDecimal(new BigDecimal(num).toString())).toString()).equals(num), "cbd011");

   394   num="123456789000000000";

   395   harness.check (((new BigDecimal(new BigDecimal(num).toString())).toString()).equals(num), "cbd012");

   396   num="0.00000123456789";

   397   harness.check (((new BigDecimal(new BigDecimal(num).toString())).toString()).equals(num), "cbd013");

   398   num="0.000000123456789";

   399   harness.check (((new BigDecimal(new BigDecimal(num).toString())).toString()).equals(num), "cbd014");

   400   

   401   // BigInteger

   402   bip=new BigInteger("987654321987654321987654321"); // biggie +ve

   403   biz=new BigInteger("0"); // biggie 0

   404   bin=new BigInteger("-12345678998765432112345678"); // biggie -ve

   405   harness.check (((new BigDecimal(bip)).toString()).equals(bip.toString()), "cbi001");

   406   harness.check (((new BigDecimal(biz)).toString()).equals("0"), "cbi002");

   407   harness.check (((new BigDecimal(bin)).toString()).equals(bin.toString()), "cbi003");

   408   try{checknull:do{

   409    new BigDecimal((java.math.BigInteger)null);

   410    flag=false;

   411   }while(false);}

   412   catch (java.lang.NullPointerException xx4){

   413    flag=true;

   414   }/*checknull*/

   415   harness.check (flag, "cbi004");

   416   

   417   // BigInteger with scale

   418   bip=new BigInteger("123456789"); // bigish

   419   bda=new BigDecimal(bip);

   420   bdb=new BigDecimal(bip,5);

   421   bmc=new BigDecimal(bip,15);

   422   harness.check ((bda.toString()).equals("123456789"), "cbs001");

   423   harness.check ((bdb.toString()).equals("1234.56789"), "cbs002");

   424   harness.check ((bmc.toString()).equals("0.000000123456789"), "cbs003");

   425   bip=new BigInteger("123456789123456789123456789"); // biggie

   426   bda=new BigDecimal(bip);

   427   bdb=new BigDecimal(bip,7);

   428   bmc=new BigDecimal(bip,13);

   429   bmd=new BigDecimal(bip,19);

   430   bme=new BigDecimal(bip,29);

   431   harness.check ((bda.toString()).equals("123456789123456789123456789"), "cbs011");

   432   harness.check ((bdb.toString()).equals("12345678912345678912.3456789"), "cbs012");

   433   harness.check ((bmc.toString()).equals("12345678912345.6789123456789"), "cbs013");

   434   harness.check ((bmd.toString()).equals("12345678.9123456789123456789"), "cbs014");

   435   harness.check ((bme.toString()).equals("0.00123456789123456789123456789"), "cbs015");

   436   try{checknull:do{

   437    new BigDecimal((java.math.BigInteger)null,1);

   438    flag=false;

   439   }while(false);}

   440   catch (java.lang.NullPointerException xx5){

   441    flag=true;

   442   }/*checknull*/

   443   harness.check (flag, "cbs004");

   444   try{checkscale:do{

   445    new BigDecimal(bip,-8);

   446    flag=false;

   447   }while(false);}

   448   catch (java.lang.RuntimeException xx6){e=xx6;

   449    flag=checkMessage(e, "Negative scale: -8");

   450   }/*checkscale*/

   451   harness.check (flag, "cbs005");

   452   

   453   // double [deprecated]

   454   // Note that many of these differ from the valueOf(double) results.

   455   dzer=(double)0;

   456   dpos=(double)1;

   457   dpos=dpos/((double)10);

   458   dneg=(double)-dpos;

   459   harness.check (((new BigDecimal(dneg)).toString()).equals("-0.1000000000000000055511151231257827021181583404541015625"), "cdo001");

   460   

   461   harness.check (((new BigDecimal(dzer)).toString()).equals("0"), "cdo002"); // NB, not '0.0'

   462   harness.check (((new BigDecimal(dpos)).toString()).equals("0.1000000000000000055511151231257827021181583404541015625"), "cdo003");

   463   

   464   dpos5=(double)0.5D;

   465   dneg5=(double)-dpos5;

   466   harness.check (((new BigDecimal(dneg5)).toString()).equals("-0.5"), "cdo004");

   467   harness.check (((new BigDecimal(dpos5)).toString()).equals("0.5"), "cdo005");

   468   dmin=java.lang.Double.MIN_VALUE;

   469   dmax=java.lang.Double.MAX_VALUE;

   470   harness.check (((new BigDecimal(dmin)).toString()).equals("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004940656458412465441765687928682213723650598026143247644255856825006755072702087518652998363616359923797965646954457177309266567103559397963987747960107818781263007131903114045278458171678489821036887186360569987307230500063874091535649843873124733972731696151400317153853980741262385655911710266585566867681870395603106249319452715914924553293054565444011274801297099995419319894090804165633245247571478690147267801593552386115501348035264934720193790268107107491703332226844753335720832431936092382893458368060106011506169809753078342277318329247904982524730776375927247874656084778203734469699533647017972677717585125660551199131504891101451037862738167250955837389733598993664809941164205702637090279242767544565229087538682506419718265533447265625"), "cdo006");

   471   

   472   harness.check (((new BigDecimal(dmax)).toString()).equals("179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368"), "cdo007");

   473   

   474   

   475   // nasties

   476   d=(double)9;

   477   d=d/((double)10);

   478   harness.check (((new BigDecimal(d)).toString()).equals("0.90000000000000002220446049250313080847263336181640625"), "cdo010");

   479   

   480   d=d/((double)10);

   481   harness.check (((new BigDecimal(d)).toString()).equals("0.0899999999999999966693309261245303787291049957275390625"), "cdo011");

   482   

   483   d=d/((double)10);

   484   harness.check (((new BigDecimal(d)).toString()).equals("0.00899999999999999931998839741709161899052560329437255859375"), "cdo012");

   485   

   486   d=d/((double)10);

   487   harness.check (((new BigDecimal(d)).toString()).equals("0.00089999999999999997536692664112933925935067236423492431640625"), "cdo013");

   488   

   489   d=d/((double)10);

   490   harness.check (((new BigDecimal(d)).toString()).equals("0.00008999999999999999211568180168541175589780323207378387451171875"), "cdo014");

   491   

   492   d=d/((double)10);

   493   harness.check (((new BigDecimal(d)).toString()).equals("0.00000899999999999999853394182236510090433512232266366481781005859375"), "cdo015");

   494   

   495   d=d/((double)10);

   496   harness.check (((new BigDecimal(d)).toString()).equals("0.000000899999999999999853394182236510090433512232266366481781005859375"), "cdo016");

   497   

   498   d=d/((double)10);

   499   harness.check (((new BigDecimal(d)).toString()).equals("0.0000000899999999999999853394182236510090433512232266366481781005859375"), "cdo017");

   500   

   501   d=d/((double)10);

   502   harness.check (((new BigDecimal(d)).toString()).equals("0.000000008999999999999997872197332322678764437995369007694534957408905029296875"), "cdo018");

   503   

   504   

   505   try{checkpin:do{

   506    new BigDecimal(java.lang.Double.POSITIVE_INFINITY);

   507    flag=false;

   508   }while(false);}

   509   catch (java.lang.NumberFormatException xx13){

   510    flag=true;

   511   }/*checkpin*/

   512   harness.check (flag, "cdo101");

   513   try{checknin:do{

   514    new BigDecimal(java.lang.Double.NEGATIVE_INFINITY);

   515    flag=false;

   516   }while(false);}

   517   catch (java.lang.NumberFormatException xx14){

   518    flag=true;

   519   }/*checknin*/

   520   harness.check (flag, "cdo102");

   521   try{checknan:do{

   522    new BigDecimal(java.lang.Double.NaN);

   523    flag=false;

   524   }while(false);}

   525   catch (java.lang.NumberFormatException xx15){

   526    flag=true;

   527   }/*checknan*/

   528   harness.check (flag, "cdo103");

   529   

   530   // int

   531   harness.check (((new BigDecimal(imin)).toString()).equals("-2147483648"), "cin001");

   532   harness.check (((new BigDecimal(imax)).toString()).equals("2147483647"), "cin002");

   533   harness.check (((new BigDecimal(ineg)).toString()).equals("-1"), "cin003");

   534   harness.check (((new BigDecimal(izer)).toString()).equals("0"), "cin004");

   535   harness.check (((new BigDecimal(ipos)).toString()).equals("1"), "cin005");

   536   harness.check (((new BigDecimal(10)).toString()).equals("10"), "cin006");

   537   harness.check (((new BigDecimal(9)).toString()).equals("9"), "cin007");

   538   harness.check (((new BigDecimal(5)).toString()).equals("5"), "cin008");

   539   harness.check (((new BigDecimal(2)).toString()).equals("2"), "cin009");

   540   harness.check (((new BigDecimal(-2)).toString()).equals("-2"), "cin010");

   541   harness.check (((new BigDecimal(-5)).toString()).equals("-5"), "cin011");

   542   harness.check (((new BigDecimal(-9)).toString()).equals("-9"), "cin012");

   543   harness.check (((new BigDecimal(-10)).toString()).equals("-10"), "cin013");

   544   harness.check (((new BigDecimal(-11)).toString()).equals("-11"), "cin014");

   545   harness.check (((new BigDecimal(-99)).toString()).equals("-99"), "cin015");

   546   harness.check (((new BigDecimal(-100)).toString()).equals("-100"), "cin016");

   547   harness.check (((new BigDecimal(-999)).toString()).equals("-999"), "cin017");

   548   harness.check (((new BigDecimal(-1000)).toString()).equals("-1000"), "cin018");

   549   

   550   harness.check (((new BigDecimal(11)).toString()).equals("11"), "cin019");

   551   harness.check (((new BigDecimal(99)).toString()).equals("99"), "cin020");

   552   harness.check (((new BigDecimal(100)).toString()).equals("100"), "cin021");

   553   harness.check (((new BigDecimal(999)).toString()).equals("999"), "cin022");

   554   harness.check (((new BigDecimal(1000)).toString()).equals("1000"), "cin023");

   555   

   556   // long

   557   harness.check (((new BigDecimal(lmin)).toString()).equals("-9223372036854775808"), "clo001");

   558   harness.check (((new BigDecimal(lmax)).toString()).equals("9223372036854775807"), "clo002");

   559   harness.check (((new BigDecimal(lneg)).toString()).equals("-1"), "clo003");

   560   harness.check (((new BigDecimal(lzer)).toString()).equals("0"), "clo004");

   561   harness.check (((new BigDecimal(lpos)).toString()).equals("1"), "clo005");

   562   

   563   // String [many more examples are elsewhere]

   564   // strings without E cannot generate E in result

   565   harness.check (((new BigDecimal("12")).toString()).equals("12"), "cst001");

   566   harness.check (((new BigDecimal("-76")).toString()).equals("-76"), "cst002");

   567   harness.check (((new BigDecimal("12.76")).toString()).equals("12.76"), "cst003");

   568   harness.check (((new BigDecimal("+12.76")).toString()).equals("12.76"), "cst004");

   569   harness.check (((new BigDecimal("012.76")).toString()).equals("12.76"), "cst005");

   570   harness.check (((new BigDecimal("+0.003")).toString()).equals("0.003"), "cst006");

   571   harness.check (((new BigDecimal("17.")).toString()).equals("17"), "cst007");

   572   harness.check (((new BigDecimal(".5")).toString()).equals("0.5"), "cst008");

   573   harness.check (((new BigDecimal("044")).toString()).equals("44"), "cst009");

   574   harness.check (((new BigDecimal("0044")).toString()).equals("44"), "cst010");

   575   harness.check (((new BigDecimal("0.0005")).toString()).equals("0.0005"), "cst011");

   576   harness.check (((new BigDecimal("00.00005")).toString()).equals("0.00005"), "cst012");

   577   harness.check (((new BigDecimal("0.000005")).toString()).equals("0.000005"), "cst013");

   578   harness.check (((new BigDecimal("0.0000005")).toString()).equals("0.0000005"), "cst014");

   579   harness.check (((new BigDecimal("0.00000005")).toString()).equals("0.00000005"), "cst015");

   580   harness.check (((new BigDecimal("12345678.876543210")).toString()).equals("12345678.876543210"), "cst016");

   581   harness.check (((new BigDecimal("2345678.876543210")).toString()).equals("2345678.876543210"), "cst017");

   582   harness.check (((new BigDecimal("345678.876543210")).toString()).equals("345678.876543210"), "cst018");

   583   harness.check (((new BigDecimal("0345678.87654321")).toString()).equals("345678.87654321"), "cst019");

   584   harness.check (((new BigDecimal("345678.8765432")).toString()).equals("345678.8765432"), "cst020");

   585   harness.check (((new BigDecimal("+345678.8765432")).toString()).equals("345678.8765432"), "cst021");

   586   harness.check (((new BigDecimal("+0345678.8765432")).toString()).equals("345678.8765432"), "cst022");

   587   harness.check (((new BigDecimal("+00345678.8765432")).toString()).equals("345678.8765432"), "cst023");

   588   harness.check (((new BigDecimal("-345678.8765432")).toString()).equals("-345678.8765432"), "cst024");

   589   harness.check (((new BigDecimal("-0345678.8765432")).toString()).equals("-345678.8765432"), "cst025");

   590   harness.check (((new BigDecimal("-00345678.8765432")).toString()).equals("-345678.8765432"), "cst026");

   591   

   592   // exotics --

   593   harness.check (((new BigDecimal("\u0e57.\u0e50")).toString()).equals("7.0"), "cst035");

   594   harness.check (((new BigDecimal("\u0b66.\u0b67")).toString()).equals("0.1"), "cst036");

   595   harness.check (((new BigDecimal("\u0b66\u0b66")).toString()).equals("0"), "cst037");

   596   harness.check (((new BigDecimal("\u0b6a\u0b66")).toString()).equals("40"), "cst038");

   597   

   598   // strings with E

   599   // Some implementations throw a NumberFormatException here.

   600   try {

   601     harness.check (((new BigDecimal("1E+9")).toString()).equals("1E+9"), "cst040");

   602   } catch (Exception ecst040) {

   603     harness.check (false, "cst040");

   604   }

   605   try {

   606     harness.check (((new BigDecimal("1e+09")).toString()).equals("1E+9"), "cst041");

   607   } catch (Exception ecst041) {

   608     harness.check (false, "cst041");

   609   }

   610   try {

   611     harness.check (((new BigDecimal("1E+90")).toString()).equals("1E+90"), "cst042");

   612   } catch (Exception ecst042) {

   613     harness.check (false, "cst042");

   614   }

   615   try {

   616     harness.check (((new BigDecimal("+1E+009")).toString()).equals("1E+9"), "cst043");

   617   } catch (Exception ecst043) {

   618     harness.check (false, "cst043");

   619   }

   620   try {

   621     harness.check (((new BigDecimal("0E+9")).toString()).equals("0"), "cst044");

   622   } catch (Exception ecst044) {

   623     harness.check (false, "cst044");

   624   }

   625   try {

   626     harness.check (((new BigDecimal("1E+9")).toString()).equals("1E+9"), "cst045");

   627   } catch (Exception ecst045) {

   628     harness.check (false, "cst045");

   629   }

   630   try {

   631     harness.check (((new BigDecimal("1E+09")).toString()).equals("1E+9"), "cst046");

   632   } catch (Exception ecst046) {

   633     harness.check (false, "cst046");

   634   }

   635   try {

   636     harness.check (((new BigDecimal("1e+90")).toString()).equals("1E+90"), "cst047");

   637   } catch (Exception ecst047) {

   638     harness.check (false, "cst047");

   639   }

   640   try {

   641     harness.check (((new BigDecimal("1E+009")).toString()).equals("1E+9"), "cst048");

   642   } catch (Exception ecst048) {

   643     harness.check (false, "cst048");

   644   }

   645   try {

   646     harness.check (((new BigDecimal("0E+9")).toString()).equals("0"), "cst049");

   647   } catch (Exception ecst049) {

   648     harness.check (false, "cst049");

   649   }

   650   try {

   651     harness.check (((new BigDecimal("1E9")).toString()).equals("1E+9"), "cst050");

   652   } catch (Exception ecst050) {

   653     harness.check (false, "cst050");

   654   }

   655   try {

   656     harness.check (((new BigDecimal("1e09")).toString()).equals("1E+9"), "cst051");

   657   } catch (Exception ecst051) {

   658     harness.check (false, "cst051");

   659   }

   660   try {

   661     harness.check (((new BigDecimal("1E90")).toString()).equals("1E+90"), "cst052");

   662   } catch (Exception ecst052) {

   663     harness.check (false, "cst052");

   664   }

   665   try {

   666     harness.check (((new BigDecimal("1E009")).toString()).equals("1E+9"), "cst053");

   667   } catch (Exception ecst053) {

   668     harness.check (false, "cst053");

   669   }

   670   try {

   671     harness.check (((new BigDecimal("0E9")).toString()).equals("0"), "cst054");

   672   } catch (Exception ecst054) {

   673     harness.check (false, "cst054");

   674   }

   675   try {

   676     harness.check (((new BigDecimal("0.000e+0")).toString()).equals("0"), "cst055");

   677   } catch (Exception ecst055) {

   678     harness.check (false, "cst055");

   679   }

   680   try {

   681     harness.check (((new BigDecimal("0.000E-1")).toString()).equals("0"), "cst056");

   682   } catch (Exception ecst056) {

   683     harness.check (false, "cst056");

   684   }

   685   try {

   686     harness.check (((new BigDecimal("4E+9")).toString()).equals("4E+9"), "cst057");

   687   } catch (Exception ecst057) {

   688     harness.check (false, "cst057");

   689   }

   690   try {

   691     harness.check (((new BigDecimal("44E+9")).toString()).equals("4.4E+10"), "cst058");

   692   } catch (Exception ecst058) {

   693     harness.check (false, "cst058");

   694   }

   695   try {

   696     harness.check (((new BigDecimal("0.73e-7")).toString()).equals("7.3E-8"), "cst059");

   697   } catch (Exception ecst059) {

   698     harness.check (false, "cst059");

   699   }

   700   try {

   701     harness.check (((new BigDecimal("00E+9")).toString()).equals("0"), "cst060");

   702   } catch (Exception ecst060) {

   703     harness.check (false, "cst060");

   704   }

   705   try {

   706     harness.check (((new BigDecimal("00E-9")).toString()).equals("0"), "cst061");

   707   } catch (Exception ecst061) {

   708     harness.check (false, "cst061");

   709   }

   710   try {

   711     harness.check (((new BigDecimal("10E+9")).toString()).equals("1.0E+10"), "cst062");

   712   } catch (Exception ecst062) {

   713     harness.check (false, "cst062");

   714   }

   715   try {

   716     harness.check (((new BigDecimal("10E+09")).toString()).equals("1.0E+10"), "cst063");

   717   } catch (Exception ecst063) {

   718     harness.check (false, "cst063");

   719   }

   720   try {

   721     harness.check (((new BigDecimal("10e+90")).toString()).equals("1.0E+91"), "cst064");

   722   } catch (Exception ecst064) {

   723     harness.check (false, "cst064");

   724   }

   725   try {

   726     harness.check (((new BigDecimal("10E+009")).toString()).equals("1.0E+10"), "cst065");

   727   } catch (Exception ecst065) {

   728     harness.check (false, "cst065");

   729   }

   730   try {

   731     harness.check (((new BigDecimal("100e+9")).toString()).equals("1.00E+11"), "cst066");

   732   } catch (Exception ecst066) {

   733     harness.check (false, "cst066");

   734   }

   735   try {

   736     harness.check (((new BigDecimal("100e+09")).toString()).equals("1.00E+11"), "cst067");

   737   } catch (Exception ecst067) {

   738     harness.check (false, "cst067");

   739   }

   740   try {

   741     harness.check (((new BigDecimal("100E+90")).toString()).equals("1.00E+92"), "cst068");

   742   } catch (Exception ecst068) {

   743     harness.check (false, "cst068");

   744   }

   745   try {

   746     harness.check (((new BigDecimal("100e+009")).toString()).equals("1.00E+11"), "cst069");

   747   } catch (Exception ecst069) {

   748     harness.check (false, "cst069");

   749   }    

   750 

   751   try {

   752     harness.check (((new BigDecimal("1.265")).toString()).equals("1.265"), "cst070");

   753   } catch (Exception ecst070) {

   754     harness.check (false, "cst070");

   755   }

   756   try {

   757     harness.check (((new BigDecimal("1.265E-20")).toString()).equals("1.265E-20"), "cst071");

   758   } catch (Exception ecst071) {

   759     harness.check (false, "cst071");

   760   }

   761   try {

   762     harness.check (((new BigDecimal("1.265E-8")).toString()).equals("1.265E-8"), "cst072");

   763   } catch (Exception ecst072) {

   764     harness.check (false, "cst072");

   765   }

   766   try {

   767     harness.check (((new BigDecimal("1.265E-4")).toString()).equals("1.265E-4"), "cst073");

   768   } catch (Exception ecst073) {

   769     harness.check (false, "cst073");

   770   }

   771   try {

   772     harness.check (((new BigDecimal("1.265E-3")).toString()).equals("1.265E-3"), "cst074");

   773   } catch (Exception ecst074) {

   774     harness.check (false, "cst074");

   775   }

   776   try {

   777     harness.check (((new BigDecimal("1.265E-2")).toString()).equals("1.265E-2"), "cst075");

   778   } catch (Exception ecst075) {

   779     harness.check (false, "cst075");

   780   }

   781   try {

   782     harness.check (((new BigDecimal("1.265E-1")).toString()).equals("1.265E-1"), "cst076");

   783   } catch (Exception ecst076) {

   784     harness.check (false, "cst076");

   785   }

   786   try {

   787     harness.check (((new BigDecimal("1.265E-0")).toString()).equals("1.265"), "cst077");

   788   } catch (Exception ecst077) {

   789     harness.check (false, "cst077");

   790   }

   791   try {

   792     harness.check (((new BigDecimal("1.265E+1")).toString()).equals("1.265E+1"), "cst078");

   793   } catch (Exception ecst078) {

   794     harness.check (false, "cst078");

   795   }

   796   try {

   797     harness.check (((new BigDecimal("1.265E+2")).toString()).equals("1.265E+2"), "cst079");

   798   } catch (Exception ecst079) {

   799     harness.check (false, "cst079");

   800   }

   801   try {

   802     harness.check (((new BigDecimal("1.265E+3")).toString()).equals("1.265E+3"), "cst080");

   803   } catch (Exception ecst080) {

   804     harness.check (false, "cst080");

   805   }

   806   try {

   807     harness.check (((new BigDecimal("1.265E+4")).toString()).equals("1.265E+4"), "cst081");

   808   } catch (Exception ecst081) {

   809     harness.check (false, "cst081");

   810   }

   811   try {

   812     harness.check (((new BigDecimal("1.265E+8")).toString()).equals("1.265E+8"), "cst082");

   813   } catch (Exception ecst082) {

   814     harness.check (false, "cst082");

   815   }

   816   try {

   817     harness.check (((new BigDecimal("1.265E+20")).toString()).equals("1.265E+20"), "cst083");

   818   } catch (Exception ecst083) {

   819     harness.check (false, "cst083");

   820   }

   821   

   822   try {

   823     harness.check (((new BigDecimal("12.65")).toString()).equals("12.65"), "cst090");

   824   } catch (Exception ecst090) {

   825     harness.check (false, "cst090");

   826   }

   827   try {

   828     harness.check (((new BigDecimal("12.65E-20")).toString()).equals("1.265E-19"), "cst091");

   829   } catch (Exception ecst091) {

   830     harness.check (false, "cst091");

   831   }

   832   try {

   833     harness.check (((new BigDecimal("12.65E-8")).toString()).equals("1.265E-7"), "cst092");

   834   } catch (Exception ecst092) {

   835     harness.check (false, "cst092");

   836   }

   837   try {

   838     harness.check (((new BigDecimal("12.65E-4")).toString()).equals("1.265E-3"), "cst093");

   839   } catch (Exception ecst093) {

   840     harness.check (false, "cst093");

   841   }

   842   try {

   843     harness.check (((new BigDecimal("12.65E-3")).toString()).equals("1.265E-2"), "cst094");

   844   } catch (Exception ecst094) {

   845     harness.check (false, "cst094");

   846   }

   847   try {

   848     harness.check (((new BigDecimal("12.65E-2")).toString()).equals("1.265E-1"), "cst095");

   849   } catch (Exception ecst095) {

   850     harness.check (false, "cst095");

   851   }

   852   try {

   853     harness.check (((new BigDecimal("12.65E-1")).toString()).equals("1.265"), "cst096");

   854   } catch (Exception ecst096) {

   855     harness.check (false, "cst096");

   856   }

   857   try {

   858     harness.check (((new BigDecimal("12.65E-0")).toString()).equals("1.265E+1"), "cst097");

   859   } catch (Exception ecst097) {

   860     harness.check (false, "cst097");

   861   }

   862   try {

   863     harness.check (((new BigDecimal("12.65E+1")).toString()).equals("1.265E+2"), "cst098");

   864   } catch (Exception ecst098) {

   865     harness.check (false, "cst098");

   866   }

   867   try {

   868     harness.check (((new BigDecimal("12.65E+2")).toString()).equals("1.265E+3"), "cst099");

   869   } catch (Exception ecst099) {

   870     harness.check (false, "cst099");

   871   }

   872   try {

   873     harness.check (((new BigDecimal("12.65E+3")).toString()).equals("1.265E+4"), "cst100");

   874   } catch (Exception ecst100) {

   875     harness.check (false, "cst100");

   876   }

   877   try {

   878     harness.check (((new BigDecimal("12.65E+4")).toString()).equals("1.265E+5"), "cst101");

   879   } catch (Exception ecst101) {

   880     harness.check (false, "cst101");

   881   }

   882   try {

   883     harness.check (((new BigDecimal("12.65E+8")).toString()).equals("1.265E+9"), "cst102");

   884   } catch (Exception ecst102) {

   885     harness.check (false, "cst102");

   886   }

   887   try {

   888     harness.check (((new BigDecimal("12.65E+20")).toString()).equals("1.265E+21"), "cst103");

   889   } catch (Exception ecst103) {

   890     harness.check (false, "cst103");

   891   }

   892   

   893   try {

   894     harness.check (((new BigDecimal("126.5")).toString()).equals("126.5"), "cst110");

   895   } catch (Exception ecst110) {

   896     harness.check (false, "cst110");

   897   }

   898   try {

   899     harness.check (((new BigDecimal("126.5E-20")).toString()).equals("1.265E-18"), "cst111");

   900   } catch (Exception ecst111) {

   901     harness.check (false, "cst111");

   902   }

   903   try {

   904     harness.check (((new BigDecimal("126.5E-8")).toString()).equals("1.265E-6"), "cst112");

   905   } catch (Exception ecst112) {

   906     harness.check (false, "cst112");

   907   }

   908   try {

   909     harness.check (((new BigDecimal("126.5E-4")).toString()).equals("1.265E-2"), "cst113");

   910   } catch (Exception ecst113) {

   911     harness.check (false, "cst113");

   912   }

   913   try {

   914     harness.check (((new BigDecimal("126.5E-3")).toString()).equals("1.265E-1"), "cst114");

   915   } catch (Exception ecst114) {

   916     harness.check (false, "cst114");

   917   }

   918   try {

   919     harness.check (((new BigDecimal("126.5E-2")).toString()).equals("1.265"), "cst115");

   920   } catch (Exception ecst115) {

   921     harness.check (false, "cst115");

   922   }

   923   try {

   924     harness.check (((new BigDecimal("126.5E-1")).toString()).equals("1.265E+1"), "cst116");

   925   } catch (Exception ecst116) {

   926     harness.check (false, "cst116");

   927   }

   928   try {

   929     harness.check (((new BigDecimal("126.5E-0")).toString()).equals("1.265E+2"), "cst117");

   930   } catch (Exception ecst117) {

   931     harness.check (false, "cst117");

   932   }

   933   try {

   934     harness.check (((new BigDecimal("126.5E+1")).toString()).equals("1.265E+3"), "cst118");

   935   } catch (Exception ecst118) {

   936     harness.check (false, "cst118");

   937   }

   938   try {

   939     harness.check (((new BigDecimal("126.5E+2")).toString()).equals("1.265E+4"), "cst119");

   940   } catch (Exception ecst119) {

   941     harness.check (false, "cst119");

   942   }

   943   try {

   944     harness.check (((new BigDecimal("126.5E+3")).toString()).equals("1.265E+5"), "cst120");

   945   } catch (Exception ecst120) {

   946     harness.check (false, "cst120");

   947   }

   948   try {

   949     harness.check (((new BigDecimal("126.5E+4")).toString()).equals("1.265E+6"), "cst121");

   950   } catch (Exception ecst121) {

   951     harness.check (false, "cst121");

   952   }

   953   try {

   954     harness.check (((new BigDecimal("126.5E+8")).toString()).equals("1.265E+10"), "cst122");

   955   } catch (Exception ecst122) {

   956     harness.check (false, "cst122");

   957   }

   958   try {

   959     harness.check (((new BigDecimal("126.5E+20")).toString()).equals("1.265E+22"), "cst123");

   960   } catch (Exception ecst123) {

   961     harness.check (false, "cst123");

   962   }

   963   

   964   try {

   965     harness.check (((new BigDecimal("1265")).toString()).equals("1265"), "cst130");

   966   } catch (Exception ecst130) {

   967     harness.check (false, "cst130");

   968   }

   969   try {

   970     harness.check (((new BigDecimal("1265E-20")).toString()).equals("1.265E-17"), "cst131");

   971   } catch (Exception ecst131) {

   972     harness.check (false, "cst131");

   973   }

   974   try {

   975     harness.check (((new BigDecimal("1265E-8")).toString()).equals("1.265E-5"), "cst132");

   976   } catch (Exception ecst132) {

   977     harness.check (false, "cst132");

   978   }

   979   try {

   980     harness.check (((new BigDecimal("1265E-4")).toString()).equals("1.265E-1"), "cst133");

   981   } catch (Exception ecst133) {

   982     harness.check (false, "cst133");

   983   }

   984   try {

   985     harness.check (((new BigDecimal("1265E-3")).toString()).equals("1.265"), "cst134");

   986   } catch (Exception ecst134) {

   987     harness.check (false, "cst134");

   988   }

   989   try {

   990     harness.check (((new BigDecimal("1265E-2")).toString()).equals("1.265E+1"), "cst135");

   991   } catch (Exception ecst135) {

   992     harness.check (false, "cst135");

   993   }

   994   try {

   995     harness.check (((new BigDecimal("1265E-1")).toString()).equals("1.265E+2"), "cst136");

   996   } catch (Exception ecst136) {

   997     harness.check (false, "cst136");

   998   }

   999   try {

  1000     harness.check (((new BigDecimal("1265E-0")).toString()).equals("1.265E+3"), "cst137");

  1001   } catch (Exception ecst137) {

  1002     harness.check (false, "cst137");

  1003   }

  1004   try {

  1005     harness.check (((new BigDecimal("1265E+1")).toString()).equals("1.265E+4"), "cst138");

  1006   } catch (Exception ecst138) {

  1007     harness.check (false, "cst138");

  1008   }

  1009   try {

  1010     harness.check (((new BigDecimal("1265E+2")).toString()).equals("1.265E+5"), "cst139");

  1011   } catch (Exception ecst139) {

  1012     harness.check (false, "cst139");

  1013   }

  1014   try {

  1015     harness.check (((new BigDecimal("1265E+3")).toString()).equals("1.265E+6"), "cst140");

  1016   } catch (Exception ecst140) {

  1017     harness.check (false, "cst140");

  1018   }

  1019   try {

  1020     harness.check (((new BigDecimal("1265E+4")).toString()).equals("1.265E+7"), "cst141");

  1021   } catch (Exception ecst141) {

  1022     harness.check (false, "cst141");

  1023   }

  1024   try {

  1025     harness.check (((new BigDecimal("1265E+8")).toString()).equals("1.265E+11"), "cst142");

  1026   } catch (Exception ecst142) {

  1027     harness.check (false, "cst142");

  1028   }

  1029   try {

  1030     harness.check (((new BigDecimal("1265E+20")).toString()).equals("1.265E+23"), "cst143");

  1031   } catch (Exception ecst143) {

  1032     harness.check (false, "cst143");

  1033   }

  1034   try {

  1035     harness.check (((new BigDecimal("0.1265")).toString()).equals("0.1265"), "cst150");

  1036   } catch (Exception ecst150) {

  1037     harness.check (false, "cst150");

  1038   }

  1039   try {

  1040     harness.check (((new BigDecimal("0.1265E-20")).toString()).equals("1.265E-21"), "cst151");

  1041   } catch (Exception ecst151) {

  1042     harness.check (false, "cst151");

  1043   }

  1044   try {

  1045     harness.check (((new BigDecimal("0.1265E-8")).toString()).equals("1.265E-9"), "cst152");

  1046   } catch (Exception ecst152) {

  1047     harness.check (false, "cst152");

  1048   }

  1049   try {

  1050     harness.check (((new BigDecimal("0.1265E-4")).toString()).equals("1.265E-5"), "cst153");

  1051   } catch (Exception ecst153) {

  1052     harness.check (false, "cst153");

  1053   }

  1054   try {

  1055     harness.check (((new BigDecimal("0.1265E-3")).toString()).equals("1.265E-4"), "cst154");

  1056   } catch (Exception ecst154) {

  1057     harness.check (false, "cst154");

  1058   }

  1059   try {

  1060     harness.check (((new BigDecimal("0.1265E-2")).toString()).equals("1.265E-3"), "cst155");

  1061   } catch (Exception ecst155) {

  1062     harness.check (false, "cst155");

  1063   }

  1064   try {

  1065     harness.check (((new BigDecimal("0.1265E-1")).toString()).equals("1.265E-2"), "cst156");

  1066   } catch (Exception ecst156) {

  1067     harness.check (false, "cst156");

  1068   }

  1069   try {

  1070     harness.check (((new BigDecimal("0.1265E-0")).toString()).equals("1.265E-1"), "cst157");

  1071   } catch (Exception ecst157) {

  1072     harness.check (false, "cst157");

  1073   }

  1074   try {

  1075     harness.check (((new BigDecimal("0.1265E+1")).toString()).equals("1.265"), "cst158");

  1076   } catch (Exception ecst158) {

  1077     harness.check (false, "cst158");

  1078   }

  1079   try {

  1080     harness.check (((new BigDecimal("0.1265E+2")).toString()).equals("1.265E+1"), "cst159");

  1081   } catch (Exception ecst159) {

  1082     harness.check (false, "cst159");

  1083   }

  1084   try {

  1085     harness.check (((new BigDecimal("0.1265E+3")).toString()).equals("1.265E+2"), "cst160");

  1086   } catch (Exception ecst160) {

  1087     harness.check (false, "cst160");

  1088   }

  1089   try {

  1090     harness.check (((new BigDecimal("0.1265E+4")).toString()).equals("1.265E+3"), "cst161");

  1091   } catch (Exception ecst161) {

  1092     harness.check (false, "cst161");

  1093   }

  1094   try {

  1095     harness.check (((new BigDecimal("0.1265E+8")).toString()).equals("1.265E+7"), "cst162");

  1096   } catch (Exception ecst162) {

  1097     harness.check (false, "cst162");

  1098   }

  1099   try {

  1100     harness.check (((new BigDecimal("0.1265E+20")).toString()).equals("1.265E+19"), "cst163");

  1101   } catch (Exception ecst163) {

  1102     harness.check (false, "cst163");

  1103   }

  1104   try {

  1105     harness.check (((new BigDecimal("0.09e999999999")).toString()).equals("9E+999999997"), "cst170");

  1106   } catch (Exception ecst170) {

  1107     harness.check (false, "cst170");

  1108   }

  1109   try {

  1110     harness.check (((new BigDecimal("0.9e999999999")).toString()).equals("9E+999999998"), "cst171");

  1111   } catch (Exception ecst171) {

  1112     harness.check (false, "cst171");

  1113   }

  1114   try {

  1115     harness.check (((new BigDecimal("9e999999999")).toString()).equals("9E+999999999"), "cst172");

  1116   } catch (Exception ecst172) {

  1117     harness.check (false, "cst172");

  1118   }

  1119   try {

  1120     harness.check (((new BigDecimal("9.9e999999999")).toString()).equals("9.9E+999999999"), "cst173");

  1121   } catch (Exception ecst173) {

  1122     harness.check (false, "cst173");

  1123   }

  1124   try {

  1125     harness.check (((new BigDecimal("9.99e999999999")).toString()).equals("9.99E+999999999"), "cst174");

  1126   } catch (Exception ecst174) {

  1127     harness.check (false, "cst174");

  1128   }

  1129   try {

  1130     harness.check (((new BigDecimal("9.99e-999999999")).toString()).equals("9.99E-999999999"), "cst175");

  1131   } catch (Exception ecst175) {

  1132     harness.check (false, "cst175");

  1133   }

  1134   try {