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());
296 public void testDeSerializeShort(){
297 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
298 nodeBuilder.setIntValueType(ValueType.SHORT_TYPE.ordinal());
299 nodeBuilder.setValue("25");
301 Object o = ValueSerializer
302 .deSerialize(mock(QNameDeSerializationContext.class),
303 nodeBuilder.build());
305 assertTrue(o instanceof Short);
306 assertEquals(25, ((Short) o).shortValue());
310 public void testDeSerializeByte(){
311 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
312 nodeBuilder.setIntValueType(ValueType.BYTE_TYPE.ordinal());
313 nodeBuilder.setValue("25");
315 Object o = ValueSerializer
316 .deSerialize(mock(QNameDeSerializationContext.class),
317 nodeBuilder.build());
319 assertTrue(o instanceof Byte);
320 assertEquals(25, ((Byte) o).byteValue());
325 public void testDeSerializeInteger(){
326 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
327 nodeBuilder.setIntValueType(ValueType.INT_TYPE.ordinal());
328 nodeBuilder.setValue("25");
330 Object o = ValueSerializer
331 .deSerialize(mock(QNameDeSerializationContext.class),
332 nodeBuilder.build());
334 assertTrue(o instanceof Integer);
335 assertEquals(25, ((Integer) o).intValue());
340 public void testDeSerializeLong(){
341 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
342 nodeBuilder.setIntValueType(ValueType.LONG_TYPE.ordinal());
343 nodeBuilder.setValue("25");
345 Object o = ValueSerializer
346 .deSerialize(mock(QNameDeSerializationContext.class),
347 nodeBuilder.build());
349 assertTrue(o instanceof Long);
350 assertEquals(25, ((Long) o).longValue());
355 public void testDeSerializeBoolean(){
356 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
357 nodeBuilder.setIntValueType(ValueType.BOOL_TYPE.ordinal());
358 nodeBuilder.setValue("false");
360 Object o = ValueSerializer
361 .deSerialize(mock(QNameDeSerializationContext.class),
362 nodeBuilder.build());
364 assertTrue(o instanceof Boolean);
365 assertEquals(false, ((Boolean) o).booleanValue());
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());
375 Object o = ValueSerializer
376 .deSerialize(mock(QNameDeSerializationContext.class),
377 nodeBuilder.build());
379 assertTrue(o instanceof QName);
380 assertEquals(TestModel.TEST_QNAME, o);
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"));
390 Object o = ValueSerializer
391 .deSerialize(mock(QNameDeSerializationContext.class),
392 nodeBuilder.build());
394 assertTrue(o instanceof Set);
395 assertTrue(((Set<?>)o).contains("foo"));
396 assertTrue(((Set<?>) o).contains("bar"));
398 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder
399 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
401 argumentBuilder.setType(ValueType.BITS_TYPE.ordinal());
402 argumentBuilder.addAllBitsValue(ImmutableList.of("foo", "bar"));
405 .deSerialize(mock(QNameDeSerializationContext.class),
406 argumentBuilder.build());
408 assertTrue(o instanceof Set);
409 assertTrue(((Set<?>)o).contains("foo"));
410 assertTrue(((Set<?>) o).contains("bar"));
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();
420 pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER.ordinal());
422 idBuilder.addArguments(pathBuilder);
424 nodeBuilder.setIntValueType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
425 nodeBuilder.setInstanceIdentifierValue(idBuilder);
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());
435 Object o = ValueSerializer.deSerialize(mockContext, nodeBuilder.build());
437 assertTrue(o instanceof YangInstanceIdentifier);
438 assertEquals(TestModel.TEST_PATH, o);
440 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
441 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
443 argumentBuilder.setType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
444 argumentBuilder.setInstanceIdentifierValue(idBuilder);
446 o = ValueSerializer.deSerialize(mockContext, argumentBuilder.build());
448 assertTrue(o instanceof YangInstanceIdentifier);
449 assertEquals(TestModel.TEST_PATH, o);
453 public void testDeSerializeString(){
454 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
455 nodeBuilder.setIntValueType(ValueType.STRING_TYPE.ordinal());
456 nodeBuilder.setValue("25");
458 Object o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),
459 nodeBuilder.build());
461 assertTrue(o instanceof String);
462 assertEquals("25", o);
467 public void testDeSerializeBigInteger(){
468 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
469 nodeBuilder.setIntValueType(ValueType.BIG_INTEGER_TYPE.ordinal());
470 nodeBuilder.setValue("25");
472 Object o = ValueSerializer
473 .deSerialize(mock(QNameDeSerializationContext.class),
474 nodeBuilder.build());
476 assertTrue(o instanceof BigInteger);
477 assertEquals(new BigInteger("25"), o);
482 public void testDeSerializeBigDecimal(){
483 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
484 nodeBuilder.setIntValueType(ValueType.BIG_DECIMAL_TYPE.ordinal());
485 nodeBuilder.setValue("25");
487 Object o = ValueSerializer
488 .deSerialize(mock(QNameDeSerializationContext.class),
489 nodeBuilder.build());
491 assertTrue(o instanceof BigDecimal);
492 assertEquals(new BigDecimal("25"), o);
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));
504 Object o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class),nodeBuilder.build());
506 assertTrue("not a byte array", o instanceof byte[]);
507 assertTrue("bytes value does not match" , Arrays.equals(bytes, (byte[]) o));
509 NormalizedNodeMessages.PathArgumentAttribute.Builder argumentBuilder =
510 NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
511 argumentBuilder.setType(ValueType.BINARY_TYPE.ordinal());
512 argumentBuilder.setBytesValue(ByteString.copyFrom(bytes));
514 o = ValueSerializer.deSerialize(mock(QNameDeSerializationContext.class), argumentBuilder.build());
516 assertTrue("not a byte array", o instanceof byte[]);
517 assertTrue("bytes value does not match" ,Arrays.equals(bytes, (byte[]) o));