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.test;
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 com.google.common.collect.Maps;
26 import java.util.ArrayList;
27 import java.util.Collections;
28 import java.util.HashSet;
29 import java.util.List;
31 import java.util.Map.Entry;
33 import javassist.ClassPool;
34 import org.junit.Before;
35 import org.junit.Test;
36 import org.opendaylight.mdsal.binding.dom.codec.gen.impl.StreamWriterGenerator;
37 import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
38 import org.opendaylight.mdsal.binding.generator.util.JavassistUtils;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment1;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment1Builder;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment2;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment2Builder;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugment;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeLeafOnlyAugment;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeLeafOnlyAugmentBuilder;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.AugmentChoice1;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.augment.choice1.Case1Builder;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.augment.choice1.case1.augment.choice2.Case11Builder;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.augment.choice1.case1.augment.choice2.case11.Case11ChoiceCaseContainerBuilder;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.ChoiceContainer;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.ChoiceContainerBuilder;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top1;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top1Builder;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top2;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top2Builder;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.TopBuilder;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.choice.identifier.ExtendedBuilder;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.choice.identifier.extended.ExtendedIdBuilder;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelList;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListBuilder;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListKey;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.top.level.list.NestedList;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.top.level.list.NestedListBuilder;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.top.level.list.NestedListKey;
66 import org.opendaylight.yang.gen.v1.urn.test.foo4798.rev160101.Root;
67 import org.opendaylight.yangtools.yang.binding.Augmentation;
68 import org.opendaylight.yangtools.yang.binding.DataObject;
69 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
70 import org.opendaylight.yangtools.yang.common.QName;
71 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
72 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
73 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
74 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
75 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
76 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
77 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
78 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
79 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
80 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
81 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
82 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAugmentationNodeBuilder;
83 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableChoiceNodeBuilder;
84 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
85 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
86 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
87 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
88 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
89 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedLeafSetNodeBuilder;
90 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedMapNodeBuilder;
92 public class NormalizedNodeSerializeDeserializeTest extends AbstractBindingRuntimeTest {
94 public static final String TOP_LEVEL_LIST_FOO_KEY_VALUE = "foo";
95 public static final TopLevelListKey TOP_LEVEL_LIST_FOO_KEY = new TopLevelListKey(TOP_LEVEL_LIST_FOO_KEY_VALUE);
97 public static final QName TOP_QNAME = Top.QNAME;
98 public static final QName TOP_LEVEL_LIST_QNAME = QName.create(TOP_QNAME, "top-level-list");
99 public static final QName TOP_LEVEL_LIST_KEY_QNAME = QName.create(TOP_QNAME, "name");
100 public static final QName TOP_LEVEL_LEAF_LIST_QNAME = QName.create(TOP_QNAME, "top-level-leaf-list");
101 public static final QName TOP_LEVEL_ORDERED_LEAF_LIST_QNAME = QName.create(TOP_QNAME,
102 "top-level-ordered-leaf-list");
103 public static final QName NESTED_LIST_QNAME = QName.create(TOP_QNAME, "nested-list");
104 public static final QName NESTED_LIST_KEY_QNAME = QName.create(TOP_QNAME, "name");
105 public static final QName CHOICE_CONTAINER_QNAME = ChoiceContainer.QNAME;
106 public static final QName CHOICE_IDENTIFIER_QNAME = QName.create(CHOICE_CONTAINER_QNAME, "identifier");
107 public static final QName CHOICE_IDENTIFIER_ID_QNAME = QName.create(CHOICE_CONTAINER_QNAME, "id");
108 public static final QName SIMPLE_ID_QNAME = QName.create(CHOICE_CONTAINER_QNAME, "simple-id");
109 public static final QName EXTENDED_ID_QNAME = QName.create(CHOICE_CONTAINER_QNAME, "extended-id");
110 private static final QName SIMPLE_VALUE_QNAME = QName.create(TreeComplexUsesAugment.QNAME, "simple-value");
112 private static final InstanceIdentifier<TopLevelList> BA_TOP_LEVEL_LIST = InstanceIdentifier
113 .builder(Top.class).child(TopLevelList.class, TOP_LEVEL_LIST_FOO_KEY).build();
114 private static final InstanceIdentifier<TreeLeafOnlyAugment> BA_TREE_LEAF_ONLY =
115 BA_TOP_LEVEL_LIST.augmentation(TreeLeafOnlyAugment.class);
116 private static final InstanceIdentifier<TreeComplexUsesAugment> BA_TREE_COMPLEX_USES =
117 BA_TOP_LEVEL_LIST.augmentation(TreeComplexUsesAugment.class);
119 public static final YangInstanceIdentifier BI_TOP_PATH = YangInstanceIdentifier.of(TOP_QNAME);
120 public static final YangInstanceIdentifier BI_TOP_LEVEL_LIST_PATH = BI_TOP_PATH.node(TOP_LEVEL_LIST_QNAME);
121 public static final YangInstanceIdentifier BI_TOP_LEVEL_LIST_FOO_PATH = BI_TOP_LEVEL_LIST_PATH
122 .node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(TOP_LEVEL_LIST_QNAME,
123 TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE));
124 public static final YangInstanceIdentifier BI_CHOICE_CONTAINER_PATH = YangInstanceIdentifier.of(
125 CHOICE_CONTAINER_QNAME);
127 private BindingNormalizedNodeCodecRegistry registry;
131 public void setup() {
133 final JavassistUtils utils = JavassistUtils.forClassPool(ClassPool.getDefault());
134 registry = new BindingNormalizedNodeCodecRegistry(StreamWriterGenerator.create(utils));
135 registry.onBindingRuntimeContextUpdated(getRuntimeContext());
139 public void containerToNormalized() {
140 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
141 InstanceIdentifier.create(Top.class), top());
142 final ContainerNode topNormalized = getEmptyTop();
143 assertEquals(topNormalized, entry.getValue());
147 public void containerFromNormalized() {
148 final ContainerNode topNormalized = getEmptyTop();
149 final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topNormalized);
150 assertEquals(top(), entry.getValue());
153 private static ContainerNode getEmptyTop() {
154 return ImmutableContainerNodeBuilder.create()
155 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
156 .withChild(mapNodeBuilder(TOP_LEVEL_LIST_QNAME).build()).build();
159 private static final QName AGUMENT_STRING_Q = QName.create(TOP_QNAME, "augmented-string");
160 private static final String AUGMENT_STRING_VALUE = "testingEquals";
161 private static final QName AUGMENT_INT_Q = QName.create(TOP_QNAME, "augmented-int");
162 private static final int AUGMENT_INT_VALUE = 44;
165 public void equalsWithAugment() {
166 final ContainerNode topNormalizedWithAugments = getNormalizedTopWithAugments(
167 augmentationBuilder()
168 .withNodeIdentifier(new AugmentationIdentifier(singleton(AGUMENT_STRING_Q)))
169 .withChild(ImmutableNodes.leafNode(AGUMENT_STRING_Q, AUGMENT_STRING_VALUE))
171 final ContainerNode topNormalized = getEmptyTop();
173 final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topNormalized);
174 final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = registry.fromNormalizedNode(BI_TOP_PATH,
175 topNormalizedWithAugments);
177 // Equals on other with no augmentation should be false
178 assertNotEquals(top(), entryWithAugments.getValue());
179 // Equals on other(reversed) with no augmentation should be false
180 assertNotEquals(entryWithAugments.getValue(), top());
181 // Equals on other(lazy) with no augmentation should be false
182 assertNotEquals(entry.getValue(), entryWithAugments.getValue());
183 // Equals on other(lazy, reversed) with no augmentation should be false
184 assertNotEquals(entryWithAugments.getValue(), entry.getValue());
186 final Top topWithAugments = topWithAugments(Collections.<Class<? extends Augmentation<Top>>, Augmentation<Top>>
187 singletonMap(Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build()));
188 // Equals other with same augment should be true
189 assertEquals(topWithAugments, entryWithAugments.getValue());
190 // Equals other with same augment should be true
191 assertEquals(entryWithAugments.getValue(), topWithAugments);
192 // Equals on self should be true
193 assertEquals(entryWithAugments.getValue(), entryWithAugments.getValue());
195 final Top topWithAugmentsDiffValue = topWithAugments(
196 Collections.<Class<? extends Augmentation<Top>>, Augmentation<Top>>singletonMap(Top1.class,
197 new Top1Builder().setAugmentedString("differentValue").build()));
198 assertNotEquals(topWithAugmentsDiffValue, entryWithAugments.getValue());
199 assertNotEquals(entryWithAugments.getValue(), topWithAugmentsDiffValue);
203 public void equalsWithMultipleAugments() {
204 final ContainerNode topNormalizedWithAugments = getNormalizedTopWithAugments(
205 augmentationBuilder()
206 .withNodeIdentifier(new AugmentationIdentifier(singleton(AGUMENT_STRING_Q)))
207 .withChild(ImmutableNodes.leafNode(AGUMENT_STRING_Q, AUGMENT_STRING_VALUE))
209 augmentationBuilder()
210 .withNodeIdentifier(new AugmentationIdentifier(singleton(AUGMENT_INT_Q)))
211 .withChild(ImmutableNodes.leafNode(AUGMENT_INT_Q, AUGMENT_INT_VALUE))
214 final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = registry.fromNormalizedNode(BI_TOP_PATH,
215 topNormalizedWithAugments);
216 Map<Class<? extends Augmentation<Top>>, Augmentation<Top>> augments = Maps.newHashMap();
217 augments.put(Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build());
218 augments.put(Top2.class, new Top2Builder().setAugmentedInt(AUGMENT_INT_VALUE).build());
219 Top topWithAugments = topWithAugments(augments);
221 assertEquals(topWithAugments, entryWithAugments.getValue());
222 assertEquals(entryWithAugments.getValue(), topWithAugments);
224 augments = Maps.newHashMap();
225 augments.put(Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build());
226 augments.put(Top2.class, new Top2Builder().setAugmentedInt(999).build());
227 topWithAugments = topWithAugments(augments);
229 assertNotEquals(topWithAugments, entryWithAugments.getValue());
230 assertNotEquals(entryWithAugments.getValue(), topWithAugments);
233 private static ContainerNode getNormalizedTopWithAugments(final AugmentationNode... augChild) {
234 final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder =
235 ImmutableContainerNodeBuilder.create();
237 for (AugmentationNode augmentationNode : augChild) {
238 builder.withChild(augmentationNode);
240 return builder.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
241 .withChild(mapNodeBuilder(TOP_LEVEL_LIST_QNAME).build()).build();
244 private static Top topWithAugments(
245 final Map<Class<? extends Augmentation<Top>>, ? extends Augmentation<Top>> augments) {
246 final TopBuilder topBuilder = new TopBuilder();
247 for (Entry<Class<? extends Augmentation<Top>>, ? extends Augmentation<Top>> augment : augments.entrySet()) {
248 topBuilder.addAugmentation(augment.getKey(), augment.getValue());
250 return topBuilder.setTopLevelList(Collections.<TopLevelList>emptyList()).build();
254 public void listWithKeysToNormalized() {
255 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(BA_TOP_LEVEL_LIST,
256 topLevelList(TOP_LEVEL_LIST_FOO_KEY));
257 final MapEntryNode topLevelListNormalized = ImmutableMapEntryNodeBuilder.create()
258 .withNodeIdentifier(new NodeIdentifierWithPredicates(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
259 TOP_LEVEL_LIST_FOO_KEY_VALUE))
260 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
262 assertEquals(topLevelListNormalized, entry.getValue());
266 public void listWithKeysFromNormalized() {
267 final MapEntryNode topLevelListNormalized = ImmutableMapEntryNodeBuilder.create()
268 .withNodeIdentifier(new NodeIdentifierWithPredicates(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
269 TOP_LEVEL_LIST_FOO_KEY_VALUE))
270 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
272 final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH,
273 topLevelListNormalized);
274 assertEquals(topLevelList(TOP_LEVEL_LIST_FOO_KEY), entry.getValue());
278 public void leafOnlyAugmentationToNormalized() {
279 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(BA_TREE_LEAF_ONLY,
280 new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build());
281 final Set<QName> augmentationChildren = new HashSet<>();
282 augmentationChildren.add(SIMPLE_VALUE_QNAME);
283 final AugmentationNode augmentationNode = ImmutableAugmentationNodeBuilder.create()
284 .withNodeIdentifier(new AugmentationIdentifier(augmentationChildren))
285 .withChild(leafNode(SIMPLE_VALUE_QNAME, "simpleValue"))
287 assertEquals(augmentationNode, entry.getValue());
291 public void leafOnlyAugmentationFromNormalized() {
292 final Set<QName> augmentationChildren = new HashSet<>();
293 augmentationChildren.add(SIMPLE_VALUE_QNAME);
294 final AugmentationNode augmentationNode = ImmutableAugmentationNodeBuilder.create()
295 .withNodeIdentifier(new AugmentationIdentifier(augmentationChildren))
296 .withChild(leafNode(SIMPLE_VALUE_QNAME, "simpleValue"))
298 final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(
299 BI_TOP_LEVEL_LIST_FOO_PATH.node(new AugmentationIdentifier(augmentationChildren)),
301 assertEquals(new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build(), entry.getValue());
305 public void orderedleafListToNormalized() {
306 List<String> topLevelLeafList = new ArrayList<>();
307 topLevelLeafList.add("foo");
308 Top top = new TopBuilder().setTopLevelOrderedLeafList(topLevelLeafList).build();
310 Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
311 InstanceIdentifier.create(Top.class), top);
312 ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
313 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
314 .withChild(ImmutableOrderedLeafSetNodeBuilder.create()
315 .withNodeIdentifier(new NodeIdentifier(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
317 ImmutableLeafSetEntryNodeBuilder.create()
318 .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME,
324 assertEquals(containerNode, entry.getValue());
328 public void leafListToNormalized() {
329 final List<String> topLevelLeafList = new ArrayList<>();
330 topLevelLeafList.add("foo");
331 final Top top = new TopBuilder().setTopLevelLeafList(topLevelLeafList).build();
333 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
334 InstanceIdentifier.create(Top.class), top);
335 final ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
336 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
337 .withChild(ImmutableLeafSetNodeBuilder.create()
338 .withNodeIdentifier(new NodeIdentifier(TOP_LEVEL_LEAF_LIST_QNAME))
340 ImmutableLeafSetEntryNodeBuilder.create()
341 .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_LEAF_LIST_QNAME, "foo"))
346 assertEquals(containerNode, entry.getValue());
350 public void leafListFromNormalized() {
351 final ContainerNode topWithLeafList = ImmutableContainerNodeBuilder.create()
352 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
353 .withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(
354 TOP_LEVEL_LEAF_LIST_QNAME))
355 .withChild(ImmutableLeafSetEntryNodeBuilder.create()
356 .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_LEAF_LIST_QNAME, "foo"))
357 .withValue("foo").build()).build())
359 final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH,
361 final List<String> topLevelLeafList = new ArrayList<>();
362 topLevelLeafList.add("foo");
363 final Top top = new TopBuilder().setTopLevelLeafList(topLevelLeafList).build();
364 assertEquals(top, entry.getValue());
368 public void orderedLeafListFromNormalized() {
369 ContainerNode topWithLeafList = ImmutableContainerNodeBuilder.create()
370 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
371 .withChild(ImmutableOrderedLeafSetNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(
372 TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
373 .withChild(ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
374 new NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME, "foo")).withValue("foo").build())
377 Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topWithLeafList);
378 List<String> topLevelLeafList = new ArrayList<>();
379 topLevelLeafList.add("foo");
380 Top top = new TopBuilder().setTopLevelOrderedLeafList(topLevelLeafList).build();
381 assertEquals(top, entry.getValue());
385 public void choiceToNormalized() {
386 final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder()
387 .setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
388 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
389 InstanceIdentifier.create(ChoiceContainer.class), choiceContainerBA);
390 final ContainerNode choiceContainer = ImmutableContainerNodeBuilder.create()
391 .withNodeIdentifier(new NodeIdentifier(CHOICE_CONTAINER_QNAME))
392 .withChild(ImmutableChoiceNodeBuilder.create()
393 .withNodeIdentifier(new NodeIdentifier(CHOICE_IDENTIFIER_QNAME))
394 .withChild(ImmutableContainerNodeBuilder.create()
395 .withNodeIdentifier(new NodeIdentifier(EXTENDED_ID_QNAME))
396 .withChild(leafNode(CHOICE_IDENTIFIER_ID_QNAME, "identifier_value")).build()).build())
398 assertEquals(choiceContainer, entry.getValue());
402 public void test4798() {
403 final QName containerIdentifierQname4798 = Root.QNAME;
404 final QName choiceIdentifierQname4798 = QName.create(containerIdentifierQname4798, "bug4798-choice");
405 final QName nestedListQname4798 = QName.create(containerIdentifierQname4798, "list-in-case");
406 final QName nestedListKeyQname4798 = QName.create(containerIdentifierQname4798, "test-leaf");
407 final QName nestedContainerValidQname = QName.create(containerIdentifierQname4798, "case-b-container");
408 final QName nestedContainerOuterQname = QName.create(containerIdentifierQname4798, "outer-container");
409 final QName nestedContainerLeafOuterQname = QName.create(containerIdentifierQname4798,
410 "leaf-in-outer-container");
412 final YangInstanceIdentifier yangInstanceIdentifierOuter = YangInstanceIdentifier.of(
413 containerIdentifierQname4798);
414 final ContainerNode containerNodeOuter = ImmutableContainerNodeBuilder.create()
415 .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
416 .withChild(ImmutableContainerNodeBuilder.create()
417 .withNodeIdentifier(new NodeIdentifier(nestedContainerOuterQname))
418 .withChild(leafNode(nestedContainerLeafOuterQname, "bar"))
421 final Entry<InstanceIdentifier<?>, DataObject> entryContainer = registry.fromNormalizedNode(
422 yangInstanceIdentifierOuter, containerNodeOuter);
423 assertNotNull(entryContainer.getValue());
424 assertNotNull(entryContainer.getKey());
426 final NodeIdentifierWithPredicates nodeIdentifierWithPredicates4798 =
427 new NodeIdentifierWithPredicates(nestedListQname4798, nestedListKeyQname4798, "foo");
428 final YangInstanceIdentifier yangInstanceIdentifier4798 = YangInstanceIdentifier.of(
429 containerIdentifierQname4798)
430 .node(choiceIdentifierQname4798)
431 .node(nestedListQname4798)
432 .node(nodeIdentifierWithPredicates4798);
434 final YangInstanceIdentifier yangInstanceIdentifierValid = YangInstanceIdentifier.of(
435 containerIdentifierQname4798)
436 .node(choiceIdentifierQname4798)
437 .node(nestedContainerValidQname)
438 .node(nestedListQname4798)
439 .node(nodeIdentifierWithPredicates4798);
440 final ContainerNode containerNodeValid = ImmutableContainerNodeBuilder.create()
441 .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
442 .withChild(ImmutableChoiceNodeBuilder.create()
443 .withNodeIdentifier(new NodeIdentifier(choiceIdentifierQname4798))
444 .withChild(ImmutableContainerNodeBuilder.create()
445 .withNodeIdentifier(new NodeIdentifier(nestedContainerValidQname))
446 .withChild(ImmutableMapNodeBuilder.create()
447 .withNodeIdentifier(new NodeIdentifier(nestedListQname4798))
448 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "foo"))
449 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "bar"))
455 registry.fromNormalizedNode(yangInstanceIdentifierValid, containerNodeValid);
456 fail("Incorect YangInstanceIdentifier should fail");
457 } catch (IllegalStateException e) {
461 final ContainerNode containerNode4798 = ImmutableContainerNodeBuilder.create()
462 .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
463 .withChild(ImmutableChoiceNodeBuilder.create()
464 .withNodeIdentifier(new NodeIdentifier(choiceIdentifierQname4798))
465 .withChild(ImmutableMapNodeBuilder.create()
466 .withNodeIdentifier(new NodeIdentifier(nestedListQname4798))
467 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "foo"))
468 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "bar"))
473 registry.fromNormalizedNode(yangInstanceIdentifier4798, containerNode4798);
474 fail("Incorect YangInstanceIdentifier should fail");
475 } catch (IllegalStateException e) {
481 public void choiceFromNormalized() {
482 final ContainerNode choiceContainerBI = ImmutableContainerNodeBuilder.create()
483 .withNodeIdentifier(new NodeIdentifier(CHOICE_CONTAINER_QNAME))
484 .withChild(ImmutableChoiceNodeBuilder.create()
485 .withNodeIdentifier(new NodeIdentifier(CHOICE_IDENTIFIER_QNAME))
486 .withChild(ImmutableContainerNodeBuilder.create()
487 .withNodeIdentifier(new NodeIdentifier(EXTENDED_ID_QNAME))
488 .withChild(leafNode(CHOICE_IDENTIFIER_ID_QNAME, "identifier_value")).build()).build())
490 final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_CHOICE_CONTAINER_PATH,
492 final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder()
493 .setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
494 assertEquals(choiceContainerBA, entry.getValue());
498 public void orderedLisToNormalized() {
499 final InstanceIdentifier<TopLevelList> ii = BA_TOP_LEVEL_LIST;
500 final List<NestedList> nestedLists = new ArrayList<>();
501 nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("foo")).build());
502 nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("bar")).build());
503 final TopLevelList topLevelList = new TopLevelListBuilder().withKey(TOP_LEVEL_LIST_FOO_KEY).setNestedList(
504 nestedLists).build();
505 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(ii, topLevelList);
506 final MapEntryNode foo = mapEntryBuilder().withNodeIdentifier(new NodeIdentifierWithPredicates(
507 TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
508 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
509 .withChild(ImmutableOrderedMapNodeBuilder.create()
510 .withNodeIdentifier(new NodeIdentifier(NESTED_LIST_QNAME))
511 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
512 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar")).build()).build();
513 assertEquals(foo, entry.getValue());
517 public void orderedLisFromNormalized() {
518 final MapEntryNode foo = mapEntryBuilder().withNodeIdentifier(new NodeIdentifierWithPredicates(
519 TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
520 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
521 .withChild(ImmutableOrderedMapNodeBuilder.create()
522 .withNodeIdentifier(new NodeIdentifier(NESTED_LIST_QNAME))
523 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
524 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar")).build()).build();
525 final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH,
527 final List<NestedList> nestedLists = new ArrayList<>();
528 nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("foo")).build());
529 nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("bar")).build());
530 final TopLevelList topLevelList = new TopLevelListBuilder().withKey(TOP_LEVEL_LIST_FOO_KEY).setNestedList(
531 nestedLists).build();
532 assertEquals(topLevelList, entry.getValue());
536 public void augmentMultipleChoices() {
537 final QName augmentChoice1QName = AugmentChoice1.QNAME;
538 final QName augmentChoice2QName = QName.create(augmentChoice1QName, "augment-choice2");
539 final QName containerQName = QName.create(augmentChoice1QName, "case11-choice-case-container");
540 final QName leafQName = QName.create(augmentChoice1QName, "case11-choice-case-leaf");
542 final AugmentationIdentifier aug1Id = new AugmentationIdentifier(Collections.singleton(augmentChoice1QName));
543 final AugmentationIdentifier aug2Id = new AugmentationIdentifier(Collections.singleton(augmentChoice2QName));
544 final NodeIdentifier augmentChoice1Id = new NodeIdentifier(augmentChoice1QName);
545 final NodeIdentifier augmentChoice2Id = new NodeIdentifier(augmentChoice2QName);
546 final NodeIdentifier containerId = new NodeIdentifier(containerQName);
548 final TopBuilder tBuilder = new TopBuilder();
549 final TopChoiceAugment1Builder tca1Builder = new TopChoiceAugment1Builder();
550 final Case1Builder c1Builder = new Case1Builder();
551 final TopChoiceAugment2Builder tca2Builder = new TopChoiceAugment2Builder();
552 final Case11Builder c11Builder = new Case11Builder();
553 final Case11ChoiceCaseContainerBuilder cccc1Builder = new Case11ChoiceCaseContainerBuilder();
554 cccc1Builder.setCase11ChoiceCaseLeaf("leaf-value");
555 c11Builder.setCase11ChoiceCaseContainer(cccc1Builder.build());
556 tca2Builder.setAugmentChoice2(c11Builder.build());
557 c1Builder.addAugmentation(TopChoiceAugment2.class, tca2Builder.build());
558 tca1Builder.setAugmentChoice1(c1Builder.build());
559 tBuilder.addAugmentation(TopChoiceAugment1.class, tca1Builder.build());
560 final Top top = tBuilder.build();
562 final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> biResult = registry.toNormalizedNode(
563 InstanceIdentifier.create(Top.class), top);
565 final NormalizedNode<?, ?> topNormalized =
566 containerBuilder().withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
567 .withChild(augmentationBuilder().withNodeIdentifier(aug1Id)
568 .withChild(choiceBuilder().withNodeIdentifier(augmentChoice1Id)
569 .withChild(augmentationBuilder().withNodeIdentifier(aug2Id)
570 .withChild(choiceBuilder().withNodeIdentifier(augmentChoice2Id)
571 .withChild(containerBuilder().withNodeIdentifier(containerId)
572 .withChild(leafNode(leafQName, "leaf-value"))
579 assertEquals(BI_TOP_PATH, biResult.getKey());
580 assertEquals(topNormalized, biResult.getValue());
582 final Entry<InstanceIdentifier<?>, DataObject> baResult = registry.fromNormalizedNode(BI_TOP_PATH,
585 assertEquals(InstanceIdentifier.create(Top.class), baResult.getKey());
586 assertEquals(top, baResult.getValue());