yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/type/NumberUtilTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. 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.model.util.type;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertTrue;
  12
  13 import java.math.BigDecimal;
  14 import java.math.BigInteger;
  15 import java.util.function.Function;
  16 import org.junit.Test;
  17 import org.opendaylight.yangtools.yang.common.Uint16;
  18 import org.opendaylight.yangtools.yang.common.Uint32;
  19 import org.opendaylight.yangtools.yang.common.Uint64;
  20
  21 public class NumberUtilTest {
  22
  23     @Test
  24     public void testRangeCoveredForShort() {
  25         final short min = 100;
  26         final short superMin = 50;
  27         final short max = 200;
  28         final short superMax = 300;
  29
  30         assertTrue(NumberUtil.isRangeCovered(min, max, superMin, superMax));
  31     }
  32
  33     @Test
  34     public void testRangeCoveredForLong() {
  35         final long min = 100L;
  36         final long superMin = 50L;
  37         final long max = 200L;
  38         final long superMax = 300L;
  39
  40         assertTrue(NumberUtil.isRangeCovered(min, max, superMin, superMax));
  41     }
  42
  43     @Test
  44     public void testRangeCoveredForBigDecimal() {
  45         final BigDecimal min = new BigDecimal(100.0);
  46         final BigDecimal superMin = new BigDecimal(50.0);
  47         final BigDecimal max = new BigDecimal(200.0);
  48         final BigDecimal superMax = new BigDecimal(300.0);
  49
  50         assertTrue(NumberUtil.isRangeCovered(min, max, superMin, superMax));
  51     }
  52
  53     @Test
  54     public void testRangeCoveredForUint8() {
  55         final Uint64 min = Uint64.valueOf("100");
  56         final Uint64 superMin = Uint64.valueOf("50");
  57         final Uint64 max = Uint64.valueOf("200");
  58         final Uint64 superMax = Uint64.valueOf("250");
  59
  60         assertTrue(NumberUtil.isRangeCovered(min, max, superMin, superMax));
  61     }
  62
  63     @Test
  64     public void testRangeCoveredForUint16() {
  65         final Uint16 min = Uint16.valueOf("100");
  66         final Uint16 superMin = Uint16.valueOf("50");
  67         final Uint16 max = Uint16.valueOf("200");
  68         final Uint16 superMax = Uint16.valueOf("300");
  69
  70         assertTrue(NumberUtil.isRangeCovered(min, max, superMin, superMax));
  71     }
  72
  73     @Test
  74     public void testRangeCoveredForUint32() {
  75         final Uint32 min = Uint32.valueOf("100");
  76         final Uint32 superMin = Uint32.valueOf("50");
  77         final Uint32 max = Uint32.valueOf("200");
  78         final Uint32 superMax = Uint32.valueOf("300");
  79
  80         assertTrue(NumberUtil.isRangeCovered(min, max, superMin, superMax));
  81     }
  82
  83     @Test
  84     public void testRangeCoveredForUint64() {
  85         final Uint64 min = Uint64.valueOf("100");
  86         final Uint64 superMin = Uint64.valueOf("50");
  87         final Uint64 max = Uint64.valueOf("200");
  88         final Uint64 superMax = Uint64.valueOf("300");
  89
  90         assertTrue(NumberUtil.isRangeCovered(min, max, superMin, superMax));
  91     }
  92
  93     @Test(expected = IllegalArgumentException.class)
  94     public void testRangeCoveredForUnsupportedNumberType() {
  95         final double min = 100.0;
  96         final double superMin = 50.0;
  97         final double max = 200.0;
  98         final double superMax = 300.0;
  99
 100         NumberUtil.isRangeCovered(min, max, superMin, superMax);
 101     }
 102
 103     @Test
 104     public void testConverterToShort() {
 105         final Short shortNum = 20;
 106         final Function<Number, Short> numberFunction = NumberUtil.converterTo(Short.class);
 107         assertEquals(shortNum, numberFunction.apply(shortNum));
 108
 109         final byte byteNum = 20;
 110         assertEquals(shortNum, numberFunction.apply(byteNum));
 111
 112         final int intNum = 20;
 113         assertEquals(shortNum, numberFunction.apply(intNum));
 114     }
 115
 116     @Test
 117     public void testConverterToInteger() {
 118         final Integer intNum = 20;
 119         final byte byteNum = 20;
 120         final Function<Number, Integer> numberFunction = NumberUtil.converterTo(Integer.class);
 121         assertEquals(intNum, numberFunction.apply(byteNum));
 122     }
 123
 124     @Test
 125     public void testConverterToLong() {
 126         final Long longNum = 20L;
 127         final Function<Number, Long> numberFunction = NumberUtil.converterTo(Long.class);
 128         assertEquals(longNum, numberFunction.apply(longNum));
 129
 130         final byte byteNum = 20;
 131         assertEquals(longNum, numberFunction.apply(byteNum));
 132
 133         final BigInteger bigIntNum = new BigInteger("20");
 134         assertEquals(longNum, numberFunction.apply(bigIntNum));
 135     }
 136
 137     @Test
 138     public void testConverterToBigDecimal() {
 139         BigDecimal bigDecNum = new BigDecimal(20.0);
 140         final Function<Number, BigDecimal> numberFunction = NumberUtil.converterTo(BigDecimal.class);
 141         assertEquals(bigDecNum, numberFunction.apply(bigDecNum));
 142
 143         int intNum = 20;
 144         assertEquals(bigDecNum, numberFunction.apply(intNum));
 145
 146         double doubleNum = 20.0;
 147         bigDecNum = new BigDecimal("20.0");
 148         assertEquals(bigDecNum, numberFunction.apply(doubleNum));
 149     }
 150
 151     @Test
 152     public void testConverterToUint64() {
 153         final Uint64 bigIntNum = Uint64.valueOf("20");
 154         final Function<Number, Uint64> numberFunction = NumberUtil.converterTo(Uint64.class);
 155         assertEquals(bigIntNum, numberFunction.apply(bigIntNum));
 156
 157         final int intNum = 20;
 158         assertEquals(bigIntNum, numberFunction.apply(intNum));
 159
 160         final BigDecimal bigDecNum = new BigDecimal(20.0);
 161         assertEquals(bigIntNum, numberFunction.apply(bigDecNum));
 162     }
 163 }