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  */
     20 
     21 package org.apache.harmony.tests.java.math;
     22 
     23 import java.math.BigDecimal;
     24 import java.math.BigInteger;
     25 import java.math.MathContext;
     26 import java.math.RoundingMode;
     27 
     28 import junit.framework.TestCase;
     29 
     30 /**
     31  * Class:  java.math.BigDecimal
     32  * Methods: abs, compareTo, equals, hashCode,
     33  * max, min, negate, signum
     34  */
     35 public class BigDecimalCompareTest extends TestCase {
     36     /**
     37      * Abs() of a negative BigDecimal
     38      */
     39     public void testAbsNeg() {
     40         String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
     41         BigDecimal aNumber = new BigDecimal(a);
     42         String result = "123809648392384754573567356745735635678902957849027687.87678287";
     43         assertEquals("incorrect value", result, aNumber.abs().toString());
     44     }
     45 
     46     /**
     47      * Abs() of a positive BigDecimal
     48      */
     49     public void testAbsPos() {
     50         String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
     51         BigDecimal aNumber = new BigDecimal(a);
     52         String result = "123809648392384754573567356745735635678902957849027687.87678287";
     53         assertEquals("incorrect value", result, aNumber.abs().toString());
     54     }
     55 
     56     /**
     57      * Abs(MathContext) of a negative BigDecimal
     58      */
     59     public void testAbsMathContextNeg() {
     60         String a = "-123809648392384754573567356745735.63567890295784902768787678287E+21";
     61         BigDecimal aNumber = new BigDecimal(a);
     62         int precision = 15;
     63         RoundingMode rm = RoundingMode.HALF_DOWN;
     64         MathContext mc = new MathContext(precision, rm);
     65         String result = "1.23809648392385E+53";
     66         int resScale = -39;
     67         BigDecimal res = aNumber.abs(mc);
     68         assertEquals("incorrect value", result, res.toString());
     69         assertEquals("incorrect scale", resScale, res.scale());
     70     }
     71 
     72     /**
     73      * Abs(MathContext) of a positive BigDecimal
     74      */
     75     public void testAbsMathContextPos() {
     76         String a = "123809648392384754573567356745735.63567890295784902768787678287E+21";
     77         BigDecimal aNumber = new BigDecimal(a);
     78         int precision = 41;
     79         RoundingMode rm = RoundingMode.HALF_EVEN;
     80         MathContext mc = new MathContext(precision, rm);
     81         String result = "1.2380964839238475457356735674573563567890E+53";
     82         int resScale = -13;
     83         BigDecimal res = aNumber.abs(mc);
     84         assertEquals("incorrect value", result, res.toString());
     85         assertEquals("incorrect scale", resScale, res.scale());
     86     }
     87 
     88     /**
     89      * Compare to a number of an equal scale
     90      */
     91     public void testCompareEqualScale1() {
     92         String a = "12380964839238475457356735674573563567890295784902768787678287";
     93         int aScale = 18;
     94         String b = "4573563567890295784902768787678287";
     95         int bScale = 18;
     96         BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
     97         BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
     98         int result = 1;
     99         assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
    100     }
    101 
    102     /**
    103      * Compare to a number of an equal scale
    104      */
    105     public void testCompareEqualScale2() {
    106         String a = "12380964839238475457356735674573563567890295784902768787678287";
    107         int aScale = 18;
    108         String b = "4573563923487289357829759278282992758247567890295784902768787678287";
    109         int bScale = 18;
    110         BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    111         BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    112         int result = -1;
    113         assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
    114     }
    115 
    116     /**
    117      * Compare to a number of an greater scale
    118      */
    119     public void testCompareGreaterScale1() {
    120         String a = "12380964839238475457356735674573563567890295784902768787678287";
    121         int aScale = 28;
    122         String b = "4573563567890295784902768787678287";
    123         int bScale = 18;
    124         BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    125         BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    126         int result = 1;
    127         assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
    128     }
    129 
    130     /**
    131      * Compare to a number of an greater scale
    132      */
    133     public void testCompareGreaterScale2() {
    134         String a = "12380964839238475457356735674573563567890295784902768787678287";
    135         int aScale = 48;
    136         String b = "4573563567890295784902768787678287";
    137         int bScale = 2;
    138         BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    139         BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    140         int result = -1;
    141         assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
    142     }
    143 
    144     /**
    145      * Compare to a number of an less scale
    146      */
    147     public void testCompareLessScale1() {
    148         String a = "12380964839238475457356735674573563567890295784902768787678287";
    149         int aScale = 18;
    150         String b = "4573563567890295784902768787678287";
    151         int bScale = 28;
    152         BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    153         BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    154         int result = 1;
    155         assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
    156     }
    157 
    158     /**
    159      * Compare to a number of an less scale
    160      */
    161     public void testCompareLessScale2() {
    162         String a = "12380964839238475457356735674573";
    163         int aScale = 36;
    164         String b = "45735635948573894578349572001798379183767890295784902768787678287";
    165         int bScale = 48;
    166         BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    167         BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    168         int result = -1;
    169         assertEquals("incorrect result", result, aNumber.compareTo(bNumber));
    170     }
    171 
    172     /**
    173      * Equals() for unequal BigDecimals
    174      */
    175     public void testEqualsUnequal1() {
    176        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    177        int aScale = -24;
    178        String b = "7472334223847623782375469293018787918347987234564568";
    179        int bScale = 13;
    180        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    181        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    182        assertFalse(aNumber.equals(bNumber));
    183     }
    184 
    185     /**
    186      * Equals() for unequal BigDecimals
    187      */
    188     public void testEqualsUnequal2() {
    189        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    190        int aScale = -24;
    191        String b = "92948782094488478231212478987482988429808779810457634781384756794987";
    192        int bScale = 13;
    193        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    194        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    195        assertFalse(aNumber.equals(bNumber));
    196     }
    197 
    198     /**
    199      * Equals() for unequal BigDecimals
    200      */
    201     public void testEqualsUnequal3() {
    202        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    203        int aScale = -24;
    204        String b = "92948782094488478231212478987482988429808779810457634781384756794987";
    205        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    206        assertFalse(aNumber.equals(b));
    207     }
    208 
    209     /**
    210      * equals() for equal BigDecimals
    211      */
    212     public void testEqualsEqual() {
    213        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    214        int aScale = -24;
    215        String b = "92948782094488478231212478987482988429808779810457634781384756794987";
    216        int bScale = -24;
    217        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    218        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    219        assertEquals(aNumber, bNumber);
    220     }
    221 
    222     /**
    223      * equals() for equal BigDecimals
    224      */
    225     public void testEqualsNull() {
    226        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    227        int aScale = -24;
    228        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    229        assertFalse(aNumber.equals(null));
    230     }
    231 
    232     /**
    233      * hashCode() for equal BigDecimals
    234      */
    235     public void testHashCodeEqual() {
    236        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    237        int aScale = -24;
    238        String b = "92948782094488478231212478987482988429808779810457634781384756794987";
    239        int bScale = -24;
    240        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    241        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    242        assertEquals("incorrect value", aNumber.hashCode(), bNumber.hashCode());
    243     }
    244 
    245     /**
    246      * hashCode() for unequal BigDecimals
    247      */
    248     public void testHashCodeUnequal() {
    249        String a = "8478231212478987482988429808779810457634781384756794987";
    250        int aScale = 41;
    251        String b = "92948782094488478231212478987482988429808779810457634781384756794987";
    252        int bScale = -24;
    253        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    254        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    255        assertTrue("incorrect value", aNumber.hashCode() != bNumber.hashCode());
    256     }
    257 
    258     /**
    259      * max() for equal BigDecimals
    260      */
    261     public void testMaxEqual() {
    262        String a = "8478231212478987482988429808779810457634781384756794987";
    263        int aScale = 41;
    264        String b = "8478231212478987482988429808779810457634781384756794987";
    265        int bScale = 41;
    266        String c = "8478231212478987482988429808779810457634781384756794987";
    267        int cScale = 41;
    268        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    269        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    270        BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
    271        assertEquals("incorrect value", cNumber, aNumber.max(bNumber));
    272     }
    273 
    274     /**
    275      * max() for unequal BigDecimals
    276      */
    277     public void testMaxUnequal1() {
    278        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    279        int aScale = 24;
    280        String b = "92948782094488478231212478987482988429808779810457634781384756794987";
    281        int bScale = 41;
    282        String c = "92948782094488478231212478987482988429808779810457634781384756794987";
    283        int cScale = 24;
    284        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    285        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    286        BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
    287        assertEquals("incorrect value", cNumber, aNumber.max(bNumber));
    288     }
    289 
    290     /**
    291      * max() for unequal BigDecimals
    292      */
    293     public void testMaxUnequal2() {
    294        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    295        int aScale = 41;
    296        String b = "94488478231212478987482988429808779810457634781384756794987";
    297        int bScale = 41;
    298        String c = "92948782094488478231212478987482988429808779810457634781384756794987";
    299        int cScale = 41;
    300        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    301        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    302        BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
    303        assertEquals("incorrect value", cNumber, aNumber.max(bNumber));
    304     }
    305 
    306     /**
    307      * min() for equal BigDecimals
    308      */
    309     public void testMinEqual() {
    310        String a = "8478231212478987482988429808779810457634781384756794987";
    311        int aScale = 41;
    312        String b = "8478231212478987482988429808779810457634781384756794987";
    313        int bScale = 41;
    314        String c = "8478231212478987482988429808779810457634781384756794987";
    315        int cScale = 41;
    316        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    317        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    318        BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
    319        assertEquals("incorrect value", cNumber, aNumber.min(bNumber));
    320     }
    321 
    322     /**
    323      * min() for unequal BigDecimals
    324      */
    325     public void testMinUnequal1() {
    326        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    327        int aScale = 24;
    328        String b = "92948782094488478231212478987482988429808779810457634781384756794987";
    329        int bScale = 41;
    330        String c = "92948782094488478231212478987482988429808779810457634781384756794987";
    331        int cScale = 41;
    332        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    333        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    334        BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
    335        assertEquals("incorrect value", cNumber, aNumber.min(bNumber));
    336     }
    337 
    338     /**
    339      * min() for unequal BigDecimals
    340      */
    341     public void testMinUnequal2() {
    342        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    343        int aScale = 41;
    344        String b = "94488478231212478987482988429808779810457634781384756794987";
    345        int bScale = 41;
    346        String c = "94488478231212478987482988429808779810457634781384756794987";
    347        int cScale = 41;
    348        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    349        BigDecimal bNumber = new BigDecimal(new BigInteger(b), bScale);
    350        BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
    351        assertEquals("incorrect value", cNumber, aNumber.min(bNumber));
    352     }
    353 
    354     /**
    355      * plus() for a positive BigDecimal
    356      */
    357     public void testPlusPositive() {
    358        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    359        int aScale = 41;
    360        String c = "92948782094488478231212478987482988429808779810457634781384756794987";
    361        int cScale = 41;
    362        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    363        BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
    364        assertEquals("incorrect value", cNumber, aNumber.plus());
    365     }
    366 
    367     /**
    368      * plus(MathContext) for a positive BigDecimal
    369      */
    370     public void testPlusMathContextPositive() {
    371        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    372        int aScale = 41;
    373        int precision = 37;
    374        RoundingMode rm = RoundingMode.FLOOR;
    375        MathContext mc = new MathContext(precision, rm);
    376        String c = "929487820944884782312124789.8748298842";
    377        int cScale = 10;
    378        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    379        BigDecimal res = aNumber.plus(mc);
    380        assertEquals("incorrect value", c, res.toString());
    381        assertEquals("incorrect scale", cScale, res.scale());
    382     }
    383 
    384     /**
    385      * plus() for a negative BigDecimal
    386      */
    387     public void testPlusNegative() {
    388        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
    389        int aScale = 41;
    390        String c = "-92948782094488478231212478987482988429808779810457634781384756794987";
    391        int cScale = 41;
    392        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    393        BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
    394        assertEquals("incorrect value", cNumber, aNumber.plus());
    395     }
    396 
    397     /**
    398      * plus(MathContext) for a negative BigDecimal
    399      */
    400     public void testPlusMathContextNegative() {
    401        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
    402        int aScale = 49;
    403        int precision = 46;
    404        RoundingMode rm = RoundingMode.CEILING;
    405        MathContext mc = new MathContext(precision, rm);
    406        String c = "-9294878209448847823.121247898748298842980877981";
    407        int cScale = 27;
    408        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    409        BigDecimal res = aNumber.plus(mc);
    410        assertEquals("incorrect value", c, res.toString());
    411        assertEquals("incorrect scale", cScale, res.scale());
    412     }
    413 
    414     /**
    415      * negate() for a positive BigDecimal
    416      */
    417     public void testNegatePositive() {
    418        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    419        int aScale = 41;
    420        String c = "-92948782094488478231212478987482988429808779810457634781384756794987";
    421        int cScale = 41;
    422        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    423        BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
    424        assertEquals("incorrect value", cNumber, aNumber.negate());
    425     }
    426 
    427     /**
    428      * negate(MathContext) for a positive BigDecimal
    429      */
    430     public void testNegateMathContextPositive() {
    431        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    432        int aScale = 41;
    433        int precision = 37;
    434        RoundingMode rm = RoundingMode.FLOOR;
    435        MathContext mc = new MathContext(precision, rm);
    436        String c = "-929487820944884782312124789.8748298843";
    437        int cScale = 10;
    438        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    439        BigDecimal res = aNumber.negate(mc);
    440        assertEquals("incorrect value", c, res.toString());
    441        assertEquals("incorrect scale", cScale, res.scale());
    442     }
    443 
    444     /**
    445      * negate() for a negative BigDecimal
    446      */
    447     public void testNegateNegative() {
    448        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
    449        int aScale = 41;
    450        String c = "92948782094488478231212478987482988429808779810457634781384756794987";
    451        int cScale = 41;
    452        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    453        BigDecimal cNumber = new BigDecimal(new BigInteger(c), cScale);
    454        assertEquals("incorrect value", cNumber, aNumber.negate());
    455     }
    456 
    457     /**
    458      * negate(MathContext) for a negative BigDecimal
    459      */
    460     public void testNegateMathContextNegative() {
    461        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
    462        int aScale = 49;
    463        int precision = 46;
    464        RoundingMode rm = RoundingMode.CEILING;
    465        MathContext mc = new MathContext(precision, rm);
    466        String c = "9294878209448847823.121247898748298842980877982";
    467        int cScale = 27;
    468        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    469        BigDecimal res = aNumber.negate(mc);
    470        assertEquals("incorrect value", c, res.toString());
    471        assertEquals("incorrect scale", cScale, res.scale());
    472     }
    473 
    474     /**
    475      * signum() for a positive BigDecimal
    476      */
    477     public void testSignumPositive() {
    478        String a = "92948782094488478231212478987482988429808779810457634781384756794987";
    479        int aScale = 41;
    480        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    481        assertEquals("incorrect value", 1, aNumber.signum());
    482     }
    483 
    484     /**
    485      * signum() for a negative BigDecimal
    486      */
    487     public void testSignumNegative() {
    488        String a = "-92948782094488478231212478987482988429808779810457634781384756794987";
    489        int aScale = 41;
    490        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    491        assertEquals("incorrect value", -1, aNumber.signum());
    492     }
    493 
    494     /**
    495      * signum() for zero
    496      */
    497     public void testSignumZero() {
    498        String a = "0";
    499        int aScale = 41;
    500        BigDecimal aNumber = new BigDecimal(new BigInteger(a), aScale);
    501        assertEquals("incorrect value", 0, aNumber.signum());
    502     }
    503 
    504     /*
    505      * Regression test for HARMONY-6406
    506      */
    507     public void testApproxPrecision() {
    508         BigDecimal testInstance = BigDecimal.TEN.multiply(new BigDecimal("0.1"));
    509         int result = testInstance.compareTo(new BigDecimal("1.00"));
    510         assertEquals(0, result);
    511     }
    512 }
    513