Code Review / yangtools.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Add ImmutableNode.newXYXBuilder() methods
[yangtools.git] / codec / yang-data-codec-xml / src / test / java / org / opendaylight / yangtools / yang / data / codec / xml / XmlToNormalizedNodesTest.java
diff --git a/codec/yang-data-codec-xml/src/test/java/org/opendaylight/yangtools/yang/data/codec/xml/XmlToNormalizedNodesTest.java b/codec/yang-data-codec-xml/src/test/java/org/opendaylight/yangtools/yang/data/codec/xml/XmlToNormalizedNodesTest.java
index c787574ebdade10bf138f63204d5217be6595227..af9f873b14451c219c07011527e9a8f18427f09d 100644 (file)
--- a/codec/yang-data-codec-xml/src/test/java/org/opendaylight/yangtools/yang/data/codec/xml/XmlToNormalizedNodesTest.java
+++ b/codec/yang-data-codec-xml/src/test/java/org/opendaylight/yangtools/yang/data/codec/xml/XmlToNormalizedNodesTest.java
@@ -8,7 +8,7 @@
 package org.opendaylight.yangtools.yang.data.codec.xml;
 
 import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -28,16 +28,15 @@ import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.common.XMLNamespace;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.api.schema.SystemLeafSetNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@@ -220,77 +219,79 @@ class XmlToNormalizedNodesTest {
 
     private static NormalizedNode buildOuterContainerNode() {
         // my-container-1
-        MapNode myKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(MY_KEYED_LIST))
-                .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
-                        NodeIdentifierWithPredicates.of(MY_KEYED_LIST, MY_KEY_LEAF, "listkeyvalue1"))
-                        .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(MY_LEAF_IN_LIST_1))
-                                .withValue("listleafvalue1").build())
-                        .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(MY_LEAF_IN_LIST_2))
-                                .withValue("listleafvalue2").build()).build())
-                .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
-                        NodeIdentifierWithPredicates.of(MY_KEYED_LIST, MY_KEY_LEAF, "listkeyvalue2"))
-                        .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(MY_LEAF_IN_LIST_1))
-                                .withValue("listleafvalue12").build())
-                        .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(MY_LEAF_IN_LIST_2))
-                                .withValue("listleafvalue22").build()).build()).build();
-
-        LeafNode<?> myLeaf1Node = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(MY_LEAF_1))
-                .withValue("value1").build();
-
-        SystemLeafSetNode<?> myLeafListNode = Builders.leafSetBuilder()
-                .withNodeIdentifier(new NodeIdentifier(MY_LEAFLIST))
-                .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
-                        new NodeWithValue<>(MY_LEAFLIST, "lflvalue1")).withValue("lflvalue1").build())
-                .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
-                        new NodeWithValue<>(MY_LEAFLIST, "lflvalue2")).withValue("lflvalue2").build()).build();
-
-        ContainerNode myContainer1Node = Builders.containerBuilder().withNodeIdentifier(
-                new NodeIdentifier(MY_CONTAINER_1))
-                .withChild(myKeyedListNode)
-                .withChild(myLeaf1Node)
-                .withChild(myLeafListNode).build();
+        MapNode myKeyedListNode = ImmutableNodes.newSystemMapBuilder()
+            .withNodeIdentifier(new NodeIdentifier(MY_KEYED_LIST))
+            .withChild(ImmutableNodes.newMapEntryBuilder()
+                .withNodeIdentifier(NodeIdentifierWithPredicates.of(MY_KEYED_LIST, MY_KEY_LEAF, "listkeyvalue1"))
+                .withChild(ImmutableNodes.leafNode(MY_LEAF_IN_LIST_1, "listleafvalue1"))
+                .withChild(ImmutableNodes.leafNode(MY_LEAF_IN_LIST_2, "listleafvalue2"))
+                .build())
+            .withChild(ImmutableNodes.newMapEntryBuilder().withNodeIdentifier(
+                NodeIdentifierWithPredicates.of(MY_KEYED_LIST, MY_KEY_LEAF, "listkeyvalue2"))
+                .withChild(ImmutableNodes.leafNode(MY_LEAF_IN_LIST_1, "listleafvalue12"))
+                .withChild(ImmutableNodes.leafNode(MY_LEAF_IN_LIST_2, "listleafvalue22"))
+                .build())
+            .build();
+
+        LeafNode<?> myLeaf1Node = ImmutableNodes.leafNode(MY_LEAF_1, "value1");
+
+        SystemLeafSetNode<?> myLeafListNode = ImmutableNodes.newSystemLeafSetBuilder()
+            .withNodeIdentifier(new NodeIdentifier(MY_LEAFLIST))
+            .withChild(ImmutableNodes.leafSetEntry(MY_LEAFLIST, "lflvalue1"))
+            .withChild(ImmutableNodes.leafSetEntry(MY_LEAFLIST, "lflvalue2"))
+            .build();
+
+        ContainerNode myContainer1Node = ImmutableNodes.newContainerBuilder()
+            .withNodeIdentifier(new NodeIdentifier(MY_CONTAINER_1))
+            .withChild(myKeyedListNode)
+            .withChild(myLeaf1Node)
+            .withChild(myLeafListNode)
+            .build();
 
         // my-container-2
-        ContainerNode innerContainerNode = Builders.containerBuilder().withNodeIdentifier(
-                new NodeIdentifier(INNER_CONTAINER))
-                .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(MY_LEAF_2))
-                        .withValue("value2").build()).build();
+        ContainerNode innerContainerNode = ImmutableNodes.newContainerBuilder()
+            .withNodeIdentifier(new NodeIdentifier(INNER_CONTAINER))
+            .withChild(ImmutableNodes.leafNode(MY_LEAF_2, "value2"))
+            .build();
 
-        LeafNode<?> myLeaf3Node = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(MY_LEAF_3))
-                .withValue("value3").build();
+        LeafNode<?> myLeaf3Node = ImmutableNodes.leafNode(MY_LEAF_3, "value3");
 
-        ChoiceNode myChoiceNode = Builders.choiceBuilder().withNodeIdentifier(new NodeIdentifier(MY_CHOICE))
-                .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(MY_LEAF_IN_CASE_2))
-                        .withValue("case2value").build()).build();
+        ChoiceNode myChoiceNode = ImmutableNodes.newChoiceBuilder()
+            .withNodeIdentifier(new NodeIdentifier(MY_CHOICE))
+            .withChild(ImmutableNodes.leafNode(MY_LEAF_IN_CASE_2, "case2value"))
+            .build();
 
-        ContainerNode myContainer2Node = Builders.containerBuilder().withNodeIdentifier(
-                new NodeIdentifier(MY_CONTAINER_2))
-                .withChild(innerContainerNode)
-                .withChild(myLeaf3Node)
-                .withChild(myChoiceNode).build();
+        ContainerNode myContainer2Node = ImmutableNodes.newContainerBuilder()
+            .withNodeIdentifier(new NodeIdentifier(MY_CONTAINER_2))
+            .withChild(innerContainerNode)
+            .withChild(myLeaf3Node)
+            .withChild(myChoiceNode)
+            .build();
 
         // my-container-3
         Map<QName, Object> keys = new HashMap<>();
         keys.put(MY_FIRST_KEY_LEAF, "listkeyvalue1");
         keys.put(MY_SECOND_KEY_LEAF, "listkeyvalue2");
 
-        MapNode myDoublyKeyedListNode = Builders.mapBuilder()
+        MapNode myDoublyKeyedListNode = ImmutableNodes.newSystemMapBuilder()
                 .withNodeIdentifier(new NodeIdentifier(MY_DOUBLY_KEYED_LIST))
-                .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
-                        NodeIdentifierWithPredicates.of(MY_DOUBLY_KEYED_LIST, keys))
-                        .withChild(Builders.leafBuilder().withNodeIdentifier(
-                                new NodeIdentifier(MY_LEAF_IN_LIST_3)).withValue("listleafvalue1").build()).build())
+                .withChild(ImmutableNodes.newMapEntryBuilder()
+                    .withNodeIdentifier(NodeIdentifierWithPredicates.of(MY_DOUBLY_KEYED_LIST, keys))
+                    .withChild(ImmutableNodes.leafNode(MY_LEAF_IN_LIST_3, "listleafvalue1"))
+                    .build())
                 .build();
 
-        ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
-                new NodeIdentifier(MY_CONTAINER_3))
-                .withChild(myDoublyKeyedListNode).build();
-
-        ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
-                new NodeIdentifier(OUTER_CONTAINER))
-                .withChild(myContainer1Node)
-                .withChild(myContainer2Node)
-                .withChild(myContainer3Node).build();
+        ContainerNode myContainer3Node = ImmutableNodes.newContainerBuilder()
+            .withNodeIdentifier(new NodeIdentifier(MY_CONTAINER_3))
+            .withChild(myDoublyKeyedListNode)
+            .build();
+
+        ContainerNode outerContainerNode = ImmutableNodes.newContainerBuilder()
+            .withNodeIdentifier(new NodeIdentifier(OUTER_CONTAINER))
+            .withChild(myContainer1Node)
+            .withChild(myContainer2Node)
+            .withChild(myContainer3Node)
+            .build();
 
         return outerContainerNode;
     }
OpenDaylight YANG Tools