2 * Copyright (c) 2014 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
8 package org.opendaylight.mdsal.binding.dom.codec.impl;
10 import static java.util.Collections.singleton;
11 import static org.junit.Assert.assertEquals;
12 import static org.junit.Assert.assertNotEquals;
13 import static org.junit.Assert.assertNotNull;
14 import static org.junit.Assert.fail;
15 import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.top;
16 import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.topLevelList;
17 import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.augmentationBuilder;
18 import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.choiceBuilder;
19 import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.containerBuilder;
20 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.leafNode;
21 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntry;
22 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
23 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
25 import java.util.ArrayList;
26 import java.util.Collections;
27 import java.util.HashMap;
28 import java.util.HashSet;
29 import java.util.List;
31 import java.util.Map.Entry;
33 import org.junit.Test;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment1;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment1Builder;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment2;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment2Builder;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugment;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeLeafOnlyAugment;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeLeafOnlyAugmentBuilder;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.AugmentChoice1;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.augment.choice1.Case1Builder;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.augment.choice1.case1.augment.choice2.Case11Builder;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.augment.choice1.case1.augment.choice2.case11.Case11ChoiceCaseContainerBuilder;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.ChoiceContainer;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.ChoiceContainerBuilder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top1;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top1Builder;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top2;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top2Builder;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.TopBuilder;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.choice.identifier.ExtendedBuilder;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.choice.identifier.extended.ExtendedIdBuilder;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelList;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListBuilder;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListKey;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.top.level.list.NestedList;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.top.level.list.NestedListBuilder;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.top.level.list.NestedListKey;
61 import org.opendaylight.yang.gen.v1.urn.test.foo4798.rev160101.Root;
62 import org.opendaylight.yangtools.yang.binding.Augmentation;
63 import org.opendaylight.yangtools.yang.binding.DataObject;
64 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
65 import org.opendaylight.yangtools.yang.common.QName;
66 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
67 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
68 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
69 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
70 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
71 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
72 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
73 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
74 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
75 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
76 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
77 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAugmentationNodeBuilder;
78 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableChoiceNodeBuilder;
79 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
80 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
81 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
82 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
83 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
84 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedLeafSetNodeBuilder;
85 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedMapNodeBuilder;
87 public class NormalizedNodeSerializeDeserializeTest extends AbstractBindingCodecTest {
89 public static final String TOP_LEVEL_LIST_FOO_KEY_VALUE = "foo";
90 public static final TopLevelListKey TOP_LEVEL_LIST_FOO_KEY = new TopLevelListKey(TOP_LEVEL_LIST_FOO_KEY_VALUE);
92 public static final QName TOP_QNAME = Top.QNAME;
93 public static final QName TOP_LEVEL_LIST_QNAME = QName.create(TOP_QNAME, "top-level-list");
94 public static final QName TOP_LEVEL_LIST_KEY_QNAME = QName.create(TOP_QNAME, "name");
95 public static final QName TOP_LEVEL_LEAF_LIST_QNAME = QName.create(TOP_QNAME, "top-level-leaf-list");
96 public static final QName TOP_LEVEL_ORDERED_LEAF_LIST_QNAME = QName.create(TOP_QNAME,
97 "top-level-ordered-leaf-list");
98 public static final QName NESTED_LIST_QNAME = QName.create(TOP_QNAME, "nested-list");
99 public static final QName NESTED_LIST_KEY_QNAME = QName.create(TOP_QNAME, "name");
100 public static final QName CHOICE_CONTAINER_QNAME = ChoiceContainer.QNAME;
101 public static final QName CHOICE_IDENTIFIER_QNAME = QName.create(CHOICE_CONTAINER_QNAME, "identifier");
102 public static final QName CHOICE_IDENTIFIER_ID_QNAME = QName.create(CHOICE_CONTAINER_QNAME, "id");
103 public static final QName SIMPLE_ID_QNAME = QName.create(CHOICE_CONTAINER_QNAME, "simple-id");
104 public static final QName EXTENDED_ID_QNAME = QName.create(CHOICE_CONTAINER_QNAME, "extended-id");
105 private static final QName SIMPLE_VALUE_QNAME = QName.create(TreeComplexUsesAugment.QNAME, "simple-value");
107 private static final InstanceIdentifier<TopLevelList> BA_TOP_LEVEL_LIST = InstanceIdentifier
108 .builder(Top.class).child(TopLevelList.class, TOP_LEVEL_LIST_FOO_KEY).build();
109 private static final InstanceIdentifier<TreeLeafOnlyAugment> BA_TREE_LEAF_ONLY =
110 BA_TOP_LEVEL_LIST.augmentation(TreeLeafOnlyAugment.class);
111 private static final InstanceIdentifier<TreeComplexUsesAugment> BA_TREE_COMPLEX_USES =
112 BA_TOP_LEVEL_LIST.augmentation(TreeComplexUsesAugment.class);
114 public static final YangInstanceIdentifier BI_TOP_PATH = YangInstanceIdentifier.of(TOP_QNAME);
115 public static final YangInstanceIdentifier BI_TOP_LEVEL_LIST_PATH = BI_TOP_PATH.node(TOP_LEVEL_LIST_QNAME);
116 public static final YangInstanceIdentifier BI_TOP_LEVEL_LIST_FOO_PATH = BI_TOP_LEVEL_LIST_PATH
117 .node(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME,
118 TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE));
119 public static final YangInstanceIdentifier BI_CHOICE_CONTAINER_PATH = YangInstanceIdentifier.of(
120 CHOICE_CONTAINER_QNAME);
123 public void containerToNormalized() {
124 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
125 InstanceIdentifier.create(Top.class), top());
126 final ContainerNode topNormalized = getEmptyTop();
127 assertEquals(topNormalized, entry.getValue());
131 public void containerFromNormalized() {
132 final ContainerNode topNormalized = getEmptyTop();
133 final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_TOP_PATH,
135 assertEquals(top(), entry.getValue());
138 private static ContainerNode getEmptyTop() {
139 return ImmutableContainerNodeBuilder.create()
140 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
144 private static final QName AGUMENT_STRING_Q = QName.create(TOP_QNAME, "augmented-string");
145 private static final String AUGMENT_STRING_VALUE = "testingEquals";
146 private static final QName AUGMENT_INT_Q = QName.create(TOP_QNAME, "augmented-int");
147 private static final int AUGMENT_INT_VALUE = 44;
150 public void equalsWithAugment() {
151 final ContainerNode topNormalizedWithAugments = getNormalizedTopWithAugments(
152 augmentationBuilder()
153 .withNodeIdentifier(new AugmentationIdentifier(singleton(AGUMENT_STRING_Q)))
154 .withChild(ImmutableNodes.leafNode(AGUMENT_STRING_Q, AUGMENT_STRING_VALUE))
156 final ContainerNode topNormalized = getEmptyTop();
158 final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_TOP_PATH,
160 final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = codecContext.fromNormalizedNode(BI_TOP_PATH,
161 topNormalizedWithAugments);
163 // Equals on other with no augmentation should be false
164 assertNotEquals(top(), entryWithAugments.getValue());
165 // Equals on other(reversed) with no augmentation should be false
166 assertNotEquals(entryWithAugments.getValue(), top());
167 // Equals on other(lazy) with no augmentation should be false
168 assertNotEquals(entry.getValue(), entryWithAugments.getValue());
169 // Equals on other(lazy, reversed) with no augmentation should be false
170 assertNotEquals(entryWithAugments.getValue(), entry.getValue());
172 final Top topWithAugments = topWithAugments(Collections.<Class<? extends Augmentation<Top>>, Augmentation<Top>>
173 singletonMap(Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build()));
174 // Equals other with same augment should be true
175 assertEquals(topWithAugments, entryWithAugments.getValue());
176 // Equals other with same augment should be true
177 assertEquals(entryWithAugments.getValue(), topWithAugments);
178 // Equals on self should be true
179 assertEquals(entryWithAugments.getValue(), entryWithAugments.getValue());
181 final Top topWithAugmentsDiffValue = topWithAugments(
182 Collections.<Class<? extends Augmentation<Top>>, Augmentation<Top>>singletonMap(Top1.class,
183 new Top1Builder().setAugmentedString("differentValue").build()));
184 assertNotEquals(topWithAugmentsDiffValue, entryWithAugments.getValue());
185 assertNotEquals(entryWithAugments.getValue(), topWithAugmentsDiffValue);
189 public void equalsWithMultipleAugments() {
190 final ContainerNode topNormalizedWithAugments = getNormalizedTopWithAugments(
191 augmentationBuilder()
192 .withNodeIdentifier(new AugmentationIdentifier(singleton(AGUMENT_STRING_Q)))
193 .withChild(ImmutableNodes.leafNode(AGUMENT_STRING_Q, AUGMENT_STRING_VALUE))
195 augmentationBuilder()
196 .withNodeIdentifier(new AugmentationIdentifier(singleton(AUGMENT_INT_Q)))
197 .withChild(ImmutableNodes.leafNode(AUGMENT_INT_Q, AUGMENT_INT_VALUE))
200 final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = codecContext.fromNormalizedNode(BI_TOP_PATH,
201 topNormalizedWithAugments);
202 Map<Class<? extends Augmentation<Top>>, Augmentation<Top>> augments = new HashMap<>();
203 augments.put(Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build());
204 augments.put(Top2.class, new Top2Builder().setAugmentedInt(AUGMENT_INT_VALUE).build());
205 Top topWithAugments = topWithAugments(augments);
207 assertEquals(topWithAugments, entryWithAugments.getValue());
208 assertEquals(entryWithAugments.getValue(), topWithAugments);
210 augments = new HashMap<>();
211 augments.put(Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build());
212 augments.put(Top2.class, new Top2Builder().setAugmentedInt(999).build());
213 topWithAugments = topWithAugments(augments);
215 assertNotEquals(topWithAugments, entryWithAugments.getValue());
216 assertNotEquals(entryWithAugments.getValue(), topWithAugments);
219 private static ContainerNode getNormalizedTopWithAugments(final AugmentationNode... augChild) {
220 final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> builder = ImmutableContainerNodeBuilder.create();
222 for (AugmentationNode augmentationNode : augChild) {
223 builder.withChild(augmentationNode);
225 return builder.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
226 .withChild(mapNodeBuilder(TOP_LEVEL_LIST_QNAME).build()).build();
229 private static Top topWithAugments(
230 final Map<Class<? extends Augmentation<Top>>, ? extends Augmentation<Top>> augments) {
231 final TopBuilder topBuilder = new TopBuilder();
232 for (Entry<Class<? extends Augmentation<Top>>, ? extends Augmentation<Top>> augment : augments.entrySet()) {
233 topBuilder.addAugmentation(augment.getKey(), augment.getValue());
235 return topBuilder.setTopLevelList(Collections.emptyMap()).build();
239 public void listWithKeysToNormalized() {
240 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
241 BA_TOP_LEVEL_LIST, topLevelList(TOP_LEVEL_LIST_FOO_KEY));
242 final MapEntryNode topLevelListNormalized = ImmutableMapEntryNodeBuilder.create()
243 .withNodeIdentifier(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
244 TOP_LEVEL_LIST_FOO_KEY_VALUE))
245 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
247 assertEquals(topLevelListNormalized, entry.getValue());
251 public void listWithKeysFromNormalized() {
252 final MapEntryNode topLevelListNormalized = ImmutableMapEntryNodeBuilder.create()
253 .withNodeIdentifier(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
254 TOP_LEVEL_LIST_FOO_KEY_VALUE))
255 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
257 final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(
258 BI_TOP_LEVEL_LIST_FOO_PATH, topLevelListNormalized);
259 assertEquals(topLevelList(TOP_LEVEL_LIST_FOO_KEY), entry.getValue());
263 public void leafOnlyAugmentationToNormalized() {
264 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
265 BA_TREE_LEAF_ONLY, new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build());
266 final Set<QName> augmentationChildren = new HashSet<>();
267 augmentationChildren.add(SIMPLE_VALUE_QNAME);
268 final AugmentationNode augmentationNode = ImmutableAugmentationNodeBuilder.create()
269 .withNodeIdentifier(new AugmentationIdentifier(augmentationChildren))
270 .withChild(leafNode(SIMPLE_VALUE_QNAME, "simpleValue"))
272 assertEquals(augmentationNode, entry.getValue());
276 public void leafOnlyAugmentationFromNormalized() {
277 final Set<QName> augmentationChildren = new HashSet<>();
278 augmentationChildren.add(SIMPLE_VALUE_QNAME);
279 final AugmentationNode augmentationNode = ImmutableAugmentationNodeBuilder.create()
280 .withNodeIdentifier(new AugmentationIdentifier(augmentationChildren))
281 .withChild(leafNode(SIMPLE_VALUE_QNAME, "simpleValue"))
283 final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(
284 BI_TOP_LEVEL_LIST_FOO_PATH.node(new AugmentationIdentifier(augmentationChildren)),
286 assertEquals(new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build(), entry.getValue());
290 public void orderedleafListToNormalized() {
291 List<String> topLevelLeafList = new ArrayList<>();
292 topLevelLeafList.add("foo");
293 Top top = new TopBuilder().setTopLevelOrderedLeafList(topLevelLeafList).build();
295 Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
296 InstanceIdentifier.create(Top.class), top);
297 ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
298 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
299 .withChild(ImmutableOrderedLeafSetNodeBuilder.create()
300 .withNodeIdentifier(new NodeIdentifier(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
302 ImmutableLeafSetEntryNodeBuilder.create()
303 .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME,
309 assertEquals(containerNode, entry.getValue());
313 public void leafListToNormalized() {
314 final List<String> topLevelLeafList = new ArrayList<>();
315 topLevelLeafList.add("foo");
316 final Top top = new TopBuilder().setTopLevelLeafList(topLevelLeafList).build();
318 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
319 InstanceIdentifier.create(Top.class), top);
320 final ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
321 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
322 .withChild(ImmutableLeafSetNodeBuilder.create()
323 .withNodeIdentifier(new NodeIdentifier(TOP_LEVEL_LEAF_LIST_QNAME))
325 ImmutableLeafSetEntryNodeBuilder.create()
326 .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_LEAF_LIST_QNAME, "foo"))
331 assertEquals(containerNode, entry.getValue());
335 public void leafListFromNormalized() {
336 final ContainerNode topWithLeafList = ImmutableContainerNodeBuilder.create()
337 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
338 .withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(
339 TOP_LEVEL_LEAF_LIST_QNAME))
340 .withChild(ImmutableLeafSetEntryNodeBuilder.create()
341 .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_LEAF_LIST_QNAME, "foo"))
342 .withValue("foo").build()).build())
344 final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_TOP_PATH,
346 final List<String> topLevelLeafList = new ArrayList<>();
347 topLevelLeafList.add("foo");
348 final Top top = new TopBuilder().setTopLevelLeafList(topLevelLeafList).build();
349 assertEquals(top, entry.getValue());
353 public void orderedLeafListFromNormalized() {
354 ContainerNode topWithLeafList = ImmutableContainerNodeBuilder.create()
355 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
356 .withChild(ImmutableOrderedLeafSetNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(
357 TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
358 .withChild(ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
359 new NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME, "foo")).withValue("foo").build())
362 Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_TOP_PATH, topWithLeafList);
363 List<String> topLevelLeafList = new ArrayList<>();
364 topLevelLeafList.add("foo");
365 Top top = new TopBuilder().setTopLevelOrderedLeafList(topLevelLeafList).build();
366 assertEquals(top, entry.getValue());
370 public void choiceToNormalized() {
371 final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder()
372 .setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
373 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
374 InstanceIdentifier.create(ChoiceContainer.class), choiceContainerBA);
375 final ContainerNode choiceContainer = ImmutableContainerNodeBuilder.create()
376 .withNodeIdentifier(new NodeIdentifier(CHOICE_CONTAINER_QNAME))
377 .withChild(ImmutableChoiceNodeBuilder.create()
378 .withNodeIdentifier(new NodeIdentifier(CHOICE_IDENTIFIER_QNAME))
379 .withChild(ImmutableContainerNodeBuilder.create()
380 .withNodeIdentifier(new NodeIdentifier(EXTENDED_ID_QNAME))
381 .withChild(leafNode(CHOICE_IDENTIFIER_ID_QNAME, "identifier_value")).build()).build())
383 assertEquals(choiceContainer, entry.getValue());
387 public void test4798() {
388 final QName containerIdentifierQname4798 = Root.QNAME;
389 final QName choiceIdentifierQname4798 = QName.create(containerIdentifierQname4798, "bug4798-choice");
390 final QName nestedListQname4798 = QName.create(containerIdentifierQname4798, "list-in-case");
391 final QName nestedListKeyQname4798 = QName.create(containerIdentifierQname4798, "test-leaf");
392 final QName nestedContainerValidQname = QName.create(containerIdentifierQname4798, "case-b-container");
393 final QName nestedContainerOuterQname = QName.create(containerIdentifierQname4798, "outer-container");
394 final QName nestedContainerLeafOuterQname = QName.create(containerIdentifierQname4798,
395 "leaf-in-outer-container");
397 final YangInstanceIdentifier yangInstanceIdentifierOuter = YangInstanceIdentifier.of(
398 containerIdentifierQname4798);
399 final ContainerNode containerNodeOuter = ImmutableContainerNodeBuilder.create()
400 .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
401 .withChild(ImmutableContainerNodeBuilder.create()
402 .withNodeIdentifier(new NodeIdentifier(nestedContainerOuterQname))
403 .withChild(leafNode(nestedContainerLeafOuterQname, "bar"))
406 final Entry<InstanceIdentifier<?>, DataObject> entryContainer = codecContext.fromNormalizedNode(
407 yangInstanceIdentifierOuter, containerNodeOuter);
408 assertNotNull(entryContainer.getValue());
409 assertNotNull(entryContainer.getKey());
411 final NodeIdentifierWithPredicates nodeIdentifierWithPredicates4798 =
412 NodeIdentifierWithPredicates.of(nestedListQname4798, nestedListKeyQname4798, "foo");
413 final YangInstanceIdentifier yangInstanceIdentifier4798 = YangInstanceIdentifier.of(
414 containerIdentifierQname4798)
415 .node(choiceIdentifierQname4798)
416 .node(nestedListQname4798)
417 .node(nodeIdentifierWithPredicates4798);
419 final YangInstanceIdentifier yangInstanceIdentifierValid = YangInstanceIdentifier.of(
420 containerIdentifierQname4798)
421 .node(choiceIdentifierQname4798)
422 .node(nestedContainerValidQname)
423 .node(nestedListQname4798)
424 .node(nodeIdentifierWithPredicates4798);
425 final ContainerNode containerNodeValid = ImmutableContainerNodeBuilder.create()
426 .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
427 .withChild(ImmutableChoiceNodeBuilder.create()
428 .withNodeIdentifier(new NodeIdentifier(choiceIdentifierQname4798))
429 .withChild(ImmutableContainerNodeBuilder.create()
430 .withNodeIdentifier(new NodeIdentifier(nestedContainerValidQname))
431 .withChild(ImmutableMapNodeBuilder.create()
432 .withNodeIdentifier(new NodeIdentifier(nestedListQname4798))
433 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "foo"))
434 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "bar"))
440 codecContext.fromNormalizedNode(yangInstanceIdentifierValid, containerNodeValid);
441 fail("Incorect YangInstanceIdentifier should fail");
442 } catch (IllegalStateException e) {
446 final ContainerNode containerNode4798 = ImmutableContainerNodeBuilder.create()
447 .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
448 .withChild(ImmutableChoiceNodeBuilder.create()
449 .withNodeIdentifier(new NodeIdentifier(choiceIdentifierQname4798))
450 .withChild(ImmutableMapNodeBuilder.create()
451 .withNodeIdentifier(new NodeIdentifier(nestedListQname4798))
452 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "foo"))
453 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "bar"))
458 codecContext.fromNormalizedNode(yangInstanceIdentifier4798, containerNode4798);
459 fail("Incorect YangInstanceIdentifier should fail");
460 } catch (IllegalStateException e) {
466 public void choiceFromNormalized() {
467 final ContainerNode choiceContainerBI = ImmutableContainerNodeBuilder.create()
468 .withNodeIdentifier(new NodeIdentifier(CHOICE_CONTAINER_QNAME))
469 .withChild(ImmutableChoiceNodeBuilder.create()
470 .withNodeIdentifier(new NodeIdentifier(CHOICE_IDENTIFIER_QNAME))
471 .withChild(ImmutableContainerNodeBuilder.create()
472 .withNodeIdentifier(new NodeIdentifier(EXTENDED_ID_QNAME))
473 .withChild(leafNode(CHOICE_IDENTIFIER_ID_QNAME, "identifier_value")).build()).build())
475 final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_CHOICE_CONTAINER_PATH,
477 final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder()
478 .setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
479 assertEquals(choiceContainerBA, entry.getValue());
483 public void orderedLisToNormalized() {
484 final InstanceIdentifier<TopLevelList> ii = BA_TOP_LEVEL_LIST;
485 final List<NestedList> nestedLists = new ArrayList<>();
486 nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("foo")).build());
487 nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("bar")).build());
488 final TopLevelList topLevelList = new TopLevelListBuilder().withKey(TOP_LEVEL_LIST_FOO_KEY).setNestedList(
489 nestedLists).build();
490 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(ii,
492 final MapEntryNode foo = mapEntryBuilder().withNodeIdentifier(NodeIdentifierWithPredicates.of(
493 TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
494 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
495 .withChild(ImmutableOrderedMapNodeBuilder.create()
496 .withNodeIdentifier(new NodeIdentifier(NESTED_LIST_QNAME))
497 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
498 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar")).build()).build();
499 assertEquals(foo, entry.getValue());
503 public void orderedLisFromNormalized() {
504 final MapEntryNode foo = mapEntryBuilder().withNodeIdentifier(NodeIdentifierWithPredicates.of(
505 TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
506 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
507 .withChild(ImmutableOrderedMapNodeBuilder.create()
508 .withNodeIdentifier(new NodeIdentifier(NESTED_LIST_QNAME))
509 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
510 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar")).build()).build();
511 final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(
512 BI_TOP_LEVEL_LIST_FOO_PATH, foo);
513 final List<NestedList> nestedLists = new ArrayList<>();
514 nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("foo")).build());
515 nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("bar")).build());
516 final TopLevelList topLevelList = new TopLevelListBuilder().withKey(TOP_LEVEL_LIST_FOO_KEY).setNestedList(
517 nestedLists).build();
518 assertEquals(topLevelList, entry.getValue());
522 public void augmentMultipleChoices() {
523 final QName augmentChoice1QName = AugmentChoice1.QNAME;
524 final QName augmentChoice2QName = QName.create(augmentChoice1QName, "augment-choice2");
525 final QName containerQName = QName.create(augmentChoice1QName, "case11-choice-case-container");
526 final QName leafQName = QName.create(augmentChoice1QName, "case11-choice-case-leaf");
528 final AugmentationIdentifier aug1Id = new AugmentationIdentifier(Collections.singleton(augmentChoice1QName));
529 final AugmentationIdentifier aug2Id = new AugmentationIdentifier(Collections.singleton(augmentChoice2QName));
530 final NodeIdentifier augmentChoice1Id = new NodeIdentifier(augmentChoice1QName);
531 final NodeIdentifier augmentChoice2Id = new NodeIdentifier(augmentChoice2QName);
532 final NodeIdentifier containerId = new NodeIdentifier(containerQName);
534 final TopBuilder tBuilder = new TopBuilder();
535 final TopChoiceAugment1Builder tca1Builder = new TopChoiceAugment1Builder();
536 final Case1Builder c1Builder = new Case1Builder();
537 final TopChoiceAugment2Builder tca2Builder = new TopChoiceAugment2Builder();
538 final Case11Builder c11Builder = new Case11Builder();
539 final Case11ChoiceCaseContainerBuilder cccc1Builder = new Case11ChoiceCaseContainerBuilder();
540 cccc1Builder.setCase11ChoiceCaseLeaf("leaf-value");
541 c11Builder.setCase11ChoiceCaseContainer(cccc1Builder.build());
542 tca2Builder.setAugmentChoice2(c11Builder.build());
543 c1Builder.addAugmentation(TopChoiceAugment2.class, tca2Builder.build());
544 tca1Builder.setAugmentChoice1(c1Builder.build());
545 tBuilder.addAugmentation(TopChoiceAugment1.class, tca1Builder.build());
546 final Top top = tBuilder.build();
548 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> biResult = codecContext.toNormalizedNode(
549 InstanceIdentifier.create(Top.class), top);
551 final NormalizedNode<?, ?> topNormalized =
552 containerBuilder().withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
553 .withChild(augmentationBuilder().withNodeIdentifier(aug1Id)
554 .withChild(choiceBuilder().withNodeIdentifier(augmentChoice1Id)
555 .withChild(augmentationBuilder().withNodeIdentifier(aug2Id)
556 .withChild(choiceBuilder().withNodeIdentifier(augmentChoice2Id)
557 .withChild(containerBuilder().withNodeIdentifier(containerId)
558 .withChild(leafNode(leafQName, "leaf-value"))
565 assertEquals(BI_TOP_PATH, biResult.getKey());
566 assertEquals(topNormalized, biResult.getValue());
568 final Entry<InstanceIdentifier<?>, DataObject> baResult = codecContext.fromNormalizedNode(BI_TOP_PATH,
571 assertEquals(InstanceIdentifier.create(Top.class), baResult.getKey());
572 assertEquals(top, baResult.getValue());