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