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 org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertNotEquals;
12 import static org.junit.Assert.assertNotNull;
13 import static org.junit.Assert.assertThrows;
14 import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.top;
15 import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.topLevelList;
16 import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.choiceBuilder;
17 import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.containerBuilder;
18 import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.leafSetBuilder;
19 import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.leafSetEntryBuilder;
20 import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.mapBuilder;
21 import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.orderedLeafSetBuilder;
22 import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.orderedMapBuilder;
23 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.leafNode;
24 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntry;
25 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
26 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
28 import java.util.List;
30 import java.util.Map.Entry;
32 import org.junit.Test;
33 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment1Builder;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment2Builder;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugment;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeLeafOnlyAugmentBuilder;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.choice.augment1.AugmentChoice1;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.choice.augment1.augment.choice1.Case1Builder;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.choice.augment2.augment.choice2.Case11Builder;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.choice.augment2.augment.choice2.case11.Case11ChoiceCaseContainerBuilder;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.ChoiceContainer;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.ChoiceContainerBuilder;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top1;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top1Builder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top2;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top2Builder;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.TopBuilder;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.choice.identifier.ExtendedBuilder;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.choice.identifier.extended.ExtendedIdBuilder;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelList;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListBuilder;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListKey;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.top.level.list.NestedListBuilder;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.top.level.list.NestedListKey;
57 import org.opendaylight.yang.gen.v1.urn.test.foo4798.rev160101.Root;
58 import org.opendaylight.yangtools.yang.binding.Augmentation;
59 import org.opendaylight.yangtools.yang.binding.DataObject;
60 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
61 import org.opendaylight.yangtools.yang.common.QName;
62 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
63 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
64 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
65 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
66 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
67 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
69 public class NormalizedNodeSerializeDeserializeTest extends AbstractBindingCodecTest {
70 public static final String TOP_LEVEL_LIST_FOO_KEY_VALUE = "foo";
71 public static final TopLevelListKey TOP_LEVEL_LIST_FOO_KEY = new TopLevelListKey(TOP_LEVEL_LIST_FOO_KEY_VALUE);
73 public static final QName TOP_QNAME = Top.QNAME;
74 public static final QName TOP_LEVEL_LIST_QNAME = QName.create(TOP_QNAME, "top-level-list");
75 public static final QName TOP_LEVEL_LIST_KEY_QNAME = QName.create(TOP_QNAME, "name");
76 public static final QName TOP_LEVEL_LEAF_LIST_QNAME = QName.create(TOP_QNAME, "top-level-leaf-list");
77 public static final QName TOP_LEVEL_ORDERED_LEAF_LIST_QNAME = QName.create(TOP_QNAME,
78 "top-level-ordered-leaf-list");
79 public static final QName NESTED_LIST_QNAME = QName.create(TOP_QNAME, "nested-list");
80 public static final QName NESTED_LIST_KEY_QNAME = QName.create(TOP_QNAME, "name");
81 public static final QName CHOICE_CONTAINER_QNAME = ChoiceContainer.QNAME;
82 public static final QName CHOICE_IDENTIFIER_QNAME = QName.create(CHOICE_CONTAINER_QNAME, "identifier");
83 public static final QName CHOICE_IDENTIFIER_ID_QNAME = QName.create(CHOICE_CONTAINER_QNAME, "id");
84 public static final QName EXTENDED_ID_QNAME = QName.create(CHOICE_CONTAINER_QNAME, "extended-id");
85 private static final QName SIMPLE_VALUE_QNAME = QName.create(TreeComplexUsesAugment.QNAME, "simple-value");
87 private static final InstanceIdentifier<TopLevelList> BA_TOP_LEVEL_LIST = InstanceIdentifier
88 .builder(Top.class).child(TopLevelList.class, TOP_LEVEL_LIST_FOO_KEY).build();
90 public static final YangInstanceIdentifier BI_TOP_PATH = YangInstanceIdentifier.of(TOP_QNAME);
91 public static final YangInstanceIdentifier BI_TOP_LEVEL_LIST_PATH = BI_TOP_PATH.node(TOP_LEVEL_LIST_QNAME);
92 public static final YangInstanceIdentifier BI_TOP_LEVEL_LIST_FOO_PATH = BI_TOP_LEVEL_LIST_PATH
93 .node(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME,
94 TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE));
95 public static final YangInstanceIdentifier BI_CHOICE_CONTAINER_PATH = YangInstanceIdentifier.of(
96 CHOICE_CONTAINER_QNAME);
99 public void containerToNormalized() {
100 final var entry = (NodeResult) codecContext.toNormalizedNode(InstanceIdentifier.create(Top.class), top());
101 assertEquals(getEmptyTop(), entry.node());
105 public void containerFromNormalized() {
106 final var entry = codecContext.fromNormalizedNode(BI_TOP_PATH, getEmptyTop());
107 assertEquals(top(), entry.getValue());
110 private static ContainerNode getEmptyTop() {
111 return containerBuilder().withNodeIdentifier(new NodeIdentifier(TOP_QNAME)).build();
114 private static final QName AGUMENT_STRING_Q = QName.create(TOP_QNAME, "augmented-string");
115 private static final String AUGMENT_STRING_VALUE = "testingEquals";
116 private static final QName AUGMENT_INT_Q = QName.create(TOP_QNAME, "augmented-int");
117 private static final int AUGMENT_INT_VALUE = 44;
120 public void equalsWithAugment() {
121 final ContainerNode topNormalizedWithAugments =
122 getNormalizedTopWithChildren(leafNode(AGUMENT_STRING_Q, AUGMENT_STRING_VALUE));
123 final ContainerNode topNormalized = getEmptyTop();
125 final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_TOP_PATH,
127 final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = codecContext.fromNormalizedNode(BI_TOP_PATH,
128 topNormalizedWithAugments);
130 // Equals on other with no augmentation should be false
131 assertNotEquals(top(), entryWithAugments.getValue());
132 // Equals on other(reversed) with no augmentation should be false
133 assertNotEquals(entryWithAugments.getValue(), top());
134 // Equals on other(lazy) with no augmentation should be false
135 assertNotEquals(entry.getValue(), entryWithAugments.getValue());
136 // Equals on other(lazy, reversed) with no augmentation should be false
137 assertNotEquals(entryWithAugments.getValue(), entry.getValue());
139 final Top topWithAugments = topWithAugments(
140 Map.of(Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build()));
141 // Equals other with same augment should be true
142 assertEquals(topWithAugments, entryWithAugments.getValue());
143 // Equals other with same augment should be true
144 assertEquals(entryWithAugments.getValue(), topWithAugments);
145 // Equals on self should be true
146 assertEquals(entryWithAugments.getValue(), entryWithAugments.getValue());
148 final Top topWithAugmentsDiffValue = topWithAugments(
149 Map.of(Top1.class, new Top1Builder().setAugmentedString("differentValue").build()));
150 assertNotEquals(topWithAugmentsDiffValue, entryWithAugments.getValue());
151 assertNotEquals(entryWithAugments.getValue(), topWithAugmentsDiffValue);
155 public void equalsWithMultipleAugments() {
156 final ContainerNode topNormalizedWithAugments = getNormalizedTopWithChildren(
157 leafNode(AGUMENT_STRING_Q, AUGMENT_STRING_VALUE),
158 leafNode(AUGMENT_INT_Q, AUGMENT_INT_VALUE));
159 final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = codecContext.fromNormalizedNode(BI_TOP_PATH,
160 topNormalizedWithAugments);
161 Top topWithAugments = topWithAugments(Map.of(
162 Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build(),
163 Top2.class, new Top2Builder().setAugmentedInt(AUGMENT_INT_VALUE).build()));
165 assertEquals(topWithAugments, entryWithAugments.getValue());
166 assertEquals(entryWithAugments.getValue(), topWithAugments);
168 topWithAugments = topWithAugments(Map.of(
169 Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build(),
170 Top2.class, new Top2Builder().setAugmentedInt(999).build()));
172 assertNotEquals(topWithAugments, entryWithAugments.getValue());
173 assertNotEquals(entryWithAugments.getValue(), topWithAugments);
176 private static ContainerNode getNormalizedTopWithChildren(final DataContainerChild... children) {
177 final var builder = containerBuilder();
178 for (DataContainerChild child : children) {
179 builder.withChild(child);
181 return builder.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
182 .withChild(mapNodeBuilder(TOP_LEVEL_LIST_QNAME).build()).build();
185 private static Top topWithAugments(
186 final Map<Class<? extends Augmentation<Top>>, ? extends Augmentation<Top>> augments) {
187 final TopBuilder topBuilder = new TopBuilder();
188 for (Augmentation<Top> augment : augments.values()) {
189 topBuilder.addAugmentation(augment);
191 return topBuilder.build();
195 public void listWithKeysToNormalized() {
196 final var entry = (NodeResult) codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
197 topLevelList(TOP_LEVEL_LIST_FOO_KEY));
198 assertEquals(mapEntryBuilder()
199 .withNodeIdentifier(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
200 TOP_LEVEL_LIST_FOO_KEY_VALUE))
201 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
207 public void listWithKeysFromNormalized() {
208 final var entry = codecContext.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH, mapEntryBuilder()
209 .withNodeIdentifier(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
210 TOP_LEVEL_LIST_FOO_KEY_VALUE))
211 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
213 assertEquals(topLevelList(TOP_LEVEL_LIST_FOO_KEY), entry.getValue());
217 public void leafOnlyAugmentationToNormalized() {
218 final var entry = (NodeResult) codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
219 topLevelList(TOP_LEVEL_LIST_FOO_KEY,
220 new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build()));
221 assertEquals(mapEntryBuilder()
222 .withNodeIdentifier(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
223 TOP_LEVEL_LIST_FOO_KEY_VALUE))
224 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
225 .withChild(leafNode(SIMPLE_VALUE_QNAME, "simpleValue")) // augmentation child
231 public void leafOnlyAugmentationFromNormalized() {
232 final var entry = codecContext.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH, mapEntryBuilder()
233 .withNodeIdentifier(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
234 TOP_LEVEL_LIST_FOO_KEY_VALUE))
235 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
236 .withChild(leafNode(SIMPLE_VALUE_QNAME, "simpleValue")) // augmentation child
239 topLevelList(TOP_LEVEL_LIST_FOO_KEY,
240 new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build()),
245 public void orderedleafListToNormalized() {
246 final var entry = (NodeResult) codecContext.toNormalizedNode(InstanceIdentifier.create(Top.class),
247 new TopBuilder().setTopLevelOrderedLeafList(List.of("foo")).build());
248 assertEquals(containerBuilder()
249 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
250 .withChild(orderedLeafSetBuilder()
251 .withNodeIdentifier(new NodeIdentifier(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
252 .withChild(leafSetEntryBuilder()
253 .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME, "foo"))
262 public void leafListToNormalized() {
263 final var entry = (NodeResult) codecContext.toNormalizedNode(
264 InstanceIdentifier.create(Top.class), new TopBuilder().setTopLevelLeafList(Set.of("foo")).build());
265 assertEquals(containerBuilder()
266 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
267 .withChild(leafSetBuilder()
268 .withNodeIdentifier(new NodeIdentifier(TOP_LEVEL_LEAF_LIST_QNAME))
269 .withChild(leafSetEntryBuilder()
270 .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_LEAF_LIST_QNAME, "foo"))
279 public void leafListFromNormalized() {
280 final var entry = codecContext.fromNormalizedNode(BI_TOP_PATH, containerBuilder()
281 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
282 .withChild(leafSetBuilder()
283 .withNodeIdentifier(new NodeIdentifier(TOP_LEVEL_LEAF_LIST_QNAME))
284 .withChild(leafSetEntryBuilder()
285 .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_LEAF_LIST_QNAME, "foo"))
290 assertEquals(new TopBuilder().setTopLevelLeafList(Set.of("foo")).build(), entry.getValue());
294 public void orderedLeafListFromNormalized() {
295 final var entry = codecContext.fromNormalizedNode(BI_TOP_PATH, containerBuilder()
296 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
297 .withChild(orderedLeafSetBuilder()
298 .withNodeIdentifier(new NodeIdentifier(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
299 .withChild(leafSetEntryBuilder()
300 .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME, "foo"))
301 .withValue("foo").build())
304 assertEquals(new TopBuilder().setTopLevelOrderedLeafList(List.of("foo")).build(), entry.getValue());
308 public void choiceToNormalized() {
309 final var entry = (NodeResult) codecContext.toNormalizedNode(InstanceIdentifier.create(ChoiceContainer.class),
310 new ChoiceContainerBuilder()
311 .setIdentifier(new ExtendedBuilder()
312 .setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build())
315 assertEquals(containerBuilder()
316 .withNodeIdentifier(new NodeIdentifier(CHOICE_CONTAINER_QNAME))
317 .withChild(choiceBuilder()
318 .withNodeIdentifier(new NodeIdentifier(CHOICE_IDENTIFIER_QNAME))
319 .withChild(containerBuilder()
320 .withNodeIdentifier(new NodeIdentifier(EXTENDED_ID_QNAME))
321 .withChild(leafNode(CHOICE_IDENTIFIER_ID_QNAME, "identifier_value"))
329 public void test4798() {
330 final QName containerIdentifierQname4798 = Root.QNAME;
331 final QName choiceIdentifierQname4798 = QName.create(containerIdentifierQname4798, "bug4798-choice");
332 final QName nestedListQname4798 = QName.create(containerIdentifierQname4798, "list-in-case");
333 final QName nestedListKeyQname4798 = QName.create(containerIdentifierQname4798, "test-leaf");
334 final QName nestedContainerValidQname = QName.create(containerIdentifierQname4798, "case-b-container");
335 final QName nestedContainerOuterQname = QName.create(containerIdentifierQname4798, "outer-container");
336 final QName nestedContainerLeafOuterQname = QName.create(containerIdentifierQname4798,
337 "leaf-in-outer-container");
339 final YangInstanceIdentifier yangInstanceIdentifierOuter = YangInstanceIdentifier.of(
340 containerIdentifierQname4798);
341 final ContainerNode containerNodeOuter = containerBuilder()
342 .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
343 .withChild(containerBuilder()
344 .withNodeIdentifier(new NodeIdentifier(nestedContainerOuterQname))
345 .withChild(leafNode(nestedContainerLeafOuterQname, "bar"))
348 final Entry<InstanceIdentifier<?>, DataObject> entryContainer = codecContext.fromNormalizedNode(
349 yangInstanceIdentifierOuter, containerNodeOuter);
350 assertNotNull(entryContainer.getValue());
351 assertNotNull(entryContainer.getKey());
353 final NodeIdentifierWithPredicates nodeIdentifierWithPredicates4798 =
354 NodeIdentifierWithPredicates.of(nestedListQname4798, nestedListKeyQname4798, "foo");
355 final YangInstanceIdentifier yangInstanceIdentifier4798 = YangInstanceIdentifier.of(
356 containerIdentifierQname4798)
357 .node(choiceIdentifierQname4798)
358 .node(nestedListQname4798)
359 .node(nodeIdentifierWithPredicates4798);
361 final YangInstanceIdentifier yangInstanceIdentifierValid = YangInstanceIdentifier.of(
362 containerIdentifierQname4798)
363 .node(choiceIdentifierQname4798)
364 .node(nestedContainerValidQname)
365 .node(nestedListQname4798)
366 .node(nodeIdentifierWithPredicates4798);
367 final ContainerNode containerNodeValid = containerBuilder()
368 .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
369 .withChild(choiceBuilder()
370 .withNodeIdentifier(new NodeIdentifier(choiceIdentifierQname4798))
371 .withChild(containerBuilder()
372 .withNodeIdentifier(new NodeIdentifier(nestedContainerValidQname))
373 .withChild(mapBuilder()
374 .withNodeIdentifier(new NodeIdentifier(nestedListQname4798))
375 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "foo"))
376 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "bar"))
382 var msg = assertThrows(IllegalArgumentException.class,
383 () -> codecContext.fromNormalizedNode(yangInstanceIdentifierValid, containerNodeValid))
385 assertEquals("Expecting either a MapEntryNode or an UnkeyedListEntryNode, not ContainerNode", msg);
387 final ContainerNode containerNode4798 = containerBuilder()
388 .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
389 .withChild(choiceBuilder()
390 .withNodeIdentifier(new NodeIdentifier(choiceIdentifierQname4798))
391 .withChild(mapBuilder()
392 .withNodeIdentifier(new NodeIdentifier(nestedListQname4798))
393 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "foo"))
394 .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "bar"))
399 msg = assertThrows(IllegalArgumentException.class,
400 () -> codecContext.fromNormalizedNode(yangInstanceIdentifier4798, containerNode4798))
402 assertEquals("Expecting either a MapEntryNode or an UnkeyedListEntryNode, not ContainerNode", msg);
406 public void choiceFromNormalized() {
407 final ContainerNode choiceContainerBI = containerBuilder()
408 .withNodeIdentifier(new NodeIdentifier(CHOICE_CONTAINER_QNAME))
409 .withChild(choiceBuilder()
410 .withNodeIdentifier(new NodeIdentifier(CHOICE_IDENTIFIER_QNAME))
411 .withChild(containerBuilder()
412 .withNodeIdentifier(new NodeIdentifier(EXTENDED_ID_QNAME))
413 .withChild(leafNode(CHOICE_IDENTIFIER_ID_QNAME, "identifier_value"))
417 final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_CHOICE_CONTAINER_PATH,
419 final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder()
420 .setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
421 assertEquals(choiceContainerBA, entry.getValue());
425 public void orderedLisToNormalized() {
426 final var entry = (NodeResult) codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST, new TopLevelListBuilder()
427 .withKey(TOP_LEVEL_LIST_FOO_KEY)
428 .setNestedList(List.of(
429 new NestedListBuilder().withKey(new NestedListKey("foo")).build(),
430 new NestedListBuilder().withKey(new NestedListKey("bar")).build()))
432 assertEquals(mapEntryBuilder()
433 .withNodeIdentifier(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME,
434 TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
435 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
436 .withChild(orderedMapBuilder()
437 .withNodeIdentifier(new NodeIdentifier(NESTED_LIST_QNAME))
438 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
439 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar"))
446 public void orderedLisFromNormalized() {
447 final var entry = codecContext.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH, mapEntryBuilder()
448 .withNodeIdentifier(NodeIdentifierWithPredicates.of(
449 TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
450 .withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
451 .withChild(orderedMapBuilder()
452 .withNodeIdentifier(new NodeIdentifier(NESTED_LIST_QNAME))
453 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
454 .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar"))
457 assertEquals(new TopLevelListBuilder()
458 .withKey(TOP_LEVEL_LIST_FOO_KEY)
459 .setNestedList(List.of(
460 new NestedListBuilder().withKey(new NestedListKey("foo")).build(),
461 new NestedListBuilder().withKey(new NestedListKey("bar")).build()))
467 public void augmentMultipleChoices() {
468 final QName augmentChoice1QName = AugmentChoice1.QNAME;
469 final QName augmentChoice2QName = QName.create(augmentChoice1QName, "augment-choice2");
470 final QName containerQName = QName.create(augmentChoice1QName, "case11-choice-case-container");
471 final QName leafQName = QName.create(augmentChoice1QName, "case11-choice-case-leaf");
473 final NodeIdentifier augmentChoice1Id = new NodeIdentifier(augmentChoice1QName);
474 final NodeIdentifier augmentChoice2Id = new NodeIdentifier(augmentChoice2QName);
475 final NodeIdentifier containerId = new NodeIdentifier(containerQName);
477 final Top top = new TopBuilder().addAugmentation(
478 // top is augmented with choice1 having case1
479 new TopChoiceAugment1Builder().setAugmentChoice1(
480 new Case1Builder().addAugmentation(
481 // case1 is augmented with choice2 having case11 (with container having leaf)
482 new TopChoiceAugment2Builder().setAugmentChoice2(
483 new Case11Builder().setCase11ChoiceCaseContainer(
484 new Case11ChoiceCaseContainerBuilder()
485 .setCase11ChoiceCaseLeaf("leaf-value").build()
492 final var biResult = (NodeResult) codecContext.toNormalizedNode(InstanceIdentifier.create(Top.class), top);
494 final var topNormalized = containerBuilder()
495 .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
496 .withChild(choiceBuilder().withNodeIdentifier(augmentChoice1Id) // choice 1
497 .withChild(choiceBuilder().withNodeIdentifier(augmentChoice2Id) // choice 2
498 .withChild(containerBuilder().withNodeIdentifier(containerId)
499 .withChild(leafNode(leafQName, "leaf-value")).build())
504 assertEquals(BI_TOP_PATH, biResult.path());
505 assertEquals(topNormalized, biResult.node());
507 final var baResult = codecContext.fromNormalizedNode(BI_TOP_PATH, topNormalized);
509 assertEquals(InstanceIdentifier.create(Top.class), baResult.getKey());
510 assertEquals(top, baResult.getValue());