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;
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;
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;
31 public class ValueSerializerTest {
34 public ExpectedException expectedException = ExpectedException.none();
37 public void testSerializeShort() {
39 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
40 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
42 assertEquals(ValueType.SHORT_TYPE.ordinal(), builder.getIntValueType());
43 assertEquals("5", builder.getValue());
45 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
46 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
48 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
50 assertEquals(ValueType.SHORT_TYPE.ordinal(), builder1.getType());
51 assertEquals("5", builder.getValue());
56 public void testSerializeInteger() {
57 String hexNumber = "f3";
59 Integer expected = Integer.valueOf(hexNumber, 16);
62 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
63 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), expected);
65 assertEquals(ValueType.INT_TYPE.ordinal(), builder.getIntValueType());
66 assertEquals("243", builder.getValue());
68 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
69 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
71 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), expected);
73 assertEquals(ValueType.INT_TYPE.ordinal(), builder1.getType());
74 assertEquals("243", builder1.getValue());
81 public void testSerializeLong() {
83 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
84 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
86 assertEquals(ValueType.LONG_TYPE.ordinal(), builder.getIntValueType());
87 assertEquals("5", builder.getValue());
89 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
90 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
92 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
94 assertEquals(ValueType.LONG_TYPE.ordinal(), builder1.getType());
95 assertEquals("5", builder1.getValue());
100 public void testSerializeByte() {
102 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
103 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
105 assertEquals(ValueType.BYTE_TYPE.ordinal(), builder.getIntValueType());
106 assertEquals("5", builder.getValue());
108 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
109 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
111 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
113 assertEquals(ValueType.BYTE_TYPE.ordinal(), builder1.getType());
114 assertEquals("5", builder1.getValue());
119 public void testSerializeBits() {
120 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
121 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),
122 ImmutableSet.of("foo", "bar"));
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"));
128 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
129 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
131 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),
132 ImmutableSet.of("foo", "bar"));
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"));
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));
151 public void testSerializeEmptyString() {
152 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
153 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),"");
155 assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
156 assertEquals("", builder.getValue());
158 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
159 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
161 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),"");
163 assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
164 assertEquals("", builder1.getValue());
169 public void testSerializeString() {
170 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
171 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),"foo");
173 assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
174 assertEquals("foo", builder.getValue());
176 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
177 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
179 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),"foo");
181 assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
182 assertEquals("foo", builder1.getValue());
188 public void testSerializeBoolean() {
190 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
191 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
193 assertEquals(ValueType.BOOL_TYPE.ordinal(), builder.getIntValueType());
194 assertEquals("true", builder.getValue());
196 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
197 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
198 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
200 assertEquals(ValueType.BOOL_TYPE.ordinal(), builder1.getType());
201 assertEquals("true", builder1.getValue());
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);
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",
214 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
215 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
217 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
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());
226 public void testSerializeYangIdentifier() {
227 YangInstanceIdentifier v1 = TestModel.TEST_PATH;
229 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
230 QNameSerializationContext mockContext = mock(QNameSerializationContext.class);
231 ValueSerializer.serialize(builder, mockContext, v1);
233 assertEquals(ValueType.YANG_IDENTIFIER_TYPE.ordinal(), builder.getIntValueType());
234 NormalizedNodeMessages.InstanceIdentifier serializedYangInstanceIdentifier =
235 builder.getInstanceIdentifierValue();
237 assertEquals(1, serializedYangInstanceIdentifier.getArgumentsCount());
238 Mockito.verify(mockContext).addLocalName(TestModel.TEST_QNAME.getLocalName());
239 Mockito.verify(mockContext).addNamespace(TestModel.TEST_QNAME.getNamespace());
241 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
242 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
244 mockContext = mock(QNameSerializationContext.class);
246 ValueSerializer.serialize(argumentBuilder, mockContext, v1);
248 serializedYangInstanceIdentifier =
249 argumentBuilder.getInstanceIdentifierValue();
251 assertEquals(1, serializedYangInstanceIdentifier.getArgumentsCount());
252 Mockito.verify(mockContext).addLocalName(TestModel.TEST_QNAME.getLocalName());
253 Mockito.verify(mockContext).addNamespace(TestModel.TEST_QNAME.getNamespace());
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);
263 assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder.getIntValueType());
264 assertEquals("1000000000000000000000000", builder.getValue());
266 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
267 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
269 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
271 assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder1.getType());
272 assertEquals("1000000000000000000000000", builder1.getValue());
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);
282 assertEquals(ValueType.BIG_DECIMAL_TYPE.ordinal(), builder.getIntValueType());
283 assertEquals("1000000000000000000000000.51616", builder.getValue());
285 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
286 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
287 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
289 assertEquals(ValueType.BIG_DECIMAL_TYPE.ordinal(), builder1.getType());
290 assertEquals("1000000000000000000000000.51616", builder1.getValue());
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);
300 assertEquals(ValueType.BINARY_TYPE.ordinal(), builder.getIntValueType());
301 assertEquals(ByteString.copyFrom(bytes), builder.getBytesValue());
303 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
304 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
306 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),bytes);
308 assertEquals(ValueType.BINARY_TYPE.ordinal(), builder1.getType());
309 assertEquals(ByteString.copyFrom(bytes), builder1.getBytesValue());
314 public void testSerializeNull() {
315 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
317 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),none);
319 assertEquals(ValueType.NULL_TYPE.ordinal(), builder.getIntValueType());
320 assertEquals("", builder.getValue());
322 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
323 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
325 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),none);
327 assertEquals(ValueType.NULL_TYPE.ordinal(), builder1.getType());
328 assertEquals("", builder.getValue());
334 public void testDeSerializeShort() {
335 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
336 nodeBuilder.setIntValueType(ValueType.SHORT_TYPE.ordinal());
337 nodeBuilder.setValue("25");
339 Object value = ValueSerializer
340 .deSerialize(mock(QNameDeSerializationContext.class),
341 nodeBuilder.build());
343 assertTrue(value instanceof Short);
344 assertEquals(25, ((Short) value).shortValue());
348 public void testDeSerializeByte() {
349 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
350 nodeBuilder.setIntValueType(ValueType.BYTE_TYPE.ordinal());
351 nodeBuilder.setValue("25");
353 Object value = ValueSerializer
354 .deSerialize(mock(QNameDeSerializationContext.class),
355 nodeBuilder.build());
357 assertTrue(value instanceof Byte);
358 assertEquals(25, ((Byte) value).byteValue());
363 public void testDeSerializeInteger() {
364 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
365 nodeBuilder.setIntValueType(ValueType.INT_TYPE.ordinal());
366 nodeBuilder.setValue("25");
368 Object value = ValueSerializer
369 .deSerialize(mock(QNameDeSerializationContext.class),
370 nodeBuilder.build());
372 assertTrue(value instanceof Integer);
373 assertEquals(25, ((Integer) value).intValue());
378 public void testDeSerializeLong() {
379 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
380 nodeBuilder.setIntValueType(ValueType.LONG_TYPE.ordinal());
381 nodeBuilder.setValue("25");
383 Object value = ValueSerializer
384 .deSerialize(mock(QNameDeSerializationContext.class),
385 nodeBuilder.build());
387 assertTrue(value instanceof Long);
388 assertEquals(25, ((Long) value).longValue());
393 public void testDeSerializeBoolean() {
394 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
395 nodeBuilder.setIntValueType(ValueType.BOOL_TYPE.ordinal());
396 nodeBuilder.setValue("false");
398 Object value = ValueSerializer
399 .deSerialize(mock(QNameDeSerializationContext.class),
400 nodeBuilder.build());
402 assertTrue(value instanceof Boolean);
403 assertEquals(false, ((Boolean) value).booleanValue());
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());
413 Object value = ValueSerializer
414 .deSerialize(mock(QNameDeSerializationContext.class),
415 nodeBuilder.build());
417 assertTrue(value instanceof QName);
418 assertEquals(TestModel.TEST_QNAME, value);
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"));
428 Object value = ValueSerializer
429 .deSerialize(mock(QNameDeSerializationContext.class),
430 nodeBuilder.build());
432 assertTrue(value instanceof Set);
433 assertTrue(((Set<?>)value).contains("foo"));
434 assertTrue(((Set<?>) value).contains("bar"));
436 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
437 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
439 argumentBuilder.setType(ValueType.BITS_TYPE.ordinal());
440 argumentBuilder.addAllBitsValue(ImmutableList.of("foo", "bar"));
442 value = ValueSerializer
443 .deSerialize(mock(QNameDeSerializationContext.class),
444 argumentBuilder.build());
446 assertTrue(value instanceof Set);
447 assertTrue(((Set<?>)value).contains("foo"));
448 assertTrue(((Set<?>) value).contains("bar"));
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();
460 pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER.ordinal());
462 idBuilder.addArguments(pathBuilder);
464 nodeBuilder.setIntValueType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
465 nodeBuilder.setInstanceIdentifierValue(idBuilder);
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());
473 Object value = ValueSerializer.deSerialize(mockContext, nodeBuilder.build());
475 assertTrue(value instanceof YangInstanceIdentifier);
476 assertEquals(TestModel.TEST_PATH, value);
478 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
479 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
481 argumentBuilder.setType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
482 argumentBuilder.setInstanceIdentifierValue(idBuilder);
484 value = ValueSerializer.deSerialize(mockContext, argumentBuilder.build());
486 assertTrue(value instanceof YangInstanceIdentifier);
487 assertEquals(TestModel.TEST_PATH, value);
491 public void testDeSerializeString() {
492 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
493 nodeBuilder.setIntValueType(ValueType.STRING_TYPE.ordinal());
494 nodeBuilder.setValue("25");
496 Object value = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),
497 nodeBuilder.build());
499 assertTrue(value instanceof String);
500 assertEquals("25", value);
505 public void testDeSerializeBigInteger() {
506 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
507 nodeBuilder.setIntValueType(ValueType.BIG_INTEGER_TYPE.ordinal());
508 nodeBuilder.setValue("25");
510 Object value = ValueSerializer
511 .deSerialize(mock(QNameDeSerializationContext.class),
512 nodeBuilder.build());
514 assertTrue(value instanceof BigInteger);
515 assertEquals(new BigInteger("25"), value);
520 public void testDeSerializeBigDecimal() {
521 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
522 nodeBuilder.setIntValueType(ValueType.BIG_DECIMAL_TYPE.ordinal());
523 nodeBuilder.setValue("25");
525 Object value = ValueSerializer
526 .deSerialize(mock(QNameDeSerializationContext.class),
527 nodeBuilder.build());
529 assertTrue(value instanceof BigDecimal);
530 assertEquals(new BigDecimal("25"), value);
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));
542 Object value = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),nodeBuilder.build());
544 assertTrue("not a byte array", value instanceof byte[]);
545 assertTrue("bytes value does not match" , Arrays.equals(bytes, (byte[]) value));
547 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
548 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
549 argumentBuilder.setType(ValueType.BINARY_TYPE.ordinal());
550 argumentBuilder.setBytesValue(ByteString.copyFrom(bytes));
552 value = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class), argumentBuilder.build());
554 assertTrue("not a byte array", value instanceof byte[]);
555 assertTrue("bytes value does not match" ,Arrays.equals(bytes, (byte[]) value));
561 public void testDeSerializeNullType() {
562 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
563 nodeBuilder.setIntValueType(ValueType.NULL_TYPE.ordinal());
564 nodeBuilder.setValue("");
566 Object value = ValueSerializer
567 .deSerialize(mock(QNameDeSerializationContext.class),
568 nodeBuilder.build());
570 assertEquals(null, value);
572 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
573 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
575 argumentBuilder.setType(ValueType.NULL_TYPE.ordinal());
576 argumentBuilder.setValue("");
578 value = ValueSerializer
579 .deSerialize(mock(QNameDeSerializationContext.class),
580 argumentBuilder.build());
582 assertEquals(null, value);