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 static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertTrue;
   5 import static org.mockito.Mockito.mock;
   6 import com.google.common.collect.ImmutableList;
   7 import com.google.common.collect.ImmutableSet;
   8 import com.google.protobuf.ByteString;
   9 import java.math.BigDecimal;
  10 import java.math.BigInteger;
  11 import java.util.Arrays;
  12 import java.util.Set;
  13 import org.junit.Rule;
  14 import org.junit.Test;
  15 import org.junit.rules.ExpectedException;
  16 import org.mockito.Mockito;
  17 import org.opendaylight.controller.cluster.datastore.util.TestModel;
  18 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
  19 import org.opendaylight.yangtools.yang.common.QName;
  20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  21
  22 public class ValueSerializerTest{
  23
  24     @Rule
  25     public ExpectedException expectedException = ExpectedException.none();
  26
  27     @Test
  28     public void testSerializeShort(){
  29         short v1 = 5;
  30         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
  31         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
  32
  33         assertEquals(ValueType.SHORT_TYPE.ordinal(), builder.getIntValueType());
  34         assertEquals("5", builder.getValue());
  35
  36         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
  37                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
  38
  39         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
  40
  41         assertEquals(ValueType.SHORT_TYPE.ordinal(), builder1.getType());
  42         assertEquals("5", builder.getValue());
  43
  44     }
  45
  46     @Test
  47     public void testSerializeInteger(){
  48         String hexNumber = "f3";
  49
  50         Integer expected = Integer.valueOf(hexNumber, 16);
  51
  52
  53         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
  54         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), expected);
  55
  56         assertEquals(ValueType.INT_TYPE.ordinal(), builder.getIntValueType());
  57         assertEquals("243", builder.getValue());
  58
  59         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
  60                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
  61
  62         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), expected);
  63
  64         assertEquals(ValueType.INT_TYPE.ordinal(), builder1.getType());
  65         assertEquals("243", builder1.getValue());
  66
  67
  68     }
  69
  70
  71     @Test
  72     public void testSerializeLong(){
  73         long v1 = 5;
  74         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
  75         ValueSerializer.serialize(builder, mock(QNameSerializationContext.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(QNameSerializationContext.class), v1);
  83
  84         assertEquals(ValueType.LONG_TYPE.ordinal(), builder1.getType());
  85         assertEquals("5", builder1.getValue());
  86
  87     }
  88
  89     @Test
  90     public void testSerializeByte(){
  91         byte v1 = 5;
  92         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
  93         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
  94
  95         assertEquals(ValueType.BYTE_TYPE.ordinal(), builder.getIntValueType());
  96         assertEquals("5", builder.getValue());
  97
  98         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
  99
 100         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
 101
 102         assertEquals(ValueType.BYTE_TYPE.ordinal(), builder1.getType());
 103         assertEquals("5", builder1.getValue());
 104
 105     }
 106
 107     @Test
 108     public void testSerializeBits(){
 109         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 110         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),
 111             ImmutableSet.of("foo", "bar"));
 112
 113         assertEquals(ValueType.BITS_TYPE.ordinal(), builder.getIntValueType());
 114         assertTrue( "foo not in bits", builder.getBitsValueList().contains("foo"));
 115         assertTrue( "bar not in bits", builder.getBitsValueList().contains("bar"));
 116
 117         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 118
 119         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),
 120             ImmutableSet.of("foo", "bar"));
 121
 122         assertEquals(ValueType.BITS_TYPE.ordinal(), builder1.getType());
 123         assertTrue( "foo not in bits", builder1.getBitsValueList().contains("foo"));
 124         assertTrue( "bar not in bits", builder1.getBitsValueList().contains("bar"));
 125
 126     }
 127
 128     @Test
 129     public void testSerializeWrongTypeOfSet(){
 130         expectedException.expect(IllegalArgumentException.class);
 131         expectedException.expectMessage("Expected value type to be Bits but was :");
 132         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 133         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),
 134             ImmutableSet.of(1, 2));
 135
 136     }
 137
 138     @Test
 139     public void testSerializeEmptyString(){
 140         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 141         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),"");
 142
 143         assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
 144         assertEquals("", builder.getValue());
 145
 146         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 147
 148         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),"");
 149
 150         assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
 151         assertEquals("", builder1.getValue());
 152
 153     }
 154
 155     @Test
 156     public void testSerializeString(){
 157         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 158         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),"foo");
 159
 160         assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
 161         assertEquals("foo", builder.getValue());
 162
 163         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
 164                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 165
 166         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),"foo");
 167
 168         assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
 169         assertEquals("foo", builder1.getValue());
 170
 171     }
 172
 173
 174     @Test
 175     public void testSerializeBoolean(){
 176         boolean v1 = true;
 177         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 178         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
 179
 180         assertEquals(ValueType.BOOL_TYPE.ordinal(), builder.getIntValueType());
 181         assertEquals("true", builder.getValue());
 182
 183         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
 184                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 185         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
 186
 187         assertEquals(ValueType.BOOL_TYPE.ordinal(), builder1.getType());
 188         assertEquals("true", builder1.getValue());
 189     }
 190
 191     @Test
 192     public void testSerializeQName(){
 193         QName v1 = TestModel.TEST_QNAME;
 194         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 195         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
 196
 197         assertEquals(ValueType.QNAME_TYPE.ordinal(), builder.getIntValueType());
 198         assertEquals("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test", builder.getValue());
 199
 200         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 201
 202         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
 203
 204         assertEquals(ValueType.QNAME_TYPE.ordinal(), builder1.getType());
 205         assertEquals("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test", builder1.getValue());
 206
 207     }
 208
 209     @Test
 210     public void testSerializeYangIdentifier(){
 211         YangInstanceIdentifier v1 = TestModel.TEST_PATH;
 212
 213         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 214         QNameSerializationContext mockContext = mock(QNameSerializationContext.class);
 215         ValueSerializer.serialize(builder, mockContext, v1);
 216
 217         assertEquals(ValueType.YANG_IDENTIFIER_TYPE.ordinal(), builder.getIntValueType());
 218         NormalizedNodeMessages.InstanceIdentifier serializedYangInstanceIdentifier =
 219             builder.getInstanceIdentifierValue();
 220
 221         assertEquals(1, serializedYangInstanceIdentifier.getArgumentsCount());
 222         Mockito.verify(mockContext).addLocalName(TestModel.TEST_QNAME.getLocalName());
 223         Mockito.verify(mockContext).addNamespace(TestModel.TEST_QNAME.getNamespace());
 224
 225         NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
 226                 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 227
 228         mockContext = mock(QNameSerializationContext.class);
 229
 230         ValueSerializer.serialize(argumentBuilder, mockContext, v1);
 231
 232         serializedYangInstanceIdentifier =
 233                 argumentBuilder.getInstanceIdentifierValue();
 234
 235         assertEquals(1, serializedYangInstanceIdentifier.getArgumentsCount());
 236         Mockito.verify(mockContext).addLocalName(TestModel.TEST_QNAME.getLocalName());
 237         Mockito.verify(mockContext).addNamespace(TestModel.TEST_QNAME.getNamespace());
 238
 239     }
 240
 241     @Test
 242     public void testSerializeBigInteger(){
 243         BigInteger v1 = new BigInteger("1000000000000000000000000");
 244         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 245         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
 246
 247         assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder.getIntValueType());
 248         assertEquals("1000000000000000000000000", builder.getValue());
 249
 250         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 251
 252         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
 253
 254         assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder1.getType());
 255         assertEquals("1000000000000000000000000", builder1.getValue());
 256
 257     }
 258
 259     @Test
 260     public void testSerializeBigDecimal(){
 261         BigDecimal v1 = new BigDecimal("1000000000000000000000000.51616");
 262         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 263         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
 264
 265         assertEquals(ValueType.BIG_DECIMAL_TYPE.ordinal(), builder.getIntValueType());
 266         assertEquals("1000000000000000000000000.51616", builder.getValue());
 267
 268         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 269         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.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 testSerializeBinary(){
 278         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 279         byte[] bytes = new byte[] {1,2,3,4};
 280         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),bytes);
 281
 282         assertEquals(ValueType.BINARY_TYPE.ordinal(), builder.getIntValueType());
 283         assertEquals(ByteString.copyFrom(bytes), builder.getBytesValue());
 284
 285         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 286
 287         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),bytes);
 288
 289         assertEquals(ValueType.BINARY_TYPE.ordinal(), builder1.getType());
 290         assertEquals(ByteString.copyFrom(bytes), builder1.getBytesValue());
 291
 292     }
 293
 294     @Test
 295     public void testSerializeNull(){
 296         NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
 297         Object none = null;
 298         ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),none);
 299
 300         assertEquals(ValueType.NULL_TYPE.ordinal(), builder.getIntValueType());
 301         assertEquals("", builder.getValue());
 302
 303         NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 304
 305         ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),none);
 306
 307         assertEquals(ValueType.NULL_TYPE.ordinal(), builder1.getType());
 308         assertEquals("", builder.getValue());
 309
 310     }
 311
 312
 313     @Test
 314     public void testDeSerializeShort(){
 315         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 316         nodeBuilder.setIntValueType(ValueType.SHORT_TYPE.ordinal());
 317         nodeBuilder.setValue("25");
 318
 319         Object o = ValueSerializer
 320             .deSerialize(mock(QNameDeSerializationContext.class),
 321                 nodeBuilder.build());
 322
 323         assertTrue(o instanceof Short);
 324         assertEquals(25, ((Short) o).shortValue());
 325     }
 326
 327     @Test
 328     public void testDeSerializeByte(){
 329         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 330         nodeBuilder.setIntValueType(ValueType.BYTE_TYPE.ordinal());
 331         nodeBuilder.setValue("25");
 332
 333         Object o = ValueSerializer
 334             .deSerialize(mock(QNameDeSerializationContext.class),
 335                 nodeBuilder.build());
 336
 337         assertTrue(o instanceof Byte);
 338         assertEquals(25, ((Byte) o).byteValue());
 339
 340     }
 341
 342     @Test
 343     public void testDeSerializeInteger(){
 344         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 345         nodeBuilder.setIntValueType(ValueType.INT_TYPE.ordinal());
 346         nodeBuilder.setValue("25");
 347
 348         Object o = ValueSerializer
 349             .deSerialize(mock(QNameDeSerializationContext.class),
 350                 nodeBuilder.build());
 351
 352         assertTrue(o instanceof Integer);
 353         assertEquals(25, ((Integer) o).intValue());
 354
 355     }
 356
 357     @Test
 358     public void testDeSerializeLong(){
 359         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 360         nodeBuilder.setIntValueType(ValueType.LONG_TYPE.ordinal());
 361         nodeBuilder.setValue("25");
 362
 363         Object o = ValueSerializer
 364             .deSerialize(mock(QNameDeSerializationContext.class),
 365                 nodeBuilder.build());
 366
 367         assertTrue(o instanceof Long);
 368         assertEquals(25, ((Long) o).longValue());
 369
 370     }
 371
 372     @Test
 373     public void testDeSerializeBoolean(){
 374         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 375         nodeBuilder.setIntValueType(ValueType.BOOL_TYPE.ordinal());
 376         nodeBuilder.setValue("false");
 377
 378         Object o = ValueSerializer
 379             .deSerialize(mock(QNameDeSerializationContext.class),
 380                 nodeBuilder.build());
 381
 382         assertTrue(o instanceof Boolean);
 383         assertEquals(false, ((Boolean) o).booleanValue());
 384
 385     }
 386
 387     @Test
 388     public void testDeSerializeQName(){
 389         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 390         nodeBuilder.setIntValueType(ValueType.QNAME_TYPE.ordinal());
 391         nodeBuilder.setValue(TestModel.TEST_QNAME.toString());
 392
 393         Object o = ValueSerializer
 394             .deSerialize(mock(QNameDeSerializationContext.class),
 395                 nodeBuilder.build());
 396
 397         assertTrue(o instanceof QName);
 398         assertEquals(TestModel.TEST_QNAME, o);
 399
 400     }
 401
 402     @Test
 403     public void testDeSerializeBits(){
 404         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 405         nodeBuilder.setIntValueType(ValueType.BITS_TYPE.ordinal());
 406         nodeBuilder.addAllBitsValue(ImmutableList.of("foo", "bar"));
 407
 408         Object o = ValueSerializer
 409             .deSerialize(mock(QNameDeSerializationContext.class),
 410                 nodeBuilder.build());
 411
 412         assertTrue(o instanceof Set);
 413         assertTrue(((Set<?>)o).contains("foo"));
 414         assertTrue(((Set<?>) o).contains("bar"));
 415
 416         NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
 417                 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 418
 419         argumentBuilder.setType(ValueType.BITS_TYPE.ordinal());
 420         argumentBuilder.addAllBitsValue(ImmutableList.of("foo", "bar"));
 421
 422         o = ValueSerializer
 423                 .deSerialize(mock(QNameDeSerializationContext.class),
 424                         argumentBuilder.build());
 425
 426         assertTrue(o instanceof Set);
 427         assertTrue(((Set<?>)o).contains("foo"));
 428         assertTrue(((Set<?>) o).contains("bar"));
 429
 430     }
 431
 432     @Test
 433     public void testDeSerializeYangIdentifier(){
 434         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 435         NormalizedNodeMessages.InstanceIdentifier.Builder idBuilder = NormalizedNodeMessages.InstanceIdentifier.newBuilder();
 436         NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
 437
 438         pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER.ordinal());
 439
 440         idBuilder.addArguments(pathBuilder);
 441
 442         nodeBuilder.setIntValueType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
 443         nodeBuilder.setInstanceIdentifierValue(idBuilder);
 444
 445         QNameDeSerializationContext mockContext = mock(QNameDeSerializationContext.class);
 446         Mockito.doReturn(TestModel.TEST_QNAME.getNamespace().toString()).when(mockContext).
 447                 getNamespace(Mockito.anyInt());
 448         Mockito.doReturn(TestModel.TEST_QNAME.getLocalName()).when(mockContext).
 449                 getLocalName(Mockito.anyInt());
 450         Mockito.doReturn(TestModel.TEST_QNAME.getFormattedRevision()).when(mockContext).
 451                 getRevision(Mockito.anyInt());
 452
 453         Object o = ValueSerializer.deSerialize(mockContext, nodeBuilder.build());
 454
 455         assertTrue(o instanceof YangInstanceIdentifier);
 456         assertEquals(TestModel.TEST_PATH, o);
 457
 458         NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
 459                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 460
 461         argumentBuilder.setType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
 462         argumentBuilder.setInstanceIdentifierValue(idBuilder);
 463
 464         o = ValueSerializer.deSerialize(mockContext, argumentBuilder.build());
 465
 466         assertTrue(o instanceof YangInstanceIdentifier);
 467         assertEquals(TestModel.TEST_PATH, o);
 468     }
 469
 470     @Test
 471     public void testDeSerializeString(){
 472         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 473         nodeBuilder.setIntValueType(ValueType.STRING_TYPE.ordinal());
 474         nodeBuilder.setValue("25");
 475
 476         Object o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),
 477                 nodeBuilder.build());
 478
 479         assertTrue(o instanceof String);
 480         assertEquals("25", o);
 481
 482     }
 483
 484     @Test
 485     public void testDeSerializeBigInteger(){
 486         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 487         nodeBuilder.setIntValueType(ValueType.BIG_INTEGER_TYPE.ordinal());
 488         nodeBuilder.setValue("25");
 489
 490         Object o = ValueSerializer
 491             .deSerialize(mock(QNameDeSerializationContext.class),
 492                 nodeBuilder.build());
 493
 494         assertTrue(o instanceof BigInteger);
 495         assertEquals(new BigInteger("25"), o);
 496
 497     }
 498
 499     @Test
 500     public void testDeSerializeBigDecimal(){
 501         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 502         nodeBuilder.setIntValueType(ValueType.BIG_DECIMAL_TYPE.ordinal());
 503         nodeBuilder.setValue("25");
 504
 505         Object o = ValueSerializer
 506             .deSerialize(mock(QNameDeSerializationContext.class),
 507                 nodeBuilder.build());
 508
 509         assertTrue(o instanceof BigDecimal);
 510         assertEquals(new BigDecimal("25"), o);
 511
 512     }
 513
 514
 515     @Test
 516     public void testDeSerializeBinaryType(){
 517         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 518         nodeBuilder.setIntValueType(ValueType.BINARY_TYPE.ordinal());
 519         byte[] bytes = new byte[] {1,2,3,4};
 520         nodeBuilder.setBytesValue(ByteString.copyFrom(bytes));
 521
 522         Object o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),nodeBuilder.build());
 523
 524         assertTrue("not a byte array", o instanceof byte[]);
 525         assertTrue("bytes value does not match" , Arrays.equals(bytes, (byte[]) o));
 526
 527         NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
 528                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 529         argumentBuilder.setType(ValueType.BINARY_TYPE.ordinal());
 530         argumentBuilder.setBytesValue(ByteString.copyFrom(bytes));
 531
 532         o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class), argumentBuilder.build());
 533
 534         assertTrue("not a byte array", o instanceof byte[]);
 535         assertTrue("bytes value does not match" ,Arrays.equals(bytes, (byte[]) o));
 536
 537
 538     }
 539
 540     @Test
 541     public void testDeSerializeNullType(){
 542         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 543         nodeBuilder.setIntValueType(ValueType.NULL_TYPE.ordinal());
 544         nodeBuilder.setValue("");
 545
 546         Object o = ValueSerializer
 547                 .deSerialize(mock(QNameDeSerializationContext.class),
 548                         nodeBuilder.build());
 549
 550         assertEquals(null, o);
 551
 552         NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
 553                 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 554
 555         argumentBuilder.setType(ValueType.NULL_TYPE.ordinal());
 556         argumentBuilder.setValue("");
 557
 558         o = ValueSerializer
 559                 .deSerialize(mock(QNameDeSerializationContext.class),
 560                         argumentBuilder.build());
 561
 562         assertEquals(null, o);
 563
 564     }
 565
 566
 567 }