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.assertThrows;
  13 import static org.junit.Assert.assertTrue;
  14
  15 import java.math.BigDecimal;
  16 import org.junit.Test;
  17
  18 public class Decimal64Test {
  19     @Test
  20     public void testParseEmpty() {
  21         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf(""));
  22     }
  23
  24     @Test
  25     public void testParseSingleIllegal() {
  26         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf("a"));
  27     }
  28
  29     @Test
  30     public void testParseSingleHighIllegal() {
  31         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf(":"));
  32     }
  33
  34     @Test
  35     public void testParseZeroIllegal() {
  36         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf("0a"));
  37     }
  38
  39     @Test
  40     public void testParseZeroHighIllegal() {
  41         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf("0:"));
  42     }
  43
  44     @Test
  45     public void testParseZeroPointIllegal() {
  46         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf("0.a"));
  47     }
  48
  49     @Test
  50     public void testParseZeroPointHighIllegal() {
  51         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf("0.:"));
  52     }
  53
  54     @Test
  55     public void testParsePointIllegal() {
  56         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf(".a"));
  57     }
  58
  59     @Test
  60     public void testParseMinus() {
  61         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf("-"));
  62     }
  63
  64     @Test
  65     public void testParsePlus() {
  66         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf("+"));
  67     }
  68
  69     @Test
  70     public void testParsePeriod() {
  71         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf("."));
  72     }
  73
  74     @Test
  75     public void testParseTwoPeriods() {
  76         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf(".."));
  77     }
  78
  79     @Test
  80     public void testParseTrailingPeriod() {
  81         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf("0."));
  82     }
  83
  84     @Test
  85     public void testParseMultiplePeriods() {
  86         assertThrows(NumberFormatException.class, () -> 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
 100     public void testParseTooLongString() {
 101         assertThrows(NumberFormatException.class, () -> Decimal64.valueOf("1234567890123456789"));
 102     }
 103
 104     @Test
 105     public void testParseTooLongDecimal() {
 106         assertThrows(NumberFormatException.class, () -> 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
 228     public void testByteValueExactFrac() {
 229         final Decimal64 dec = Decimal64.valueOf("1.1");
 230         assertThrows(ArithmeticException.class, () -> dec.byteValueExact());
 231     }
 232
 233     @Test
 234     public void testByteValueExactRange() {
 235         final Decimal64 dec = Decimal64.valueOf(Byte.MAX_VALUE + 1);
 236         assertThrows(ArithmeticException.class, () -> dec.byteValueExact());
 237     }
 238
 239     @Test
 240     public void testShortValueExact() {
 241         assertEquals(Short.MIN_VALUE, Decimal64.valueOf(Short.MIN_VALUE).shortValueExact());
 242         assertEquals(Short.MAX_VALUE, Decimal64.valueOf(Short.MAX_VALUE).shortValueExact());
 243     }
 244
 245     @Test
 246     public void testShortValueExactFrac() {
 247         final Decimal64 dec = Decimal64.valueOf("1.1");
 248         assertThrows(ArithmeticException.class, () -> dec.shortValueExact());
 249     }
 250
 251     @Test
 252     public void testShortValueExactRange() {
 253         final Decimal64 dec = Decimal64.valueOf(Short.MAX_VALUE + 1);
 254         assertThrows(ArithmeticException.class, () -> dec.shortValueExact());
 255     }
 256
 257     @Test
 258     public void testIntValueExact() {
 259         assertEquals(Integer.MIN_VALUE, Decimal64.valueOf(Integer.MIN_VALUE).intValueExact());
 260         assertEquals(Integer.MAX_VALUE, Decimal64.valueOf(Integer.MAX_VALUE).intValueExact());
 261     }
 262
 263     @Test
 264     public void testIntValueExactFrac() {
 265         final Decimal64 dec = Decimal64.valueOf("1.1");
 266         assertThrows(ArithmeticException.class, () -> dec.intValueExact());
 267     }
 268
 269     @Test
 270     public void testIntValueExactRange() {
 271         final Decimal64 dec = Decimal64.valueOf(Integer.MAX_VALUE + 1L);
 272         assertThrows(ArithmeticException.class, () -> dec.intValueExact());
 273     }
 274
 275     @Test
 276     public void testLongValueExactFrac() {
 277         final Decimal64 dec = Decimal64.valueOf("1.1");
 278         assertThrows(ArithmeticException.class, () -> dec.longValueExact());
 279     }
 280
 281     private static void assertCanonicalVariants(final String str, final long intPart, final long fracPart,
 282             final int digits) {
 283         assertCanonicalString(str, intPart, fracPart, digits, false);
 284         assertCanonicalString("-" + str, intPart, fracPart, digits, true);
 285
 286         final Decimal64 parsed = assertParsedString("+" + str, intPart, fracPart, digits, false);
 287         assertEquals(str, parsed.toString());
 288     }
 289
 290     private static void assertParsedVariants(final String str, final long intPart, final long fracPart,
 291             final int digits) {
 292         assertParsedString(str, intPart, fracPart, digits, false);
 293         assertParsedString("-" + str, intPart, fracPart, digits, true);
 294         assertParsedString("+" + str, intPart, fracPart, digits, false);
 295     }
 296
 297     private static void assertCanonicalString(final String str, final long intPart, final long fracPart,
 298             final int digits, final boolean negative) {
 299         final Decimal64 parsed = assertParsedString(str, intPart, fracPart, digits, negative);
 300         assertEquals(str, parsed.toString());
 301     }
 302
 303     private static Decimal64 assertParsedString(final String str, final long intPart, final long fracPart,
 304             final int digits, final boolean negative) {
 305         final Decimal64 parsed = Decimal64.valueOf(str);
 306         assertEquals(new Decimal64((byte) digits, intPart, fracPart, negative), parsed);
 307         return parsed;
 308     }
 309 }