2 * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others. All rights reserved.
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
9 package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
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;
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;
30 public class ValueSerializerTest{
33 public ExpectedException expectedException = ExpectedException.none();
36 public void testSerializeShort(){
38 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
39 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
41 assertEquals(ValueType.SHORT_TYPE.ordinal(), builder.getIntValueType());
42 assertEquals("5", builder.getValue());
44 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
45 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
47 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
49 assertEquals(ValueType.SHORT_TYPE.ordinal(), builder1.getType());
50 assertEquals("5", builder.getValue());
55 public void testSerializeInteger(){
56 String hexNumber = "f3";
58 Integer expected = Integer.valueOf(hexNumber, 16);
61 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
62 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), expected);
64 assertEquals(ValueType.INT_TYPE.ordinal(), builder.getIntValueType());
65 assertEquals("243", builder.getValue());
67 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
68 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
70 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), expected);
72 assertEquals(ValueType.INT_TYPE.ordinal(), builder1.getType());
73 assertEquals("243", builder1.getValue());
80 public void testSerializeLong(){
82 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
83 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
85 assertEquals(ValueType.LONG_TYPE.ordinal(), builder.getIntValueType());
86 assertEquals("5", builder.getValue());
88 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
90 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
92 assertEquals(ValueType.LONG_TYPE.ordinal(), builder1.getType());
93 assertEquals("5", builder1.getValue());
98 public void testSerializeByte(){
100 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
101 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
103 assertEquals(ValueType.BYTE_TYPE.ordinal(), builder.getIntValueType());
104 assertEquals("5", builder.getValue());
106 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
108 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
110 assertEquals(ValueType.BYTE_TYPE.ordinal(), builder1.getType());
111 assertEquals("5", builder1.getValue());
116 public void testSerializeBits(){
117 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
118 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),
119 ImmutableSet.of("foo", "bar"));
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"));
125 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
127 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),
128 ImmutableSet.of("foo", "bar"));
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"));
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));
147 public void testSerializeEmptyString(){
148 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
149 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),"");
151 assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
152 assertEquals("", builder.getValue());
154 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
156 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),"");
158 assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
159 assertEquals("", builder1.getValue());
164 public void testSerializeString(){
165 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
166 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),"foo");
168 assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
169 assertEquals("foo", builder.getValue());
171 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
172 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
174 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),"foo");
176 assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
177 assertEquals("foo", builder1.getValue());
183 public void testSerializeBoolean(){
185 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
186 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
188 assertEquals(ValueType.BOOL_TYPE.ordinal(), builder.getIntValueType());
189 assertEquals("true", builder.getValue());
191 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
192 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
193 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
195 assertEquals(ValueType.BOOL_TYPE.ordinal(), builder1.getType());
196 assertEquals("true", builder1.getValue());
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);
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());
208 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
210 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
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());
218 public void testSerializeYangIdentifier(){
219 YangInstanceIdentifier v1 = TestModel.TEST_PATH;
221 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
222 QNameSerializationContext mockContext = mock(QNameSerializationContext.class);
223 ValueSerializer.serialize(builder, mockContext, v1);
225 assertEquals(ValueType.YANG_IDENTIFIER_TYPE.ordinal(), builder.getIntValueType());
226 NormalizedNodeMessages.InstanceIdentifier serializedYangInstanceIdentifier =
227 builder.getInstanceIdentifierValue();
229 assertEquals(1, serializedYangInstanceIdentifier.getArgumentsCount());
230 Mockito.verify(mockContext).addLocalName(TestModel.TEST_QNAME.getLocalName());
231 Mockito.verify(mockContext).addNamespace(TestModel.TEST_QNAME.getNamespace());
233 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
234 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
236 mockContext = mock(QNameSerializationContext.class);
238 ValueSerializer.serialize(argumentBuilder, mockContext, v1);
240 serializedYangInstanceIdentifier =
241 argumentBuilder.getInstanceIdentifierValue();
243 assertEquals(1, serializedYangInstanceIdentifier.getArgumentsCount());
244 Mockito.verify(mockContext).addLocalName(TestModel.TEST_QNAME.getLocalName());
245 Mockito.verify(mockContext).addNamespace(TestModel.TEST_QNAME.getNamespace());
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);
255 assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder.getIntValueType());
256 assertEquals("1000000000000000000000000", builder.getValue());
258 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
260 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
262 assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder1.getType());
263 assertEquals("1000000000000000000000000", builder1.getValue());
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);
273 assertEquals(ValueType.BIG_DECIMAL_TYPE.ordinal(), builder.getIntValueType());
274 assertEquals("1000000000000000000000000.51616", builder.getValue());
276 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
277 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
279 assertEquals(ValueType.BIG_DECIMAL_TYPE.ordinal(), builder1.getType());
280 assertEquals("1000000000000000000000000.51616", builder1.getValue());
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);
290 assertEquals(ValueType.BINARY_TYPE.ordinal(), builder.getIntValueType());
291 assertEquals(ByteString.copyFrom(bytes), builder.getBytesValue());
293 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
295 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),bytes);
297 assertEquals(ValueType.BINARY_TYPE.ordinal(), builder1.getType());
298 assertEquals(ByteString.copyFrom(bytes), builder1.getBytesValue());
303 public void testSerializeNull(){
304 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
306 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),none);
308 assertEquals(ValueType.NULL_TYPE.ordinal(), builder.getIntValueType());
309 assertEquals("", builder.getValue());
311 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
313 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),none);
315 assertEquals(ValueType.NULL_TYPE.ordinal(), builder1.getType());
316 assertEquals("", builder.getValue());
322 public void testDeSerializeShort(){
323 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
324 nodeBuilder.setIntValueType(ValueType.SHORT_TYPE.ordinal());
325 nodeBuilder.setValue("25");
327 Object o = ValueSerializer
328 .deSerialize(mock(QNameDeSerializationContext.class),
329 nodeBuilder.build());
331 assertTrue(o instanceof Short);
332 assertEquals(25, ((Short) o).shortValue());
336 public void testDeSerializeByte(){
337 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
338 nodeBuilder.setIntValueType(ValueType.BYTE_TYPE.ordinal());
339 nodeBuilder.setValue("25");
341 Object o = ValueSerializer
342 .deSerialize(mock(QNameDeSerializationContext.class),
343 nodeBuilder.build());
345 assertTrue(o instanceof Byte);
346 assertEquals(25, ((Byte) o).byteValue());
351 public void testDeSerializeInteger(){
352 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
353 nodeBuilder.setIntValueType(ValueType.INT_TYPE.ordinal());
354 nodeBuilder.setValue("25");
356 Object o = ValueSerializer
357 .deSerialize(mock(QNameDeSerializationContext.class),
358 nodeBuilder.build());
360 assertTrue(o instanceof Integer);
361 assertEquals(25, ((Integer) o).intValue());
366 public void testDeSerializeLong(){
367 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
368 nodeBuilder.setIntValueType(ValueType.LONG_TYPE.ordinal());
369 nodeBuilder.setValue("25");
371 Object o = ValueSerializer
372 .deSerialize(mock(QNameDeSerializationContext.class),
373 nodeBuilder.build());
375 assertTrue(o instanceof Long);
376 assertEquals(25, ((Long) o).longValue());
381 public void testDeSerializeBoolean(){
382 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
383 nodeBuilder.setIntValueType(ValueType.BOOL_TYPE.ordinal());
384 nodeBuilder.setValue("false");
386 Object o = ValueSerializer
387 .deSerialize(mock(QNameDeSerializationContext.class),
388 nodeBuilder.build());
390 assertTrue(o instanceof Boolean);
391 assertEquals(false, ((Boolean) o).booleanValue());
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());
401 Object o = ValueSerializer
402 .deSerialize(mock(QNameDeSerializationContext.class),
403 nodeBuilder.build());
405 assertTrue(o instanceof QName);
406 assertEquals(TestModel.TEST_QNAME, o);
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"));
416 Object o = ValueSerializer
417 .deSerialize(mock(QNameDeSerializationContext.class),
418 nodeBuilder.build());
420 assertTrue(o instanceof Set);
421 assertTrue(((Set<?>)o).contains("foo"));
422 assertTrue(((Set<?>) o).contains("bar"));
424 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
425 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
427 argumentBuilder.setType(ValueType.BITS_TYPE.ordinal());
428 argumentBuilder.addAllBitsValue(ImmutableList.of("foo", "bar"));
431 .deSerialize(mock(QNameDeSerializationContext.class),
432 argumentBuilder.build());
434 assertTrue(o instanceof Set);
435 assertTrue(((Set<?>)o).contains("foo"));
436 assertTrue(((Set<?>) o).contains("bar"));
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();
446 pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER.ordinal());
448 idBuilder.addArguments(pathBuilder);
450 nodeBuilder.setIntValueType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
451 nodeBuilder.setInstanceIdentifierValue(idBuilder);
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());
461 Object o = ValueSerializer.deSerialize(mockContext, nodeBuilder.build());
463 assertTrue(o instanceof YangInstanceIdentifier);
464 assertEquals(TestModel.TEST_PATH, o);
466 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
467 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
469 argumentBuilder.setType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
470 argumentBuilder.setInstanceIdentifierValue(idBuilder);
472 o = ValueSerializer.deSerialize(mockContext, argumentBuilder.build());
474 assertTrue(o instanceof YangInstanceIdentifier);
475 assertEquals(TestModel.TEST_PATH, o);
479 public void testDeSerializeString(){
480 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
481 nodeBuilder.setIntValueType(ValueType.STRING_TYPE.ordinal());
482 nodeBuilder.setValue("25");
484 Object o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),
485 nodeBuilder.build());
487 assertTrue(o instanceof String);
488 assertEquals("25", o);
493 public void testDeSerializeBigInteger(){
494 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
495 nodeBuilder.setIntValueType(ValueType.BIG_INTEGER_TYPE.ordinal());
496 nodeBuilder.setValue("25");
498 Object o = ValueSerializer
499 .deSerialize(mock(QNameDeSerializationContext.class),
500 nodeBuilder.build());
502 assertTrue(o instanceof BigInteger);
503 assertEquals(new BigInteger("25"), o);
508 public void testDeSerializeBigDecimal(){
509 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
510 nodeBuilder.setIntValueType(ValueType.BIG_DECIMAL_TYPE.ordinal());
511 nodeBuilder.setValue("25");
513 Object o = ValueSerializer
514 .deSerialize(mock(QNameDeSerializationContext.class),
515 nodeBuilder.build());
517 assertTrue(o instanceof BigDecimal);
518 assertEquals(new BigDecimal("25"), o);
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));
530 Object o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),nodeBuilder.build());
532 assertTrue("not a byte array", o instanceof byte[]);
533 assertTrue("bytes value does not match" , Arrays.equals(bytes, (byte[]) o));
535 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
536 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
537 argumentBuilder.setType(ValueType.BINARY_TYPE.ordinal());
538 argumentBuilder.setBytesValue(ByteString.copyFrom(bytes));
540 o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class), argumentBuilder.build());
542 assertTrue("not a byte array", o instanceof byte[]);
543 assertTrue("bytes value does not match" ,Arrays.equals(bytes, (byte[]) o));
549 public void testDeSerializeNullType(){
550 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
551 nodeBuilder.setIntValueType(ValueType.NULL_TYPE.ordinal());
552 nodeBuilder.setValue("");
554 Object o = ValueSerializer
555 .deSerialize(mock(QNameDeSerializationContext.class),
556 nodeBuilder.build());
558 assertEquals(null, o);
560 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
561 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
563 argumentBuilder.setType(ValueType.NULL_TYPE.ordinal());
564 argumentBuilder.setValue("");
567 .deSerialize(mock(QNameDeSerializationContext.class),
568 argumentBuilder.build());
570 assertEquals(null, o);