yang/yang-common/src/test/java/org/opendaylight/yangtools/yang/common/Decimal64Test.java

   1 /*
   2  * Copyright (c) 2017 Pantheon Technologies s.r.o. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.common;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertTrue;
  13
  14 import java.math.BigDecimal;
  15 import org.junit.Test;
  16
  17 public class Decimal64Test {
  18
  19     @Test(expected = NumberFormatException.class)
  20     public void testParseEmpty() {
  21         Decimal64.valueOf("");
  22     }
  23
  24     @Test(expected = NumberFormatException.class)
  25     public void testParseSingleIllegal() {
  26         Decimal64.valueOf("a");
  27     }
  28
  29     @Test(expected = NumberFormatException.class)
  30     public void testParseSingleHighIllegal() {
  31         Decimal64.valueOf(":");
  32     }
  33
  34     @Test(expected = NumberFormatException.class)
  35     public void testParseZeroIllegal() {
  36         Decimal64.valueOf("0a");
  37     }
  38
  39     @Test(expected = NumberFormatException.class)
  40     public void testParseZeroHighIllegal() {
  41         Decimal64.valueOf("0:");
  42     }
  43
  44     @Test(expected = NumberFormatException.class)
  45     public void testParseZeroPointIllegal() {
  46         Decimal64.valueOf("0.a");
  47     }
  48
  49     @Test(expected = NumberFormatException.class)
  50     public void testParseZeroPointHighIllegal() {
  51         Decimal64.valueOf("0.:");
  52     }
  53
  54     @Test(expected = NumberFormatException.class)
  55     public void testParsePointIllegal() {
  56         Decimal64.valueOf(".a");
  57     }
  58
  59     @Test(expected = NullPointerException.class)
  60     public void testParseNull() {
  61         Decimal64.valueOf((String)null);
  62     }
  63
  64     @Test(expected = NumberFormatException.class)
  65     public void testParseMinus() {
  66         Decimal64.valueOf("-");
  67     }
  68
  69     @Test(expected = NumberFormatException.class)
  70     public void testParsePlus() {
  71         Decimal64.valueOf("+");
  72     }
  73
  74     @Test(expected = NumberFormatException.class)
  75     public void testParsePeriod() {
  76         Decimal64.valueOf(".");
  77     }
  78
  79     @Test(expected = NumberFormatException.class)
  80     public void testParseTwoPeriods() {
  81         Decimal64.valueOf("..");
  82     }
  83
  84     @Test(expected = NumberFormatException.class)
  85     public void testParseTrailingPeriod() {
  86         Decimal64.valueOf("0.");
  87     }
  88
  89     @Test(expected = NumberFormatException.class)
  90     public void testParseMultiplePeriods() {
  91         Decimal64.valueOf("0.1.");
  92     }
  93
  94     @Test
  95     public void testParseLongString() {
  96         Decimal64.valueOf("123456789012345678");
  97     }
  98
  99     @Test
 100     public void testParseLongDecimal() {
 101         Decimal64.valueOf("0.12345678901234568");
 102     }
 103
 104     @Test(expected = NumberFormatException.class)
 105     public void testParseTooLongString() {
 106         Decimal64.valueOf("1234567890123456789");
 107     }
 108
 109     @Test(expected = NumberFormatException.class)
 110     public void testParseTooLongDecimal() {
 111         Decimal64.valueOf("0.123456789012345689");
 112     }
 113
 114     @Test
 115     public void testParse() {
 116         assertParsedVariants("0", 0, 0, 1);
 117         assertParsedVariants("0.00", 0, 0, 1);
 118         assertParsedVariants("00.0", 0, 0, 1);
 119         assertParsedVariants("000.0", 0, 0, 1);
 120         assertCanonicalVariants("10.0", 10, 0, 1);
 121         assertCanonicalVariants("10.09", 10, 9, 2);
 122         assertParsedVariants("10.0900900", 10, 9009, 5);
 123         assertParsedVariants("0002210.09", 2210, 9, 2);
 124
 125         Decimal64 parsed = assertParsedString("0.0", 0, 0, 1, false);
 126         parsed = assertParsedString("+0.0", 0, 0, 1, false);
 127         assertEquals("0.0", parsed.toString());
 128         assertEquals("0.0", parsed.toString());
 129         parsed = assertParsedString("-0.0", 0, 0, 1, true);
 130         assertEquals("0.0", parsed.toString());
 131
 132         assertCanonicalVariants("1.0", 1, 0, 1);
 133         assertCanonicalVariants("2.3", 2, 3, 1);
 134     }
 135
 136     @Test
 137     public void testCompare() {
 138         final Decimal64 one = Decimal64.valueOf("1");
 139         final Decimal64 two = Decimal64.valueOf("2");
 140         final Decimal64 three = Decimal64.valueOf("3");
 141         final Decimal64 negOne = Decimal64.valueOf("-1");
 142         final Decimal64 anotherOne = Decimal64.valueOf("1");
 143
 144         assertEquals(0, one.compareTo(one));
 145         assertEquals(0, one.compareTo(anotherOne));
 146         assertEquals(-1, one.compareTo(two));
 147         assertEquals(-1, one.compareTo(three));
 148         assertEquals(1, one.compareTo(negOne));
 149
 150         assertEquals(1, two.compareTo(one));
 151         assertEquals(1, two.compareTo(anotherOne));
 152         assertEquals(-1, two.compareTo(three));
 153         assertEquals(1, one.compareTo(negOne));
 154     }
 155
 156     @Test
 157     public void testEquals() {
 158         final Decimal64 one = Decimal64.valueOf("1");
 159         final Decimal64 two = Decimal64.valueOf("2");
 160         final Decimal64 anotherOne = Decimal64.valueOf("1");
 161
 162         assertTrue(one.equals(one));
 163         assertTrue(one.equals(anotherOne));
 164         assertFalse(one.equals(two));
 165         assertTrue(two.equals(two));
 166         assertFalse(two.equals(one));
 167
 168         assertFalse(one.equals(new Object()));
 169     }
 170
 171     @Test
 172     public void testConversions() {
 173         assertEquals(new BigDecimal("0.12"), Decimal64.valueOf("0.12").decimalValue());
 174         assertEquals(new BigDecimal("-0.12"), Decimal64.valueOf("-0.12").decimalValue());
 175         assertEquals(new BigDecimal("0.12"), Decimal64.valueOf("+0.12").decimalValue());
 176         assertEquals(new BigDecimal("123.456"), Decimal64.valueOf("123.456").decimalValue());
 177         assertEquals(new BigDecimal("-123.456"), Decimal64.valueOf("-123.456").decimalValue());
 178
 179         assertEquals(0.12, Decimal64.valueOf("0.12").doubleValue(), 0);
 180         assertEquals(-0.12, Decimal64.valueOf("-0.12").doubleValue(), 0);
 181
 182         assertEquals((float) 0.12, Decimal64.valueOf("0.12").floatValue(), 0);
 183         assertEquals((float) -0.12, Decimal64.valueOf("-0.12").floatValue(), 0);
 184
 185         assertEquals(12345678901L, Decimal64.valueOf("12345678901").longValue());
 186         assertEquals(-12345678901L, Decimal64.valueOf("-12345678901").longValue());
 187     }
 188
 189     @Test
 190     public void testFactories() {
 191         assertEquals("0.0", Decimal64.valueOf((byte) 0).toString());
 192         assertEquals("1.0", Decimal64.valueOf((byte) 1).toString());
 193         assertEquals("-1.0", Decimal64.valueOf((byte) -1).toString());
 194
 195         assertEquals("0.0", Decimal64.valueOf((short) 0).toString());
 196         assertEquals("1.0", Decimal64.valueOf((short) 1).toString());
 197         assertEquals("-1.0", Decimal64.valueOf((short) -1).toString());
 198
 199         assertEquals("0.0", Decimal64.valueOf(0).toString());
 200         assertEquals("1.0", Decimal64.valueOf(1).toString());
 201         assertEquals("-1.0", Decimal64.valueOf(-1).toString());
 202
 203         assertEquals("0.0", Decimal64.valueOf(0L).toString());
 204         assertEquals("1.0", Decimal64.valueOf(1L).toString());
 205         assertEquals("-1.0", Decimal64.valueOf(-1L).toString());
 206
 207         assertEquals("0.0", Decimal64.valueOf(0.0).toString());
 208         assertEquals("1.0", Decimal64.valueOf(1.0).toString());
 209         assertEquals("-1.0", Decimal64.valueOf(-1.0).toString());
 210
 211         assertEquals("0.0", Decimal64.valueOf(BigDecimal.ZERO).toString());
 212         assertEquals("1.0", Decimal64.valueOf(BigDecimal.ONE).toString());
 213         assertEquals("-1.0", Decimal64.valueOf(BigDecimal.ONE.negate()).toString());
 214     }
 215
 216     @Test
 217     public void testBoundaries() {
 218         assertEquals(-128L, Decimal64.valueOf(Byte.MIN_VALUE).longValue());
 219         assertEquals(127L, Decimal64.valueOf(Byte.MAX_VALUE).longValue());
 220         assertEquals(-32768L, Decimal64.valueOf(Short.MIN_VALUE).longValue());
 221         assertEquals(32767L, Decimal64.valueOf(Short.MAX_VALUE).longValue());
 222         assertEquals(-2147483648L, Decimal64.valueOf(Integer.MIN_VALUE).longValue());
 223         assertEquals(2147483647L, Decimal64.valueOf(Integer.MAX_VALUE).longValue());
 224     }
 225
 226     @Test
 227     public void testByteValueExact() {
 228         assertEquals(Byte.MIN_VALUE, Decimal64.valueOf(Byte.MIN_VALUE).byteValueExact());
 229         assertEquals(Byte.MAX_VALUE, Decimal64.valueOf(Byte.MAX_VALUE).byteValueExact());
 230     }
 231
 232     @Test(expected = ArithmeticException.class)
 233     public void testByteValueExactFrac() {
 234         Decimal64.valueOf("1.1").byteValueExact();
 235     }
 236
 237     @Test(expected = ArithmeticException.class)
 238     public void testByteValueExactRange() {
 239         Decimal64.valueOf(Byte.MAX_VALUE + 1).byteValueExact();
 240     }
 241
 242     @Test
 243     public void testShortValueExact() {
 244         assertEquals(Short.MIN_VALUE, Decimal64.valueOf(Short.MIN_VALUE).shortValueExact());
 245         assertEquals(Short.MAX_VALUE, Decimal64.valueOf(Short.MAX_VALUE).shortValueExact());
 246     }
 247
 248     @Test(expected = ArithmeticException.class)
 249     public void testShortValueExactFrac() {
 250         Decimal64.valueOf("1.1").shortValueExact();
 251     }
 252
 253     @Test(expected = ArithmeticException.class)
 254     public void testShortValueExactRange() {
 255         Decimal64.valueOf(Short.MAX_VALUE + 1).shortValueExact();
 256     }
 257
 258     @Test
 259     public void testIntValueExact() {
 260         assertEquals(Integer.MIN_VALUE, Decimal64.valueOf(Integer.MIN_VALUE).intValueExact());
 261         assertEquals(Integer.MAX_VALUE, Decimal64.valueOf(Integer.MAX_VALUE).intValueExact());
 262     }
 263
 264     @Test(expected = ArithmeticException.class)
 265     public void testIntValueExactFrac() {
 266         Decimal64.valueOf("1.1").intValueExact();
 267     }
 268
 269     @Test(expected = ArithmeticException.class)
 270     public void testIntValueExactRange() {
 271         Decimal64.valueOf(Integer.MAX_VALUE + 1L).intValueExact();
 272     }
 273
 274     @Test(expected = ArithmeticException.class)
 275     public void testLongValueExactFrac() {
 276         Decimal64.valueOf("1.1").longValueExact();
 277     }
 278
 279     private static void assertCanonicalVariants(final String str, final long intPart, final long fracPart,
 280             final int digits) {
 281         assertCanonicalString(str, intPart, fracPart, digits, false);
 282         assertCanonicalString("-" + str, intPart, fracPart, digits, true);
 283
 284         final Decimal64 parsed = assertParsedString("+" + str, intPart, fracPart, digits, false);
 285         assertEquals(str, parsed.toString());
 286     }
 287
 288     private static void assertParsedVariants(final String str, final long intPart, final long fracPart,
 289             final int digits) {
 290         assertParsedString(str, intPart, fracPart, digits, false);
 291         assertParsedString("-" + str, intPart, fracPart, digits, true);
 292         assertParsedString("+" + str, intPart, fracPart, digits, false);
 293     }
 294
 295     private static void assertCanonicalString(final String str, final long intPart, final long fracPart,
 296             final int digits, final boolean negative) {
 297         final Decimal64 parsed = assertParsedString(str, intPart, fracPart, digits, negative);
 298         assertEquals(str, parsed.toString());
 299     }
 300
 301     private static Decimal64 assertParsedString(final String str, final long intPart, final long fracPart,
 302             final int digits, final boolean negative) {
 303         final Decimal64 parsed = Decimal64.valueOf(str);
 304         assertEquals(new Decimal64((byte) digits, intPart, fracPart, negative), parsed);
 305         return parsed;
 306     }
 307 }