yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/test/codecs/IntCodecStringTest.java

   1 /*
   2  * Copyright (c) 2014 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.data.impl.test.codecs;
   9
  10 import static org.junit.Assert.assertEquals;
  11
  12 import java.math.BigInteger;
  13
  14 import org.junit.Test;
  15 import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
  16
  17 public class IntCodecStringTest {
  18
  19     @Test
  20     public void uint8CodecTest() {
  21         final String hexa = "0x40";
  22         final String octal = "0100";
  23         final String integer = "64";
  24
  25         assertEquals(TypeDefinitionAwareCodec.UINT8_DEFAULT_CODEC.deserialize(hexa), Short.valueOf("040", 16));
  26         assertEquals(TypeDefinitionAwareCodec.UINT8_DEFAULT_CODEC.deserialize(octal), Short.valueOf(octal, 8));
  27         assertEquals(TypeDefinitionAwareCodec.UINT8_DEFAULT_CODEC.deserialize(integer), Short.valueOf(integer, 10));
  28         assertEquals(TypeDefinitionAwareCodec.UINT8_DEFAULT_CODEC.deserialize("0"), Short.valueOf("0", 10));
  29     }
  30
  31     @Test
  32     public void uint16CodecTest() {
  33         final String hexa = "0X45c";
  34         final String octal = "02134";
  35         final String integer = "1116";
  36
  37         assertEquals(TypeDefinitionAwareCodec.UINT16_DEFAULT_CODEC.deserialize(hexa), Integer.valueOf("045c", 16));
  38         assertEquals(TypeDefinitionAwareCodec.UINT16_DEFAULT_CODEC.deserialize(octal), Integer.valueOf(octal, 8));
  39         assertEquals(TypeDefinitionAwareCodec.UINT16_DEFAULT_CODEC.deserialize(integer), Integer.valueOf(integer, 10));
  40     }
  41
  42     @Test
  43     public void uint32CodecTest() {
  44         final String hexa = "0x45FFFCDE";
  45         final String octal = "010577776336";
  46         final String integer = "1174404318";
  47
  48         assertEquals(TypeDefinitionAwareCodec.UINT32_DEFAULT_CODEC.deserialize(hexa), Long.valueOf("45FFFCDE", 16));
  49         assertEquals(TypeDefinitionAwareCodec.UINT32_DEFAULT_CODEC.deserialize(octal), Long.valueOf(octal, 8));
  50         assertEquals(TypeDefinitionAwareCodec.UINT32_DEFAULT_CODEC.deserialize(integer), Long.valueOf(integer, 10));
  51     }
  52
  53     @Test
  54     public void uint64CodecTest() {
  55         final String hexa = "0X75EDC78edCBA";
  56         final String octal = "03536670743556272";
  57         final String integer = "129664115727546";
  58
  59         assertEquals(TypeDefinitionAwareCodec.UINT64_DEFAULT_CODEC.deserialize(hexa),
  60                 new BigInteger("75EDC78edCBA", 16));
  61         assertEquals(TypeDefinitionAwareCodec.UINT64_DEFAULT_CODEC.deserialize(octal), new BigInteger(octal, 8));
  62         assertEquals(TypeDefinitionAwareCodec.UINT64_DEFAULT_CODEC.deserialize(integer), new BigInteger(integer, 10));
  63     }
  64
  65     @Test
  66     public void int8CodecTest() {
  67         final String hexa = "0x40";
  68         final String negHexa = "-0x40";
  69         final String octal = "+0100";
  70         final String negOctal = "-0100";
  71         final String integer = "64";
  72         final String negInteger = "-64";
  73
  74         assertEquals(TypeDefinitionAwareCodec.INT8_DEFAULT_CODEC.deserialize(hexa), Byte.valueOf("040", 16));
  75         assertEquals(TypeDefinitionAwareCodec.INT8_DEFAULT_CODEC.deserialize(negHexa), Byte.valueOf("-040", 16));
  76         assertEquals(TypeDefinitionAwareCodec.INT8_DEFAULT_CODEC.deserialize(octal), Byte.valueOf(octal, 8));
  77         assertEquals(TypeDefinitionAwareCodec.INT8_DEFAULT_CODEC.deserialize(negOctal), Byte.valueOf(negOctal, 8));
  78         assertEquals(TypeDefinitionAwareCodec.INT8_DEFAULT_CODEC.deserialize(integer), Byte.valueOf(integer, 10));
  79         assertEquals(TypeDefinitionAwareCodec.INT8_DEFAULT_CODEC.deserialize(negInteger), Byte.valueOf(negInteger, 10));
  80     }
  81
  82     @Test
  83     public void int16CodecTest() {
  84         final String hexa = "+0X45c";
  85         final String negHexa = "-0X45c";
  86         final String octal = "02134";
  87         final String negOctal = "-02134";
  88         final String integer = "+1116";
  89         final String negInteger = "-1116";
  90
  91         assertEquals(TypeDefinitionAwareCodec.INT16_DEFAULT_CODEC.deserialize(hexa), Short.valueOf("+045c", 16));
  92         assertEquals(TypeDefinitionAwareCodec.INT16_DEFAULT_CODEC.deserialize(negHexa), Short.valueOf("-045c", 16));
  93         assertEquals(TypeDefinitionAwareCodec.INT16_DEFAULT_CODEC.deserialize(octal), Short.valueOf(octal, 8));
  94         assertEquals(TypeDefinitionAwareCodec.INT16_DEFAULT_CODEC.deserialize(negOctal), Short.valueOf(negOctal, 8));
  95         assertEquals(TypeDefinitionAwareCodec.INT16_DEFAULT_CODEC.deserialize(integer), Short.valueOf(integer, 10));
  96         assertEquals(TypeDefinitionAwareCodec.INT16_DEFAULT_CODEC.deserialize(negInteger),
  97                 Short.valueOf(negInteger, 10));
  98     }
  99
 100     @Test
 101     public void int32CodecTest() {
 102         final String hexa = "0x45FFFCDE";
 103         final String negHexa = "-0x45FFFCDE";
 104         final String octal = "010577776336";
 105         final String negOctal = "-010577776336";
 106         final String integer = "1174404318";
 107         final String negInteger = "-1174404318";
 108
 109         assertEquals(TypeDefinitionAwareCodec.INT32_DEFAULT_CODEC.deserialize(hexa), Integer.valueOf("+045FFFCDE", 16));
 110         assertEquals(TypeDefinitionAwareCodec.INT32_DEFAULT_CODEC.deserialize(negHexa),
 111                 Integer.valueOf("-045FFFCDE", 16));
 112         assertEquals(TypeDefinitionAwareCodec.INT32_DEFAULT_CODEC.deserialize(octal), Integer.valueOf(octal, 8));
 113         assertEquals(TypeDefinitionAwareCodec.INT32_DEFAULT_CODEC.deserialize(negOctal), Integer.valueOf(negOctal, 8));
 114         assertEquals(TypeDefinitionAwareCodec.INT32_DEFAULT_CODEC.deserialize(integer), Integer.valueOf(integer, 10));
 115         assertEquals(TypeDefinitionAwareCodec.INT32_DEFAULT_CODEC.deserialize(negInteger),
 116                 Integer.valueOf(negInteger, 10));
 117     }
 118
 119     @Test
 120     public void int64CodecTest() {
 121         final String hexa = "0X75EDC78edCBA";
 122         final String negHexa = "-0X75EDC78edCBA";
 123         final String octal = "+03536670743556272";
 124         final String negOctal = "-03536670743556272";
 125         final String integer = "+129664115727546";
 126         final String negInteger = "-129664115727546";
 127
 128         assertEquals(TypeDefinitionAwareCodec.INT64_DEFAULT_CODEC.deserialize(hexa), Long.valueOf("075EDC78edCBA", 16));
 129         assertEquals(TypeDefinitionAwareCodec.INT64_DEFAULT_CODEC.deserialize(negHexa),
 130                 Long.valueOf("-075EDC78edCBA", 16));
 131         assertEquals(TypeDefinitionAwareCodec.INT64_DEFAULT_CODEC.deserialize(octal), Long.valueOf(octal, 8));
 132         assertEquals(TypeDefinitionAwareCodec.INT64_DEFAULT_CODEC.deserialize(negOctal), Long.valueOf(negOctal, 8));
 133         assertEquals(TypeDefinitionAwareCodec.INT64_DEFAULT_CODEC.deserialize(integer), Long.valueOf(integer, 10));
 134         assertEquals(TypeDefinitionAwareCodec.INT64_DEFAULT_CODEC.deserialize(negInteger), Long.valueOf(negInteger, 10));
 135     }
 136 }