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