1 package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
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;
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;
22 public class ValueSerializerTest{
25 public ExpectedException expectedException = ExpectedException.none();
28 public void testSerializeShort(){
30 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
31 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
33 assertEquals(ValueType.SHORT_TYPE.ordinal(), builder.getIntValueType());
34 assertEquals("5", builder.getValue());
36 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
37 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
39 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
41 assertEquals(ValueType.SHORT_TYPE.ordinal(), builder1.getType());
42 assertEquals("5", builder.getValue());
47 public void testSerializeInteger(){
48 String hexNumber = "f3";
50 Integer expected = Integer.valueOf(hexNumber, 16);
53 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
54 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), expected);
56 assertEquals(ValueType.INT_TYPE.ordinal(), builder.getIntValueType());
57 assertEquals("243", builder.getValue());
59 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
60 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
62 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), expected);
64 assertEquals(ValueType.INT_TYPE.ordinal(), builder1.getType());
65 assertEquals("243", builder1.getValue());
72 public void testSerializeLong(){
74 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
75 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
77 assertEquals(ValueType.LONG_TYPE.ordinal(), builder.getIntValueType());
78 assertEquals("5", builder.getValue());
80 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
82 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
84 assertEquals(ValueType.LONG_TYPE.ordinal(), builder1.getType());
85 assertEquals("5", builder1.getValue());
90 public void testSerializeByte(){
92 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
93 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
95 assertEquals(ValueType.BYTE_TYPE.ordinal(), builder.getIntValueType());
96 assertEquals("5", builder.getValue());
98 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
100 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
102 assertEquals(ValueType.BYTE_TYPE.ordinal(), builder1.getType());
103 assertEquals("5", builder1.getValue());
108 public void testSerializeBits(){
109 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
110 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),
111 ImmutableSet.of("foo", "bar"));
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"));
117 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
119 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),
120 ImmutableSet.of("foo", "bar"));
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"));
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));
139 public void testSerializeEmptyString(){
140 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
141 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),"");
143 assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
144 assertEquals("", builder.getValue());
146 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
148 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),"");
150 assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
151 assertEquals("", builder1.getValue());
156 public void testSerializeString(){
157 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
158 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),"foo");
160 assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
161 assertEquals("foo", builder.getValue());
163 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
164 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
166 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),"foo");
168 assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
169 assertEquals("foo", builder1.getValue());
175 public void testSerializeBoolean(){
177 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
178 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class), v1);
180 assertEquals(ValueType.BOOL_TYPE.ordinal(), builder.getIntValueType());
181 assertEquals("true", builder.getValue());
183 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 =
184 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
185 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
187 assertEquals(ValueType.BOOL_TYPE.ordinal(), builder1.getType());
188 assertEquals("true", builder1.getValue());
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);
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());
200 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
202 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
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());
210 public void testSerializeYangIdentifier(){
211 YangInstanceIdentifier v1 = TestModel.TEST_PATH;
213 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
214 QNameSerializationContext mockContext = mock(QNameSerializationContext.class);
215 ValueSerializer.serialize(builder, mockContext, v1);
217 assertEquals(ValueType.YANG_IDENTIFIER_TYPE.ordinal(), builder.getIntValueType());
218 NormalizedNodeMessages.InstanceIdentifier serializedYangInstanceIdentifier =
219 builder.getInstanceIdentifierValue();
221 assertEquals(1, serializedYangInstanceIdentifier.getArgumentsCount());
222 Mockito.verify(mockContext).addLocalName(TestModel.TEST_QNAME.getLocalName());
223 Mockito.verify(mockContext).addNamespace(TestModel.TEST_QNAME.getNamespace());
225 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
226 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
228 mockContext = mock(QNameSerializationContext.class);
230 ValueSerializer.serialize(argumentBuilder, mockContext, v1);
232 serializedYangInstanceIdentifier =
233 argumentBuilder.getInstanceIdentifierValue();
235 assertEquals(1, serializedYangInstanceIdentifier.getArgumentsCount());
236 Mockito.verify(mockContext).addLocalName(TestModel.TEST_QNAME.getLocalName());
237 Mockito.verify(mockContext).addNamespace(TestModel.TEST_QNAME.getNamespace());
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);
247 assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder.getIntValueType());
248 assertEquals("1000000000000000000000000", builder.getValue());
250 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
252 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
254 assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder1.getType());
255 assertEquals("1000000000000000000000000", builder1.getValue());
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);
265 assertEquals(ValueType.BIG_DECIMAL_TYPE.ordinal(), builder.getIntValueType());
266 assertEquals("1000000000000000000000000.51616", builder.getValue());
268 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
269 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class), v1);
271 assertEquals(ValueType.BIG_DECIMAL_TYPE.ordinal(), builder1.getType());
272 assertEquals("1000000000000000000000000.51616", builder1.getValue());
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);
282 assertEquals(ValueType.BINARY_TYPE.ordinal(), builder.getIntValueType());
283 assertEquals(ByteString.copyFrom(bytes), builder.getBytesValue());
285 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
287 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),bytes);
289 assertEquals(ValueType.BINARY_TYPE.ordinal(), builder1.getType());
290 assertEquals(ByteString.copyFrom(bytes), builder1.getBytesValue());
295 public void testSerializeNull(){
296 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
298 ValueSerializer.serialize(builder, mock(QNameSerializationContext.class),none);
300 assertEquals(ValueType.NULL_TYPE.ordinal(), builder.getIntValueType());
301 assertEquals("", builder.getValue());
303 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
305 ValueSerializer.serialize(builder1, mock(QNameSerializationContext.class),none);
307 assertEquals(ValueType.NULL_TYPE.ordinal(), builder1.getType());
308 assertEquals("", builder.getValue());
314 public void testDeSerializeShort(){
315 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
316 nodeBuilder.setIntValueType(ValueType.SHORT_TYPE.ordinal());
317 nodeBuilder.setValue("25");
319 Object o = ValueSerializer
320 .deSerialize(mock(QNameDeSerializationContext.class),
321 nodeBuilder.build());
323 assertTrue(o instanceof Short);
324 assertEquals(25, ((Short) o).shortValue());
328 public void testDeSerializeByte(){
329 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
330 nodeBuilder.setIntValueType(ValueType.BYTE_TYPE.ordinal());
331 nodeBuilder.setValue("25");
333 Object o = ValueSerializer
334 .deSerialize(mock(QNameDeSerializationContext.class),
335 nodeBuilder.build());
337 assertTrue(o instanceof Byte);
338 assertEquals(25, ((Byte) o).byteValue());
343 public void testDeSerializeInteger(){
344 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
345 nodeBuilder.setIntValueType(ValueType.INT_TYPE.ordinal());
346 nodeBuilder.setValue("25");
348 Object o = ValueSerializer
349 .deSerialize(mock(QNameDeSerializationContext.class),
350 nodeBuilder.build());
352 assertTrue(o instanceof Integer);
353 assertEquals(25, ((Integer) o).intValue());
358 public void testDeSerializeLong(){
359 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
360 nodeBuilder.setIntValueType(ValueType.LONG_TYPE.ordinal());
361 nodeBuilder.setValue("25");
363 Object o = ValueSerializer
364 .deSerialize(mock(QNameDeSerializationContext.class),
365 nodeBuilder.build());
367 assertTrue(o instanceof Long);
368 assertEquals(25, ((Long) o).longValue());
373 public void testDeSerializeBoolean(){
374 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
375 nodeBuilder.setIntValueType(ValueType.BOOL_TYPE.ordinal());
376 nodeBuilder.setValue("false");
378 Object o = ValueSerializer
379 .deSerialize(mock(QNameDeSerializationContext.class),
380 nodeBuilder.build());
382 assertTrue(o instanceof Boolean);
383 assertEquals(false, ((Boolean) o).booleanValue());
388 public void testDeSerializeQName(){
389 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
390 nodeBuilder.setIntValueType(ValueType.QNAME_TYPE.ordinal());
391 nodeBuilder.setValue(TestModel.TEST_QNAME.toString());
393 Object o = ValueSerializer
394 .deSerialize(mock(QNameDeSerializationContext.class),
395 nodeBuilder.build());
397 assertTrue(o instanceof QName);
398 assertEquals(TestModel.TEST_QNAME, o);
403 public void testDeSerializeBits(){
404 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
405 nodeBuilder.setIntValueType(ValueType.BITS_TYPE.ordinal());
406 nodeBuilder.addAllBitsValue(ImmutableList.of("foo", "bar"));
408 Object o = ValueSerializer
409 .deSerialize(mock(QNameDeSerializationContext.class),
410 nodeBuilder.build());
412 assertTrue(o instanceof Set);
413 assertTrue(((Set<?>)o).contains("foo"));
414 assertTrue(((Set<?>) o).contains("bar"));
416 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
417 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
419 argumentBuilder.setType(ValueType.BITS_TYPE.ordinal());
420 argumentBuilder.addAllBitsValue(ImmutableList.of("foo", "bar"));
423 .deSerialize(mock(QNameDeSerializationContext.class),
424 argumentBuilder.build());
426 assertTrue(o instanceof Set);
427 assertTrue(((Set<?>)o).contains("foo"));
428 assertTrue(((Set<?>) o).contains("bar"));
433 public void testDeSerializeYangIdentifier(){
434 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
435 NormalizedNodeMessages.InstanceIdentifier.Builder idBuilder = NormalizedNodeMessages.InstanceIdentifier.newBuilder();
436 NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
438 pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER.ordinal());
440 idBuilder.addArguments(pathBuilder);
442 nodeBuilder.setIntValueType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
443 nodeBuilder.setInstanceIdentifierValue(idBuilder);
445 QNameDeSerializationContext mockContext = mock(QNameDeSerializationContext.class);
446 Mockito.doReturn(TestModel.TEST_QNAME.getNamespace().toString()).when(mockContext).
447 getNamespace(Mockito.anyInt());
448 Mockito.doReturn(TestModel.TEST_QNAME.getLocalName()).when(mockContext).
449 getLocalName(Mockito.anyInt());
450 Mockito.doReturn(TestModel.TEST_QNAME.getFormattedRevision()).when(mockContext).
451 getRevision(Mockito.anyInt());
453 Object o = ValueSerializer.deSerialize(mockContext, nodeBuilder.build());
455 assertTrue(o instanceof YangInstanceIdentifier);
456 assertEquals(TestModel.TEST_PATH, o);
458 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
459 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
461 argumentBuilder.setType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
462 argumentBuilder.setInstanceIdentifierValue(idBuilder);
464 o = ValueSerializer.deSerialize(mockContext, argumentBuilder.build());
466 assertTrue(o instanceof YangInstanceIdentifier);
467 assertEquals(TestModel.TEST_PATH, o);
471 public void testDeSerializeString(){
472 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
473 nodeBuilder.setIntValueType(ValueType.STRING_TYPE.ordinal());
474 nodeBuilder.setValue("25");
476 Object o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),
477 nodeBuilder.build());
479 assertTrue(o instanceof String);
480 assertEquals("25", o);
485 public void testDeSerializeBigInteger(){
486 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
487 nodeBuilder.setIntValueType(ValueType.BIG_INTEGER_TYPE.ordinal());
488 nodeBuilder.setValue("25");
490 Object o = ValueSerializer
491 .deSerialize(mock(QNameDeSerializationContext.class),
492 nodeBuilder.build());
494 assertTrue(o instanceof BigInteger);
495 assertEquals(new BigInteger("25"), o);
500 public void testDeSerializeBigDecimal(){
501 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
502 nodeBuilder.setIntValueType(ValueType.BIG_DECIMAL_TYPE.ordinal());
503 nodeBuilder.setValue("25");
505 Object o = ValueSerializer
506 .deSerialize(mock(QNameDeSerializationContext.class),
507 nodeBuilder.build());
509 assertTrue(o instanceof BigDecimal);
510 assertEquals(new BigDecimal("25"), o);
516 public void testDeSerializeBinaryType(){
517 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
518 nodeBuilder.setIntValueType(ValueType.BINARY_TYPE.ordinal());
519 byte[] bytes = new byte[] {1,2,3,4};
520 nodeBuilder.setBytesValue(ByteString.copyFrom(bytes));
522 Object o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),nodeBuilder.build());
524 assertTrue("not a byte array", o instanceof byte[]);
525 assertTrue("bytes value does not match" , Arrays.equals(bytes, (byte[]) o));
527 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
528 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
529 argumentBuilder.setType(ValueType.BINARY_TYPE.ordinal());
530 argumentBuilder.setBytesValue(ByteString.copyFrom(bytes));
532 o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class), argumentBuilder.build());
534 assertTrue("not a byte array", o instanceof byte[]);
535 assertTrue("bytes value does not match" ,Arrays.equals(bytes, (byte[]) o));
541 public void testDeSerializeNullType(){
542 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
543 nodeBuilder.setIntValueType(ValueType.NULL_TYPE.ordinal());
544 nodeBuilder.setValue("");
546 Object o = ValueSerializer
547 .deSerialize(mock(QNameDeSerializationContext.class),
548 nodeBuilder.build());
550 assertEquals(null, o);
552 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
553 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
555 argumentBuilder.setType(ValueType.NULL_TYPE.ordinal());
556 argumentBuilder.setValue("");
559 .deSerialize(mock(QNameDeSerializationContext.class),
560 argumentBuilder.build());
562 assertEquals(null, o);