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
 295     @Test
 296     public void testDeSerializeShort(){
 297         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 298         nodeBuilder.setIntValueType(ValueType.SHORT_TYPE.ordinal());
 299         nodeBuilder.setValue("25");
 300
 301         Object o = ValueSerializer
 302             .deSerialize(mock(QNameDeSerializationContext.class),
 303                 nodeBuilder.build());
 304
 305         assertTrue(o instanceof Short);
 306         assertEquals(25, ((Short) o).shortValue());
 307     }
 308
 309     @Test
 310     public void testDeSerializeByte(){
 311         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 312         nodeBuilder.setIntValueType(ValueType.BYTE_TYPE.ordinal());
 313         nodeBuilder.setValue("25");
 314
 315         Object o = ValueSerializer
 316             .deSerialize(mock(QNameDeSerializationContext.class),
 317                 nodeBuilder.build());
 318
 319         assertTrue(o instanceof Byte);
 320         assertEquals(25, ((Byte) o).byteValue());
 321
 322     }
 323
 324     @Test
 325     public void testDeSerializeInteger(){
 326         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 327         nodeBuilder.setIntValueType(ValueType.INT_TYPE.ordinal());
 328         nodeBuilder.setValue("25");
 329
 330         Object o = ValueSerializer
 331             .deSerialize(mock(QNameDeSerializationContext.class),
 332                 nodeBuilder.build());
 333
 334         assertTrue(o instanceof Integer);
 335         assertEquals(25, ((Integer) o).intValue());
 336
 337     }
 338
 339     @Test
 340     public void testDeSerializeLong(){
 341         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 342         nodeBuilder.setIntValueType(ValueType.LONG_TYPE.ordinal());
 343         nodeBuilder.setValue("25");
 344
 345         Object o = ValueSerializer
 346             .deSerialize(mock(QNameDeSerializationContext.class),
 347                 nodeBuilder.build());
 348
 349         assertTrue(o instanceof Long);
 350         assertEquals(25, ((Long) o).longValue());
 351
 352     }
 353
 354     @Test
 355     public void testDeSerializeBoolean(){
 356         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 357         nodeBuilder.setIntValueType(ValueType.BOOL_TYPE.ordinal());
 358         nodeBuilder.setValue("false");
 359
 360         Object o = ValueSerializer
 361             .deSerialize(mock(QNameDeSerializationContext.class),
 362                 nodeBuilder.build());
 363
 364         assertTrue(o instanceof Boolean);
 365         assertEquals(false, ((Boolean) o).booleanValue());
 366
 367     }
 368
 369     @Test
 370     public void testDeSerializeQName(){
 371         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 372         nodeBuilder.setIntValueType(ValueType.QNAME_TYPE.ordinal());
 373         nodeBuilder.setValue(TestModel.TEST_QNAME.toString());
 374
 375         Object o = ValueSerializer
 376             .deSerialize(mock(QNameDeSerializationContext.class),
 377                 nodeBuilder.build());
 378
 379         assertTrue(o instanceof QName);
 380         assertEquals(TestModel.TEST_QNAME, o);
 381
 382     }
 383
 384     @Test
 385     public void testDeSerializeBits(){
 386         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 387         nodeBuilder.setIntValueType(ValueType.BITS_TYPE.ordinal());
 388         nodeBuilder.addAllBitsValue(ImmutableList.of("foo", "bar"));
 389
 390         Object o = ValueSerializer
 391             .deSerialize(mock(QNameDeSerializationContext.class),
 392                 nodeBuilder.build());
 393
 394         assertTrue(o instanceof Set);
 395         assertTrue(((Set<?>)o).contains("foo"));
 396         assertTrue(((Set<?>) o).contains("bar"));
 397
 398         NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
 399                 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 400
 401         argumentBuilder.setType(ValueType.BITS_TYPE.ordinal());
 402         argumentBuilder.addAllBitsValue(ImmutableList.of("foo", "bar"));
 403
 404         o = ValueSerializer
 405                 .deSerialize(mock(QNameDeSerializationContext.class),
 406                         argumentBuilder.build());
 407
 408         assertTrue(o instanceof Set);
 409         assertTrue(((Set<?>)o).contains("foo"));
 410         assertTrue(((Set<?>) o).contains("bar"));
 411
 412     }
 413
 414     @Test
 415     public void testDeSerializeYangIdentifier(){
 416         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 417         NormalizedNodeMessages.InstanceIdentifier.Builder idBuilder = NormalizedNodeMessages.InstanceIdentifier.newBuilder();
 418         NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
 419
 420         pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER.ordinal());
 421
 422         idBuilder.addArguments(pathBuilder);
 423
 424         nodeBuilder.setIntValueType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
 425         nodeBuilder.setInstanceIdentifierValue(idBuilder);
 426
 427         QNameDeSerializationContext mockContext = mock(QNameDeSerializationContext.class);
 428         Mockito.doReturn(TestModel.TEST_QNAME.getNamespace().toString()).when(mockContext).
 429                 getNamespace(Mockito.anyInt());
 430         Mockito.doReturn(TestModel.TEST_QNAME.getLocalName()).when(mockContext).
 431                 getLocalName(Mockito.anyInt());
 432         Mockito.doReturn(TestModel.TEST_QNAME.getFormattedRevision()).when(mockContext).
 433                 getRevision(Mockito.anyInt());
 434
 435         Object o = ValueSerializer.deSerialize(mockContext, nodeBuilder.build());
 436
 437         assertTrue(o instanceof YangInstanceIdentifier);
 438         assertEquals(TestModel.TEST_PATH, o);
 439
 440         NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
 441                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 442
 443         argumentBuilder.setType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
 444         argumentBuilder.setInstanceIdentifierValue(idBuilder);
 445
 446         o = ValueSerializer.deSerialize(mockContext, argumentBuilder.build());
 447
 448         assertTrue(o instanceof YangInstanceIdentifier);
 449         assertEquals(TestModel.TEST_PATH, o);
 450     }
 451
 452     @Test
 453     public void testDeSerializeString(){
 454         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 455         nodeBuilder.setIntValueType(ValueType.STRING_TYPE.ordinal());
 456         nodeBuilder.setValue("25");
 457
 458         Object o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),
 459                 nodeBuilder.build());
 460
 461         assertTrue(o instanceof String);
 462         assertEquals("25", o);
 463
 464     }
 465
 466     @Test
 467     public void testDeSerializeBigInteger(){
 468         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 469         nodeBuilder.setIntValueType(ValueType.BIG_INTEGER_TYPE.ordinal());
 470         nodeBuilder.setValue("25");
 471
 472         Object o = ValueSerializer
 473             .deSerialize(mock(QNameDeSerializationContext.class),
 474                 nodeBuilder.build());
 475
 476         assertTrue(o instanceof BigInteger);
 477         assertEquals(new BigInteger("25"), o);
 478
 479     }
 480
 481     @Test
 482     public void testDeSerializeBigDecimal(){
 483         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 484         nodeBuilder.setIntValueType(ValueType.BIG_DECIMAL_TYPE.ordinal());
 485         nodeBuilder.setValue("25");
 486
 487         Object o = ValueSerializer
 488             .deSerialize(mock(QNameDeSerializationContext.class),
 489                 nodeBuilder.build());
 490
 491         assertTrue(o instanceof BigDecimal);
 492         assertEquals(new BigDecimal("25"), o);
 493
 494     }
 495
 496
 497     @Test
 498     public void testDeSerializeBinaryType(){
 499         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 500         nodeBuilder.setIntValueType(ValueType.BINARY_TYPE.ordinal());
 501         byte[] bytes = new byte[] {1,2,3,4};
 502         nodeBuilder.setBytesValue(ByteString.copyFrom(bytes));
 503
 504         Object o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),nodeBuilder.build());
 505
 506         assertTrue("not a byte array", o instanceof byte[]);
 507         assertTrue("bytes value does not match" , Arrays.equals(bytes, (byte[]) o));
 508
 509         NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
 510                 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
 511         argumentBuilder.setType(ValueType.BINARY_TYPE.ordinal());
 512         argumentBuilder.setBytesValue(ByteString.copyFrom(bytes));
 513
 514         o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class), argumentBuilder.build());
 515
 516         assertTrue("not a byte array", o instanceof byte[]);
 517         assertTrue("bytes value does not match" ,Arrays.equals(bytes, (byte[]) o));
 518
 519
 520     }
 521
 522
 523 }