opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/ValueSerializerTest.java

   1 package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
   2
   3 import com.google.common.collect.ImmutableList;
   4 import com.google.common.collect.ImmutableSet;
   5 import org.junit.Rule;
   6 import org.junit.Test;
   7 import org.junit.rules.ExpectedException;
   8 import org.mockito.Mockito;
   9 import org.opendaylight.controller.cluster.datastore.util.TestModel;
  10 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
  11 import org.opendaylight.yangtools.yang.common.QName;
  12 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  13 import java.math.BigDecimal;
  14 import java.math.BigInteger;
  15 import java.util.Set;
  16 import static org.junit.Assert.assertEquals;
  17 import static org.junit.Assert.assertTrue;
  18 import static org.mockito.Mockito.mock;
  19
  20 public class ValueSerializerTest{
  21
  22     @Rule
  23     public ExpectedException expectedException = ExpectedException.none();
  24
  25     @Test
  26     public void testSerializeShort(){
  27         short v1 = 5;
  28         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
  29         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
  30
  31         assertEquals(ValueType.SHORT_TYPE.ordinal(), builder.getIntValueType());
  32         assertEquals("5", builder.getValue());
  33
  34         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
  35                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
  36
  37         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
  38
  39         assertEquals(ValueType.SHORT_TYPE.ordinal(), builder1.getType());
  40         assertEquals("5", builder.getValue());
  41
  42     }
  43
  44     @Test
  45     public void testSerializeInteger(){
  46         String hexNumber = "f3";
  47
  48         Integer expected = Integer.valueOf(hexNumber, 16);
  49
  50
  51         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
  52         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), expected);
  53
  54         assertEquals(ValueType.INT_TYPE.ordinal(), builder.getIntValueType());
  55         assertEquals("243", builder.getValue());
  56
  57         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
  58                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
  59
  60         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), expected);
  61
  62         assertEquals(ValueType.INT_TYPE.ordinal(), builder1.getType());
  63         assertEquals("243", builder1.getValue());
  64
  65
  66     }
  67
  68
  69     @Test
  70     public void testSerializeLong(){
  71         long v1 = 5;
  72         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
  73         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
  74
  75         assertEquals(ValueType.LONG_TYPE.ordinal(), builder.getIntValueType());
  76         assertEquals("5", builder.getValue());
  77
  78         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
  79
  80         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
  81
  82         assertEquals(ValueType.LONG_TYPE.ordinal(), builder1.getType());
  83         assertEquals("5", builder1.getValue());
  84
  85     }
  86
  87     @Test
  88     public void testSerializeByte(){
  89         byte v1 = 5;
  90         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
  91         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
  92
  93         assertEquals(ValueType.BYTE_TYPE.ordinal(), builder.getIntValueType());
  94         assertEquals("5", builder.getValue());
  95
  96         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
  97
  98         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
  99
 100         assertEquals(ValueType.BYTE_TYPE.ordinal(), builder1.getType());
 101         assertEquals("5", builder1.getValue());
 102
 103     }
 104
 105     @Test
 106     public void testSerializeBits(){
 107         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 108         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),
 109             ImmutableSet.of("foo", "bar"));
 110
 111         assertEquals(ValueType.BITS_TYPE.ordinal(), builder.getIntValueType());
 112         assertTrue( "foo not in bits", builder.getBitsValueList().contains("foo"));
 113         assertTrue( "bar not in bits", builder.getBitsValueList().contains("bar"));
 114
 115         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 116
 117         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),
 118             ImmutableSet.of("foo", "bar"));
 119
 120         assertEquals(ValueType.BITS_TYPE.ordinal(), builder1.getType());
 121         assertEquals("[foo, bar]", builder1.getValue());
 122
 123     }
 124
 125     @Test
 126     public void testSerializeWrongTypeOfSet(){
 127         expectedException.expect(IllegalArgumentException.class);
 128         expectedException.expectMessage("Expected value type to be Bits but was :");
 129         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 130         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),
 131             ImmutableSet.of(1, 2));
 132
 133     }
 134
 135     @Test
 136     public void testSerializeEmptyString(){
 137         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 138         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),"");
 139
 140         assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
 141         assertEquals("", builder.getValue());
 142
 143         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 144
 145         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),"");
 146
 147         assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
 148         assertEquals("", builder1.getValue());
 149
 150     }
 151
 152     @Test
 153     public void testSerializeString(){
 154         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 155         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),"foo");
 156
 157         assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
 158         assertEquals("foo", builder.getValue());
 159
 160         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
 161                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 162
 163         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),"foo");
 164
 165         assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
 166         assertEquals("foo", builder1.getValue());
 167
 168     }
 169
 170
 171     @Test
 172     public void testSerializeBoolean(){
 173         boolean v1 = true;
 174         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 175         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
 176
 177         assertEquals(ValueType.BOOL_TYPE.ordinal(), builder.getIntValueType());
 178         assertEquals("true", builder.getValue());
 179
 180         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
 181                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 182         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
 183
 184         assertEquals(ValueType.BOOL_TYPE.ordinal(), builder1.getType());
 185         assertEquals("true", builder1.getValue());
 186     }
 187
 188     @Test
 189     public void testSerializeQName(){
 190         QName v1 = TestModel.TEST_QNAME;
 191         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 192         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
 193
 194         assertEquals(ValueType.QNAME_TYPE.ordinal(), builder.getIntValueType());
 195         assertEquals("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test", builder.getValue());
 196
 197         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 198
 199         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
 200
 201         assertEquals(ValueType.QNAME_TYPE.ordinal(), builder1.getType());
 202         assertEquals("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test", builder1.getValue());
 203
 204     }
 205
 206     @Test
 207     public void testSerializeYangIdentifier(){
 208         YangInstanceIdentifier v1 = TestModel.TEST_PATH;
 209
 210         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 211         QNameSerializationContext mockContext = mock(QNameSerializationContext.class);
 212         ValueSerializer.serialize(builder, mockContext, v1);
 213
 214         assertEquals(ValueType.YANG_IDENTIFIER_TYPE.ordinal(), builder.getIntValueType());
 215         NormalizedNodeMessages.InstanceIdentifier serializedYangInstanceIdentifier =
 216             builder.getInstanceIdentifierValue();
 217
 218         assertEquals(1, serializedYangInstanceIdentifier.getArgumentsCount());
 219         Mockito.verify(mockContext).addLocalName(TestModel.TEST_QNAME.getLocalName());
 220         Mockito.verify(mockContext).addNamespace(TestModel.TEST_QNAME.getNamespace());
 221     }
 222
 223     @Test
 224     public void testSerializeBigInteger(){
 225         BigInteger v1 = new BigInteger("1000000000000000000000000");
 226         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 227         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
 228
 229         assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder.getIntValueType());
 230         assertEquals("1000000000000000000000000", builder.getValue());
 231
 232         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 233
 234         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
 235
 236         assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder1.getType());
 237         assertEquals("1000000000000000000000000", builder1.getValue());
 238
 239     }
 240
 241     @Test
 242     public void testSerializeBigDecimal(){
 243         BigDecimal v1 = new BigDecimal("1000000000000000000000000.51616");
 244         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 245         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
 246
 247         assertEquals(ValueType.BIG_DECIMAL_TYPE.ordinal(), builder.getIntValueType());
 248         assertEquals("1000000000000000000000000.51616", builder.getValue());
 249
 250         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 251         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
 252
 253         assertEquals(ValueType.BIG_DECIMAL_TYPE.ordinal(), builder1.getType());
 254         assertEquals("1000000000000000000000000.51616", builder1.getValue());
 255
 256     }
 257
 258     @Test
 259     public void testDeSerializeShort(){
 260         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 261         nodeBuilder.setIntValueType(ValueType.SHORT_TYPE.ordinal());
 262         nodeBuilder.setValue("25");
 263
 264         Object o = ValueSerializer
 265             .deSerialize(mock(QNameDeSerializationContext.class),
 266                 nodeBuilder.build());
 267
 268         assertTrue(o instanceof Short);
 269         assertEquals(25, ((Short) o).shortValue());
 270     }
 271
 272     @Test
 273     public void testDeSerializeByte(){
 274         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 275         nodeBuilder.setIntValueType(ValueType.BYTE_TYPE.ordinal());
 276         nodeBuilder.setValue("25");
 277
 278         Object o = ValueSerializer
 279             .deSerialize(mock(QNameDeSerializationContext.class),
 280                 nodeBuilder.build());
 281
 282         assertTrue(o instanceof Byte);
 283         assertEquals(25, ((Byte) o).byteValue());
 284
 285     }
 286
 287     @Test
 288     public void testDeSerializeInteger(){
 289         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 290         nodeBuilder.setIntValueType(ValueType.INT_TYPE.ordinal());
 291         nodeBuilder.setValue("25");
 292
 293         Object o = ValueSerializer
 294             .deSerialize(mock(QNameDeSerializationContext.class),
 295                 nodeBuilder.build());
 296
 297         assertTrue(o instanceof Integer);
 298         assertEquals(25, ((Integer) o).intValue());
 299
 300     }
 301
 302     @Test
 303     public void testDeSerializeLong(){
 304         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 305         nodeBuilder.setIntValueType(ValueType.LONG_TYPE.ordinal());
 306         nodeBuilder.setValue("25");
 307
 308         Object o = ValueSerializer
 309             .deSerialize(mock(QNameDeSerializationContext.class),
 310                 nodeBuilder.build());
 311
 312         assertTrue(o instanceof Long);
 313         assertEquals(25, ((Long) o).longValue());
 314
 315     }
 316
 317     @Test
 318     public void testDeSerializeBoolean(){
 319         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 320         nodeBuilder.setIntValueType(ValueType.BOOL_TYPE.ordinal());
 321         nodeBuilder.setValue("false");
 322
 323         Object o = ValueSerializer
 324             .deSerialize(mock(QNameDeSerializationContext.class),
 325                 nodeBuilder.build());
 326
 327         assertTrue(o instanceof Boolean);
 328         assertEquals(false, ((Boolean) o).booleanValue());
 329
 330     }
 331
 332     @Test
 333     public void testDeSerializeQName(){
 334         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 335         nodeBuilder.setIntValueType(ValueType.QNAME_TYPE.ordinal());
 336         nodeBuilder.setValue(TestModel.TEST_QNAME.toString());
 337
 338         Object o = ValueSerializer
 339             .deSerialize(mock(QNameDeSerializationContext.class),
 340                 nodeBuilder.build());
 341
 342         assertTrue(o instanceof QName);
 343         assertEquals(TestModel.TEST_QNAME, o);
 344
 345     }
 346
 347     @Test
 348     public void testDeSerializeBits(){
 349         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 350         nodeBuilder.setIntValueType(ValueType.BITS_TYPE.ordinal());
 351         nodeBuilder.addAllBitsValue(ImmutableList.of("foo", "bar"));
 352
 353         Object o = ValueSerializer
 354             .deSerialize(mock(QNameDeSerializationContext.class),
 355                 nodeBuilder.build());
 356
 357         assertTrue(o instanceof Set);
 358         assertTrue(((Set)o).contains("foo"));
 359         assertTrue(((Set) o).contains("bar"));
 360
 361     }
 362
 363     @Test
 364     public void testDeSerializeYangIdentifier(){
 365         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 366         NormalizedNodeMessages.InstanceIdentifier.Builder idBuilder = NormalizedNodeMessages.InstanceIdentifier.newBuilder();
 367         NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
 368
 369         pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER.ordinal());
 370
 371         idBuilder.addArguments(pathBuilder);
 372
 373         nodeBuilder.setIntValueType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
 374         nodeBuilder.setInstanceIdentifierValue(idBuilder);
 375
 376         QNameDeSerializationContext mockContext = mock(QNameDeSerializationContext.class);
 377         Mockito.doReturn(TestModel.TEST_QNAME.getNamespace().toString()).when(mockContext).
 378                 getNamespace(Mockito.anyInt());
 379         Mockito.doReturn(TestModel.TEST_QNAME.getLocalName()).when(mockContext).
 380                 getLocalName(Mockito.anyInt());
 381         Mockito.doReturn(TestModel.TEST_QNAME.getFormattedRevision()).when(mockContext).
 382                 getRevision(Mockito.anyInt());
 383
 384         Object o = ValueSerializer.deSerialize(mockContext, nodeBuilder.build());
 385
 386         assertTrue(o instanceof YangInstanceIdentifier);
 387         assertEquals(TestModel.TEST_PATH, o);
 388
 389     }
 390
 391     @Test
 392     public void testDeSerializeString(){
 393         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 394         nodeBuilder.setIntValueType(ValueType.STRING_TYPE.ordinal());
 395         nodeBuilder.setValue("25");
 396
 397         Object o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),
 398                 nodeBuilder.build());
 399
 400         assertTrue(o instanceof String);
 401         assertEquals("25", o);
 402
 403     }
 404
 405     @Test
 406     public void testDeSerializeBigInteger(){
 407         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 408         nodeBuilder.setIntValueType(ValueType.BIG_INTEGER_TYPE.ordinal());
 409         nodeBuilder.setValue("25");
 410
 411         Object o = ValueSerializer
 412             .deSerialize(mock(QNameDeSerializationContext.class),
 413                 nodeBuilder.build());
 414
 415         assertTrue(o instanceof BigInteger);
 416         assertEquals(new BigInteger("25"), o);
 417
 418     }
 419
 420     @Test
 421     public void testDeSerializeBigDecimal(){
 422         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 423         nodeBuilder.setIntValueType(ValueType.BIG_DECIMAL_TYPE.ordinal());
 424         nodeBuilder.setValue("25");
 425
 426         Object o = ValueSerializer
 427             .deSerialize(mock(QNameDeSerializationContext.class),
 428                 nodeBuilder.build());
 429
 430         assertTrue(o instanceof BigDecimal);
 431         assertEquals(new BigDecimal("25"), o);
 432
 433     }
 434
 435 }