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 = NumberFormatException.class)
  60     public void testParseMinus() {
  61         Decimal64.valueOf("-");
  62     }
  63
  64     @Test(expected = NumberFormatException.class)
  65     public void testParsePlus() {
  66         Decimal64.valueOf("+");
  67     }
  68
  69     @Test(expected = NumberFormatException.class)
  70     public void testParsePeriod() {
  71         Decimal64.valueOf(".");
  72     }
  73
  74     @Test(expected = NumberFormatException.class)
  75     public void testParseTwoPeriods() {
  76         Decimal64.valueOf("..");
  77     }
  78
  79     @Test(expected = NumberFormatException.class)
  80     public void testParseTrailingPeriod() {
  81         Decimal64.valueOf("0.");
  82     }
  83
  84     @Test(expected = NumberFormatException.class)
  85     public void testParseMultiplePeriods() {
  86         Decimal64.valueOf("0.1.");
  87     }
  88
  89     @Test
  90     public void testParseLongString() {
  91         Decimal64.valueOf("123456789012345678");
  92     }
  93
  94     @Test
  95     public void testParseLongDecimal() {
  96         Decimal64.valueOf("0.12345678901234568");
  97     }
  98
  99     @Test(expected = NumberFormatException.class)
 100     public void testParseTooLongString() {
 101         Decimal64.valueOf("1234567890123456789");
 102     }
 103
 104     @Test(expected = NumberFormatException.class)
 105     public void testParseTooLongDecimal() {
 106         Decimal64.valueOf("0.123456789012345689");
 107     }
 108
 109     @Test
 110     public void testParse() {
 111         assertParsedVariants("0", 0, 0, 1);
 112         assertParsedVariants("0.00", 0, 0, 1);
 113         assertParsedVariants("00.0", 0, 0, 1);
 114         assertParsedVariants("000.0", 0, 0, 1);
 115         assertCanonicalVariants("10.0", 10, 0, 1);
 116         assertCanonicalVariants("10.09", 10, 9, 2);
 117         assertParsedVariants("10.0900900", 10, 9009, 5);
 118         assertParsedVariants("0002210.09", 2210, 9, 2);
 119
 120         Decimal64 parsed = assertParsedString("0.0", 0, 0, 1, false);
 121         parsed = assertParsedString("+0.0", 0, 0, 1, false);
 122         assertEquals("0.0", parsed.toString());
 123         assertEquals("0.0", parsed.toString());
 124         parsed = assertParsedString("-0.0", 0, 0, 1, true);
 125         assertEquals("0.0", parsed.toString());
 126
 127         assertCanonicalVariants("1.0", 1, 0, 1);
 128         assertCanonicalVariants("2.3", 2, 3, 1);
 129     }
 130
 131     @Test
 132     public void testCompare() {
 133         final Decimal64 one = Decimal64.valueOf("1");
 134         final Decimal64 two = Decimal64.valueOf("2");
 135         final Decimal64 three = Decimal64.valueOf("3");
 136         final Decimal64 negOne = Decimal64.valueOf("-1");
 137         final Decimal64 anotherOne = Decimal64.valueOf("1");
 138
 139         assertEquals(0, one.compareTo(one));
 140         assertEquals(0, one.compareTo(anotherOne));
 141         assertEquals(-1, one.compareTo(two));
 142         assertEquals(-1, one.compareTo(three));
 143         assertEquals(1, one.compareTo(negOne));
 144
 145         assertEquals(1, two.compareTo(one));
 146         assertEquals(1, two.compareTo(anotherOne));
 147         assertEquals(-1, two.compareTo(three));
 148         assertEquals(1, one.compareTo(negOne));
 149     }
 150
 151     @Test
 152     public void testEquals() {
 153         final Decimal64 one = Decimal64.valueOf("1");
 154         final Decimal64 two = Decimal64.valueOf("2");
 155         final Decimal64 anotherOne = Decimal64.valueOf("1");
 156
 157         assertTrue(one.equals(one));
 158         assertTrue(one.equals(anotherOne));
 159         assertFalse(one.equals(two));
 160         assertTrue(two.equals(two));
 161         assertFalse(two.equals(one));
 162
 163         assertFalse(one.equals(new Object()));
 164     }
 165
 166     @Test
 167     public void testConversions() {
 168         assertEquals(new BigDecimal("0.12"), Decimal64.valueOf("0.12").decimalValue());
 169         assertEquals(new BigDecimal("-0.12"), Decimal64.valueOf("-0.12").decimalValue());
 170         assertEquals(new BigDecimal("0.12"), Decimal64.valueOf("+0.12").decimalValue());
 171         assertEquals(new BigDecimal("123.456"), Decimal64.valueOf("123.456").decimalValue());
 172         assertEquals(new BigDecimal("-123.456"), Decimal64.valueOf("-123.456").decimalValue());
 173
 174         assertEquals(0.12, Decimal64.valueOf("0.12").doubleValue(), 0);
 175         assertEquals(-0.12, Decimal64.valueOf("-0.12").doubleValue(), 0);
 176
 177         assertEquals((float) 0.12, Decimal64.valueOf("0.12").floatValue(), 0);
 178         assertEquals((float) -0.12, Decimal64.valueOf("-0.12").floatValue(), 0);
 179
 180         assertEquals(12345678901L, Decimal64.valueOf("12345678901").longValue());
 181         assertEquals(-12345678901L, Decimal64.valueOf("-12345678901").longValue());
 182     }
 183
 184     @Test
 185     public void testFactories() {
 186         assertEquals("0.0", Decimal64.valueOf((byte) 0).toString());
 187         assertEquals("1.0", Decimal64.valueOf((byte) 1).toString());
 188         assertEquals("-1.0", Decimal64.valueOf((byte) -1).toString());
 189
 190         assertEquals("0.0", Decimal64.valueOf((short) 0).toString());
 191         assertEquals("1.0", Decimal64.valueOf((short) 1).toString());
 192         assertEquals("-1.0", Decimal64.valueOf((short) -1).toString());
 193
 194         assertEquals("0.0", Decimal64.valueOf(0).toString());
 195         assertEquals("1.0", Decimal64.valueOf(1).toString());
 196         assertEquals("-1.0", Decimal64.valueOf(-1).toString());
 197
 198         assertEquals("0.0", Decimal64.valueOf(0L).toString());
 199         assertEquals("1.0", Decimal64.valueOf(1L).toString());
 200         assertEquals("-1.0", Decimal64.valueOf(-1L).toString());
 201
 202         assertEquals("0.0", Decimal64.valueOf(0.0).toString());
 203         assertEquals("1.0", Decimal64.valueOf(1.0).toString());
 204         assertEquals("-1.0", Decimal64.valueOf(-1.0).toString());
 205
 206         assertEquals("0.0", Decimal64.valueOf(BigDecimal.ZERO).toString());
 207         assertEquals("1.0", Decimal64.valueOf(BigDecimal.ONE).toString());
 208         assertEquals("-1.0", Decimal64.valueOf(BigDecimal.ONE.negate()).toString());
 209     }
 210
 211     @Test
 212     public void testBoundaries() {
 213         assertEquals(-128L, Decimal64.valueOf(Byte.MIN_VALUE).longValue());
 214         assertEquals(127L, Decimal64.valueOf(Byte.MAX_VALUE).longValue());
 215         assertEquals(-32768L, Decimal64.valueOf(Short.MIN_VALUE).longValue());
 216         assertEquals(32767L, Decimal64.valueOf(Short.MAX_VALUE).longValue());
 217         assertEquals(-2147483648L, Decimal64.valueOf(Integer.MIN_VALUE).longValue());
 218         assertEquals(2147483647L, Decimal64.valueOf(Integer.MAX_VALUE).longValue());
 219     }
 220
 221     @Test
 222     public void testByteValueExact() {
 223         assertEquals(Byte.MIN_VALUE, Decimal64.valueOf(Byte.MIN_VALUE).byteValueExact());
 224         assertEquals(Byte.MAX_VALUE, Decimal64.valueOf(Byte.MAX_VALUE).byteValueExact());
 225     }
 226
 227     @Test(expected = ArithmeticException.class)
 228     public void testByteValueExactFrac() {
 229         Decimal64.valueOf("1.1").byteValueExact();
 230     }
 231
 232     @Test(expected = ArithmeticException.class)
 233     public void testByteValueExactRange() {
 234         Decimal64.valueOf(Byte.MAX_VALUE + 1).byteValueExact();
 235     }
 236
 237     @Test
 238     public void testShortValueExact() {
 239         assertEquals(Short.MIN_VALUE, Decimal64.valueOf(Short.MIN_VALUE).shortValueExact());
 240         assertEquals(Short.MAX_VALUE, Decimal64.valueOf(Short.MAX_VALUE).shortValueExact());
 241     }
 242
 243     @Test(expected = ArithmeticException.class)
 244     public void testShortValueExactFrac() {
 245         Decimal64.valueOf("1.1").shortValueExact();
 246     }
 247
 248     @Test(expected = ArithmeticException.class)
 249     public void testShortValueExactRange() {
 250         Decimal64.valueOf(Short.MAX_VALUE + 1).shortValueExact();
 251     }
 252
 253     @Test
 254     public void testIntValueExact() {
 255         assertEquals(Integer.MIN_VALUE, Decimal64.valueOf(Integer.MIN_VALUE).intValueExact());
 256         assertEquals(Integer.MAX_VALUE, Decimal64.valueOf(Integer.MAX_VALUE).intValueExact());
 257     }
 258
 259     @Test(expected = ArithmeticException.class)
 260     public void testIntValueExactFrac() {
 261         Decimal64.valueOf("1.1").intValueExact();
 262     }
 263
 264     @Test(expected = ArithmeticException.class)
 265     public void testIntValueExactRange() {
 266         Decimal64.valueOf(Integer.MAX_VALUE + 1L).intValueExact();
 267     }
 268
 269     @Test(expected = ArithmeticException.class)
 270     public void testLongValueExactFrac() {
 271         Decimal64.valueOf("1.1").longValueExact();
 272     }
 273
 274     private static void assertCanonicalVariants(final String str, final long intPart, final long fracPart,
 275             final int digits) {
 276         assertCanonicalString(str, intPart, fracPart, digits, false);
 277         assertCanonicalString("-" + str, intPart, fracPart, digits, true);
 278
 279         final Decimal64 parsed = assertParsedString("+" + str, intPart, fracPart, digits, false);
 280         assertEquals(str, parsed.toString());
 281     }
 282
 283     private static void assertParsedVariants(final String str, final long intPart, final long fracPart,
 284             final int digits) {
 285         assertParsedString(str, intPart, fracPart, digits, false);
 286         assertParsedString("-" + str, intPart, fracPart, digits, true);
 287         assertParsedString("+" + str, intPart, fracPart, digits, false);
 288     }
 289
 290     private static void assertCanonicalString(final String str, final long intPart, final long fracPart,
 291             final int digits, final boolean negative) {
 292         final Decimal64 parsed = assertParsedString(str, intPart, fracPart, digits, negative);
 293         assertEquals(str, parsed.toString());
 294     }
 295
 296     private static Decimal64 assertParsedString(final String str, final long intPart, final long fracPart,
 297             final int digits, final boolean negative) {
 298         final Decimal64 parsed = Decimal64.valueOf(str);
 299         assertEquals(new Decimal64((byte) digits, intPart, fracPart, negative), parsed);
 300         return parsed;
 301     }
 302 }