1 package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
3 import com.google.common.collect.ImmutableList;
4 import com.google.common.collect.ImmutableSet;
7 import org.junit.rules.ExpectedException;
8 import org.opendaylight.controller.cluster.datastore.util.TestModel;
9 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
10 import org.opendaylight.yangtools.yang.common.QName;
11 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
13 import java.math.BigDecimal;
14 import java.math.BigInteger;
17 import static org.junit.Assert.assertEquals;
18 import static org.junit.Assert.assertTrue;
19 import static org.mockito.Mockito.mock;
21 public class ValueSerializerTest{
24 public ExpectedException expectedException = ExpectedException.none();
27 public void testSerializeShort(){
29 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
30 ValueSerializer.serialize(builder, mock(NormalizedNodeSerializationContext.class), v1);
32 assertEquals(ValueType.SHORT_TYPE.ordinal(), builder.getIntValueType());
33 assertEquals("5", builder.getValue());
35 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
37 ValueSerializer.serialize(builder1, mock(NormalizedNodeSerializationContext.class), v1);
39 assertEquals(ValueType.SHORT_TYPE.ordinal(), builder1.getType());
40 assertEquals("5", builder.getValue());
45 public void testSerializeInteger(){
46 String hexNumber = "f3";
48 Integer expected = Integer.valueOf(hexNumber, 16);
51 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
52 ValueSerializer.serialize(builder, mock(
53 NormalizedNodeSerializationContext.class), expected);
55 assertEquals(ValueType.INT_TYPE.ordinal(), builder.getIntValueType());
56 assertEquals("243", builder.getValue());
58 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
60 ValueSerializer.serialize(builder1, mock(
61 NormalizedNodeSerializationContext.class), expected);
63 assertEquals(ValueType.INT_TYPE.ordinal(), builder1.getType());
64 assertEquals("243", builder1.getValue());
71 public void testSerializeLong(){
73 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
74 ValueSerializer.serialize(builder, mock(
75 NormalizedNodeSerializationContext.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(
83 NormalizedNodeSerializationContext.class), v1);
85 assertEquals(ValueType.LONG_TYPE.ordinal(), builder1.getType());
86 assertEquals("5", builder1.getValue());
91 public void testSerializeByte(){
93 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
94 ValueSerializer.serialize(builder, mock(
95 NormalizedNodeSerializationContext.class), v1);
97 assertEquals(ValueType.BYTE_TYPE.ordinal(), builder.getIntValueType());
98 assertEquals("5", builder.getValue());
100 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
102 ValueSerializer.serialize(builder1, mock(
103 NormalizedNodeSerializationContext.class), v1);
105 assertEquals(ValueType.BYTE_TYPE.ordinal(), builder1.getType());
106 assertEquals("5", builder1.getValue());
111 public void testSerializeBits(){
112 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
113 ValueSerializer.serialize(builder, mock(
114 NormalizedNodeSerializationContext.class),
115 ImmutableSet.of("foo", "bar"));
117 assertEquals(ValueType.BITS_TYPE.ordinal(), builder.getIntValueType());
118 assertTrue( "foo not in bits", builder.getBitsValueList().contains("foo"));
119 assertTrue( "bar not in bits", builder.getBitsValueList().contains("bar"));
121 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
123 ValueSerializer.serialize(builder1, mock(
124 NormalizedNodeSerializationContext.class),
125 ImmutableSet.of("foo", "bar"));
127 assertEquals(ValueType.BITS_TYPE.ordinal(), builder1.getType());
128 assertEquals("[foo, bar]", builder1.getValue());
133 public void testSerializeWrongTypeOfSet(){
134 expectedException.expect(IllegalArgumentException.class);
135 expectedException.expectMessage("Expected value type to be Bits but was :");
136 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
137 ValueSerializer.serialize(builder, mock(
138 NormalizedNodeSerializationContext.class),
139 ImmutableSet.of(1, 2));
144 public void testSerializeEmptyString(){
145 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
146 ValueSerializer.serialize(builder, mock(
147 NormalizedNodeSerializationContext.class),"");
149 assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
150 assertEquals("", builder.getValue());
152 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
154 ValueSerializer.serialize(builder1, mock(
155 NormalizedNodeSerializationContext.class),"");
157 assertEquals(ValueType.STRING_TYPE.ordinal(), builder1.getType());
158 assertEquals("", builder1.getValue());
163 public void testSerializeString(){
164 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
165 ValueSerializer.serialize(builder, mock(
166 NormalizedNodeSerializationContext.class),"foo");
168 assertEquals(ValueType.STRING_TYPE.ordinal(), builder.getIntValueType());
169 assertEquals("foo", builder.getValue());
171 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
173 ValueSerializer.serialize(builder1, mock(
174 NormalizedNodeSerializationContext.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(
187 NormalizedNodeSerializationContext.class), v1);
189 assertEquals(ValueType.BOOL_TYPE.ordinal(), builder.getIntValueType());
190 assertEquals("true", builder.getValue());
192 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
193 ValueSerializer.serialize(builder1, mock(
194 NormalizedNodeSerializationContext.class), v1);
196 assertEquals(ValueType.BOOL_TYPE.ordinal(), builder1.getType());
197 assertEquals("true", builder1.getValue());
201 public void testSerializeQName(){
202 QName v1 = TestModel.TEST_QNAME;
203 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
204 ValueSerializer.serialize(builder, mock(
205 NormalizedNodeSerializationContext.class), v1);
207 assertEquals(ValueType.QNAME_TYPE.ordinal(), builder.getIntValueType());
208 assertEquals("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test", builder.getValue());
210 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
212 ValueSerializer.serialize(builder1, mock(
213 NormalizedNodeSerializationContext.class), v1);
215 assertEquals(ValueType.QNAME_TYPE.ordinal(), builder1.getType());
216 assertEquals("(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test", builder1.getValue());
221 public void testSerializeYangIdentifier(){
222 YangInstanceIdentifier v1 = TestModel.TEST_PATH;
224 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
225 ValueSerializer.serialize(builder, mock(
226 NormalizedNodeSerializationContext.class), v1);
229 assertEquals(ValueType.YANG_IDENTIFIER_TYPE.ordinal(), builder.getIntValueType());
230 NormalizedNodeMessages.InstanceIdentifier serializedYangInstanceIdentifier =
231 builder.getInstanceIdentifierValue();
233 assertEquals(1, serializedYangInstanceIdentifier.getArgumentsCount());
234 assertEquals(TestModel.TEST_QNAME.toString(), serializedYangInstanceIdentifier.getArguments(0).getNodeType().getValue());
238 public void testSerializeBigInteger(){
239 BigInteger v1 = new BigInteger("1000000000000000000000000");
240 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
241 ValueSerializer.serialize(builder, mock(
242 NormalizedNodeSerializationContext.class), v1);
244 assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder.getIntValueType());
245 assertEquals("1000000000000000000000000", builder.getValue());
247 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
249 ValueSerializer.serialize(builder1, mock(
250 NormalizedNodeSerializationContext.class), v1);
252 assertEquals(ValueType.BIG_INTEGER_TYPE.ordinal(), builder1.getType());
253 assertEquals("1000000000000000000000000", builder1.getValue());
258 public void testSerializeBigDecimal(){
259 BigDecimal v1 = new BigDecimal("1000000000000000000000000.51616");
260 NormalizedNodeMessages.Node.Builder builder = NormalizedNodeMessages.Node.newBuilder();
261 ValueSerializer.serialize(builder, mock(
262 NormalizedNodeSerializationContext.class), v1);
264 assertEquals(ValueType.BIG_DECIMAL_TYPE.ordinal(), builder.getIntValueType());
265 assertEquals("1000000000000000000000000.51616", builder.getValue());
267 NormalizedNodeMessages.PathArgumentAttribute.Builder builder1 = NormalizedNodeMessages.PathArgumentAttribute.newBuilder();
268 ValueSerializer.serialize(builder1, mock(
269 NormalizedNodeSerializationContext.class), v1);
271 assertEquals(ValueType.BIG_DECIMAL_TYPE.ordinal(), builder1.getType());
272 assertEquals("1000000000000000000000000.51616", builder1.getValue());
277 public void testDeSerializeShort(){
278 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
279 nodeBuilder.setIntValueType(ValueType.SHORT_TYPE.ordinal());
280 nodeBuilder.setValue("25");
282 Object o = ValueSerializer
283 .deSerialize(mock(NormalizedNodeDeSerializationContext.class),
284 nodeBuilder.build());
286 assertTrue(o instanceof Short);
287 assertEquals(25, ((Short) o).shortValue());
291 public void testDeSerializeByte(){
292 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
293 nodeBuilder.setIntValueType(ValueType.BYTE_TYPE.ordinal());
294 nodeBuilder.setValue("25");
296 Object o = ValueSerializer
297 .deSerialize(mock(NormalizedNodeDeSerializationContext.class),
298 nodeBuilder.build());
300 assertTrue(o instanceof Byte);
301 assertEquals(25, ((Byte) o).byteValue());
306 public void testDeSerializeInteger(){
307 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
308 nodeBuilder.setIntValueType(ValueType.INT_TYPE.ordinal());
309 nodeBuilder.setValue("25");
311 Object o = ValueSerializer
312 .deSerialize(mock(NormalizedNodeDeSerializationContext.class),
313 nodeBuilder.build());
315 assertTrue(o instanceof Integer);
316 assertEquals(25, ((Integer) o).intValue());
321 public void testDeSerializeLong(){
322 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
323 nodeBuilder.setIntValueType(ValueType.LONG_TYPE.ordinal());
324 nodeBuilder.setValue("25");
326 Object o = ValueSerializer
327 .deSerialize(mock(NormalizedNodeDeSerializationContext.class),
328 nodeBuilder.build());
330 assertTrue(o instanceof Long);
331 assertEquals(25, ((Long) o).longValue());
336 public void testDeSerializeBoolean(){
337 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
338 nodeBuilder.setIntValueType(ValueType.BOOL_TYPE.ordinal());
339 nodeBuilder.setValue("false");
341 Object o = ValueSerializer
342 .deSerialize(mock(NormalizedNodeDeSerializationContext.class),
343 nodeBuilder.build());
345 assertTrue(o instanceof Boolean);
346 assertEquals(false, ((Boolean) o).booleanValue());
351 public void testDeSerializeQName(){
352 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
353 nodeBuilder.setIntValueType(ValueType.QNAME_TYPE.ordinal());
354 nodeBuilder.setValue(TestModel.TEST_QNAME.toString());
356 Object o = ValueSerializer
357 .deSerialize(mock(NormalizedNodeDeSerializationContext.class),
358 nodeBuilder.build());
360 assertTrue(o instanceof QName);
361 assertEquals(TestModel.TEST_QNAME, o);
366 public void testDeSerializeBits(){
367 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
368 nodeBuilder.setIntValueType(ValueType.BITS_TYPE.ordinal());
369 nodeBuilder.addAllBitsValue(ImmutableList.of("foo", "bar"));
371 Object o = ValueSerializer
372 .deSerialize(mock(NormalizedNodeDeSerializationContext.class),
373 nodeBuilder.build());
375 assertTrue(o instanceof Set);
376 assertTrue(((Set)o).contains("foo"));
377 assertTrue(((Set) o).contains("bar"));
382 public void testDeSerializeYangIdentifier(){
383 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
384 NormalizedNodeMessages.InstanceIdentifier.Builder idBuilder = NormalizedNodeMessages.InstanceIdentifier.newBuilder();
385 NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
387 pathBuilder.setValue(TestModel.TEST_QNAME.toString());
388 pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER.ordinal());
390 idBuilder.addArguments(pathBuilder);
392 nodeBuilder.setIntValueType(ValueType.YANG_IDENTIFIER_TYPE.ordinal());
393 nodeBuilder.setInstanceIdentifierValue(idBuilder);
395 Object o = ValueSerializer
396 .deSerialize(mock(NormalizedNodeDeSerializationContext.class),
397 nodeBuilder.build());
399 assertTrue(o instanceof YangInstanceIdentifier);
400 assertEquals(TestModel.TEST_PATH, o);
405 public void testDeSerializeString(){
406 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
407 nodeBuilder.setIntValueType(ValueType.STRING_TYPE.ordinal());
408 nodeBuilder.setValue("25");
410 Object o = ValueSerializer
411 .deSerialize(mock(NormalizedNodeDeSerializationContext.class),
412 nodeBuilder.build());
414 assertTrue(o instanceof String);
415 assertEquals("25", o);
420 public void testDeSerializeBigInteger(){
421 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
422 nodeBuilder.setIntValueType(ValueType.BIG_INTEGER_TYPE.ordinal());
423 nodeBuilder.setValue("25");
425 Object o = ValueSerializer
426 .deSerialize(mock(NormalizedNodeDeSerializationContext.class),
427 nodeBuilder.build());
429 assertTrue(o instanceof BigInteger);
430 assertEquals(new BigInteger("25"), o);
435 public void testDeSerializeBigDecimal(){
436 NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
437 nodeBuilder.setIntValueType(ValueType.BIG_DECIMAL_TYPE.ordinal());
438 nodeBuilder.setValue("25");
440 Object o = ValueSerializer
441 .deSerialize(mock(NormalizedNodeDeSerializationContext.class),
442 nodeBuilder.build());
444 assertTrue(o instanceof BigDecimal);
445 assertEquals(new BigDecimal("25"), o);