Home | History | Annotate | Download | only in math
      1 /*
      2  *  Licensed to the Apache Software Foundation (ASF) under one or more
      3  *  contributor license agreements.  See the NOTICE file distributed with
      4  *  this work for additional information regarding copyright ownership.
      5  *  The ASF licenses this file to You under the Apache License, Version 2.0
      6  *  (the "License"); you may not use this file except in compliance with
      7  *  the License.  You may obtain a copy of the License at
      8  *
      9  *     http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  *  Unless required by applicable law or agreed to in writing, software
     12  *  distributed under the License is distributed on an "AS IS" BASIS,
     13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  *  See the License for the specific language governing permissions and
     15  *  limitations under the License.
     16  */
     17 /**
     18  * @author Elena Semukhina
     19  * @version $Revision$
     20  */
     21 
     22 package libcore.java.math;
     23 
     24 import java.math.BigDecimal;
     25 import java.math.MathContext;
     26 import java.math.RoundingMode;
     27 import junit.framework.TestCase;
     28 
     29 public class OldBigDecimalConvertTest extends TestCase {
     30 
     31     public void test_IntValueExactNeg() {
     32         String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
     33         BigDecimal aNumber = new BigDecimal(a);
     34         try {
     35             aNumber.intValueExact();
     36             fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
     37         } catch (java.lang.ArithmeticException ae) {
     38             // expected;
     39         }
     40     }
     41 
     42     public void test_IntValueExactPos() {
     43         String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
     44         BigDecimal aNumber = new BigDecimal(a);
     45         try {
     46             aNumber.intValueExact();
     47             fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
     48         } catch (java.lang.ArithmeticException ae) {
     49             // expected;
     50         }
     51     }
     52 
     53     public void test_IntValueExactFloatNeg() {
     54         BigDecimal aNumber = new BigDecimal("-2147483647.999");
     55         try {
     56             aNumber.intValueExact();
     57             fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
     58         } catch (java.lang.ArithmeticException ae) {
     59             // expected;
     60         }
     61     }
     62 
     63     public void test_IntValueExactFloatPos() {
     64         float a = 2147483646.99999F;
     65         BigDecimal aNumber = new BigDecimal(a);
     66         try {
     67             aNumber.intValueExact();
     68             fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
     69         } catch (java.lang.ArithmeticException ae) {
     70             // expected;
     71         }
     72     }
     73 
     74     public void test_IntValueExactLongPos() {
     75         long a = 2147483647L;
     76         BigDecimal aNumber = new BigDecimal(a);
     77         int iNumber = aNumber.intValueExact();
     78         assertTrue("incorrect value", iNumber == a);
     79     }
     80 
     81     public void test_IntValueExactLongNeg() {
     82         long a = -2147483648L;
     83         BigDecimal aNumber = new BigDecimal(a);
     84         int iNumber = aNumber.intValueExact();
     85         assertTrue("incorrect value", iNumber == a);
     86     }
     87 
     88     public void test_LongValueExactNeg() {
     89         String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
     90         BigDecimal aNumber = new BigDecimal(a);
     91         try {
     92             aNumber.longValueExact();
     93             fail("java.lang.ArithmeticException isn't thrown after calling longValueExact");
     94         } catch (java.lang.ArithmeticException ae) {
     95             // expected;
     96         }
     97     }
     98 
     99     public void test_LongValueExactPos() {
    100         String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
    101         BigDecimal aNumber = new BigDecimal(a);
    102         try {
    103             aNumber.longValueExact();
    104             fail("java.lang.ArithmeticException isn't thrown after calling longValueExact");
    105         } catch (java.lang.ArithmeticException ae) {
    106             // expected;
    107         }
    108     }
    109 
    110     public void test_LongValueExactFloatNeg() {
    111         BigDecimal aNumber = new BigDecimal("-9223372036854775807.99999");
    112         try {
    113             aNumber.longValueExact();
    114             fail("java.lang.ArithmeticException isn't thrown after calling longValueExact");
    115         } catch (java.lang.ArithmeticException ae) {
    116             // expected;
    117         }
    118     }
    119 
    120     /**
    121      * @tests java.math.BigDecimal#longValueExact() Long value of a positive
    122      *        BigDecimal
    123      */
    124     public void test_LongValueExactFloatPos() {
    125         float a = 9223372036854775806.99999F;
    126         BigDecimal aNumber = new BigDecimal(a);
    127         try {
    128             aNumber.longValueExact();
    129             fail("java.lang.ArithmeticException isn't thrown after calling longValueExact");
    130         } catch (java.lang.ArithmeticException ae) {
    131             // expected;
    132         }
    133     }
    134 
    135     public void test_ByteValueExactPos() {
    136         int i = 127;
    137         BigDecimal bdNumber = new BigDecimal(i);
    138         byte bNumber = bdNumber.byteValueExact();
    139         assertTrue("incorrect byteValueExact", i == bNumber);
    140     }
    141 
    142     public void test_ByteValueExactNeg() {
    143         String sNumber = "-127.56789";
    144         int iNumber = -128;
    145         int iPresition = 3;
    146         MathContext mc = new MathContext(iPresition, RoundingMode.UP);
    147         BigDecimal bdNumber = new BigDecimal(sNumber, mc);
    148         byte bNumber = bdNumber.byteValueExact();
    149         assertTrue("incorrect byteValueExact", iNumber == bNumber);
    150     }
    151 
    152     public void test_ByteValueExactCharZero() {
    153         char[] cNumber = {
    154                 '-', '0', '.', '0'
    155         };
    156         int iNumber = 0;
    157         int iPresition = 5;
    158         MathContext mc = new MathContext(iPresition, RoundingMode.HALF_DOWN);
    159         BigDecimal bdNumber = new BigDecimal(cNumber, mc);
    160         byte bNumber = bdNumber.byteValueExact();
    161         assertTrue("incorrect byteValueExact", iNumber == bNumber);
    162     }
    163 
    164     public void test_ByteValueExactStringZero() {
    165         String sNumber = "00000000000000";
    166         int iNumber = 0;
    167         int iPresition = 0;
    168         MathContext mc = new MathContext(iPresition, RoundingMode.HALF_UP);
    169         BigDecimal bdNumber = new BigDecimal(sNumber, mc);
    170         byte bNumber = bdNumber.byteValueExact();
    171         assertTrue("incorrect byteValueExact", iNumber == bNumber);
    172     }
    173 
    174     public void test_ByteValueExactDoubleMax() {
    175         double dNumber = Double.MAX_VALUE;
    176         BigDecimal bdNumber = new BigDecimal(dNumber);
    177         try {
    178             bdNumber.byteValueExact();
    179             fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
    180         } catch (java.lang.ArithmeticException ae) {
    181             // expected
    182         }
    183     }
    184 
    185     public void test_ByteValueExactDoubleMin() {
    186         double dNumber = Double.MIN_VALUE;
    187         BigDecimal bdNumber = new BigDecimal(dNumber);
    188         try {
    189             bdNumber.byteValueExact();
    190             fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
    191         } catch (java.lang.ArithmeticException ae) {
    192             // expected
    193         }
    194     }
    195 
    196     public void test_ByteValueExactFloatPos() {
    197         float fNumber = 123.5445F;
    198         BigDecimal bdNumber = new BigDecimal(fNumber);
    199         try {
    200             bdNumber.byteValueExact();
    201             fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
    202         } catch (java.lang.ArithmeticException ae) {
    203             // expected
    204         }
    205     }
    206 
    207     public void test_ByteValueExactFloatNeg() {
    208         float fNumber = -12.987654321F;
    209         BigDecimal bdNumber = new BigDecimal(fNumber);
    210         try {
    211             bdNumber.byteValueExact();
    212             fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
    213         } catch (java.lang.ArithmeticException ae) {
    214             // expected
    215         }
    216     }
    217 
    218     public void test_ByteValueExactDouble() {
    219         double dNumber = 123.0000D;
    220         BigDecimal bdNumber = new BigDecimal(dNumber);
    221         byte bNumber = bdNumber.byteValueExact();
    222         assertTrue("incorrect byteValueExact", dNumber == bNumber);
    223     }
    224 
    225     public void test_ByteValueExactLongMin() {
    226         long lNumber = Long.MIN_VALUE;
    227         BigDecimal bdNumber = new BigDecimal(lNumber);
    228         try {
    229             bdNumber.byteValueExact();
    230             fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
    231         } catch (java.lang.ArithmeticException ae) {
    232             // expected
    233         }
    234     }
    235 
    236     public void test_ByteValueExactIntMax() {
    237         int iNumber = Integer.MAX_VALUE;
    238         BigDecimal bdNumber = new BigDecimal(iNumber);
    239         try {
    240             bdNumber.byteValueExact();
    241             fail("java.lang.ArithmeticException isn't thrown after calling byteValueExact");
    242         } catch (java.lang.ArithmeticException ae) {
    243             // expected
    244         }
    245     }
    246 
    247     public void test_ByteValuePos() {
    248         int i = 127;
    249         BigDecimal bdNumber = new BigDecimal(i);
    250         byte bNumber = bdNumber.byteValue();
    251         assertTrue("incorrect byteValue", i == bNumber);
    252     }
    253 
    254     /**
    255      * @test java.math.BigDecimal#byteValue() Convert negative BigDesimal to
    256      *       byte type
    257      */
    258     public void test_ByteValueNeg() {
    259         String sNumber = "-127.56789";
    260         int iNumber = -128;
    261         int iPresition = 3;
    262         MathContext mc = new MathContext(iPresition, RoundingMode.UP);
    263         BigDecimal bdNumber = new BigDecimal(sNumber, mc);
    264         byte bNumber = bdNumber.byteValue();
    265         assertTrue("incorrect byteValueExact", iNumber == bNumber);
    266     }
    267 
    268     public void test_ByteValueCharZero() {
    269         char[] cNumber = {
    270                 '-', '0', '.', '0'
    271         };
    272         int iNumber = 0;
    273         int iPresition = 0;
    274         MathContext mc = new MathContext(iPresition, RoundingMode.HALF_UP);
    275         BigDecimal bdNumber = new BigDecimal(cNumber, mc);
    276         byte bNumber = bdNumber.byteValue();
    277         assertTrue("incorrect byteValue", iNumber == bNumber);
    278     }
    279 
    280     public void test_ByteValueStringZero() {
    281         String sNumber = "00000";
    282         int iNumber = 0;
    283         int iPresition = 0;
    284         MathContext mc = new MathContext(iPresition, RoundingMode.HALF_UP);
    285         BigDecimal bdNumber = new BigDecimal(sNumber, mc);
    286         byte bNumber = bdNumber.byteValue();
    287         assertTrue("incorrect byteValue", iNumber == bNumber);
    288     }
    289 
    290     public void test_ByteValueDoubleMax() {
    291         double dNumber = Double.MAX_VALUE;
    292         BigDecimal bdNumber = new BigDecimal(dNumber);
    293         int result = 0;
    294         byte bNumber = bdNumber.byteValue();
    295         assertTrue("incorrect byteValue", bNumber == result);
    296     }
    297 
    298     public void test_ByteValueDoubleMin() {
    299         double dNumber = Double.MIN_VALUE;
    300         BigDecimal bdNumber = new BigDecimal(dNumber);
    301         int result = 0;
    302         byte bNumber = bdNumber.byteValue();
    303         assertTrue("incorrect byteValue", bNumber == result);
    304     }
    305 
    306     public void test_ByteValueFloatNeg() {
    307         float fNumber = -12.987654321F;
    308         byte bValue = -12;
    309         BigDecimal bdNumber = new BigDecimal(fNumber);
    310         byte bNumber = bdNumber.byteValue();
    311         assertTrue("incorrect byteValue", bNumber == bValue);
    312     }
    313 
    314     public void test_ByteValueDouble() {
    315         double dNumber = 123.0000D;
    316         BigDecimal bdNumber = new BigDecimal(dNumber);
    317         byte bNumber = bdNumber.byteValue();
    318         assertTrue("incorrect byteValue", dNumber == bNumber);
    319     }
    320 
    321     public void test_ByteValueLongMin() {
    322         long lNumber = Long.MIN_VALUE;
    323         int result = 0;
    324         BigDecimal bdNumber = new BigDecimal(lNumber);
    325         byte bNumber = bdNumber.byteValue();
    326         assertTrue("incorrect byteValue", bNumber == result);
    327     }
    328 
    329     public void test_ByteValueIntMin() {
    330         int iNumber = Integer.MIN_VALUE;
    331         int result = 0;
    332         BigDecimal bdNumber = new BigDecimal(iNumber);
    333         byte bNumber = bdNumber.byteValue();
    334         assertTrue("incorrect byteValue", bNumber == result);
    335     }
    336 
    337     public void test_ByteValueIntMax() {
    338         int iNumber = Integer.MAX_VALUE;
    339         int result = -1;
    340         BigDecimal bdNumber = new BigDecimal(iNumber);
    341         byte bNumber = bdNumber.byteValue();
    342         assertTrue("incorrect byteValue", bNumber == result);
    343     }
    344 
    345     public void test_ShortValueNeg() {
    346         String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
    347         BigDecimal aNumber = new BigDecimal(a);
    348         int result = 23449;
    349         assertTrue("incorrect value", aNumber.shortValue() == result);
    350     }
    351 
    352     public void test_ShortValuePos() {
    353         String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
    354         BigDecimal aNumber = new BigDecimal(a);
    355         int result = -23449;
    356         assertTrue("incorrect value", aNumber.shortValue() == result);
    357     }
    358 
    359     public void test_ShortValueExactNeg() {
    360         String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
    361         BigDecimal aNumber = new BigDecimal(a);
    362         try {
    363             aNumber.shortValueExact();
    364             fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
    365         } catch (java.lang.ArithmeticException ae) {
    366             // expected;
    367         }
    368     }
    369 
    370     public void test_ShortValueExactPos() {
    371         String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
    372         BigDecimal aNumber = new BigDecimal(a);
    373         try {
    374             aNumber.shortValueExact();
    375             fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
    376         } catch (java.lang.ArithmeticException ae) {
    377             // expected;
    378         }
    379     }
    380 
    381     public void test_ShortValueExactFloatNeg() {
    382         BigDecimal aNumber = new BigDecimal("-32766.99999");
    383         try {
    384             aNumber.shortValueExact();
    385             fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
    386         } catch (java.lang.ArithmeticException ae) {
    387             // expected;
    388         }
    389     }
    390 
    391     public void test_ShortValueExactFloatPos() {
    392         float a = 32767.99999F;
    393         BigDecimal aNumber = new BigDecimal(a);
    394         try {
    395             aNumber.shortValueExact();
    396             fail("java.lang.ArithmeticException isn't thrown after calling intValueExact");
    397         } catch (java.lang.ArithmeticException ae) {
    398             // expected;
    399         }
    400     }
    401 
    402     public void test_ShortValueExactLongPos() {
    403         long a = 12345L;
    404         BigDecimal aNumber = new BigDecimal(a);
    405         short shNumber = aNumber.shortValueExact();
    406         assertTrue("incorrect value", shNumber == a);
    407     }
    408 
    409     public void test_ShortValueExactLongNeg() {
    410         long a = -12345L;
    411         BigDecimal aNumber = new BigDecimal(a);
    412         int iNumber = aNumber.shortValueExact();
    413         assertTrue("incorrect value", iNumber == a);
    414     }
    415 
    416     public void test_stripTrailingZerosZeros() {
    417 
    418         BigDecimal bdNumber = new BigDecimal("0000000");
    419         BigDecimal result = bdNumber.stripTrailingZeros();
    420         assertEquals("incorrect value", result.unscaledValue(), bdNumber.unscaledValue());
    421         assertTrue("incorrect value", result.scale() == 0);
    422 
    423         bdNumber = new BigDecimal(0);
    424         result = bdNumber.stripTrailingZeros();
    425         assertEquals("incorrect value", result.unscaledValue(), bdNumber.unscaledValue());
    426         assertTrue("incorrect value", result.scale() == 0);
    427 
    428         bdNumber = new BigDecimal(0.000000);
    429         result = bdNumber.stripTrailingZeros();
    430         assertEquals("incorrect value", result.unscaledValue(), bdNumber.unscaledValue());
    431         assertTrue("incorrect value", result.scale() == 0);
    432     }
    433 
    434     public void test_stripTrailingZeros() {
    435         String s = "00000000100000000100000000.000000000100000000";
    436         int iScale = 10;
    437         BigDecimal bdValue = new BigDecimal("1000000001000000000000000001");
    438         BigDecimal bdNumber = new BigDecimal(s);
    439         BigDecimal bdResult = bdNumber.stripTrailingZeros();
    440         assertEquals("incorrect value", bdResult.unscaledValue(), bdValue.unscaledValue());
    441         assertTrue("incorrect value", bdResult.scale() == iScale);
    442 
    443         s = "1000.0";
    444         iScale = -3;
    445         BigDecimal bd = new BigDecimal("1");
    446         bdNumber = new BigDecimal(s);
    447         bdResult = bdNumber.stripTrailingZeros();
    448         assertEquals("incorrect value", bdResult.unscaledValue(), bd.unscaledValue());
    449         assertTrue("incorrect value", bdResult.scale() == iScale);
    450     }
    451 }
    452