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

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