data/yang-data-spi/src/test/java/org/opendaylight/yangtools/yang/data/spi/node/impl/BuilderTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.yangtools.yang.data.spi.node.impl;
  10
  11 import static org.junit.jupiter.api.Assertions.assertEquals;
  12 import static org.junit.jupiter.api.Assertions.assertNotNull;
  13 import static org.junit.jupiter.api.Assertions.assertNull;
  14 import static org.junit.jupiter.api.Assertions.assertThrows;
  15
  16 import java.util.List;
  17 import javax.xml.transform.dom.DOMSource;
  18 import org.junit.jupiter.api.Test;
  19 import org.opendaylight.yangtools.yang.common.QName;
  20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  23 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  24 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  25 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode.BuilderFactory;
  26 import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
  27 import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
  28
  29 class BuilderTest {
  30     private static final BuilderFactory BUILDER_FACTORY = ImmutableNodes.builderFactory();
  31     private static final QName ROOT_CONTAINER = QName.create("test.namespace.builder.test", "2016-01-01",
  32         "root-container");
  33     private static final QName LIST_MAIN = QName.create(ROOT_CONTAINER, "list-ordered-by-user-with-key");
  34     private static final QName LEAF_LIST_MAIN = QName.create(ROOT_CONTAINER, "leaf-list-ordered-by-user");
  35     private static final QName LIST_MAIN_CHILD_QNAME_1 = QName.create(ROOT_CONTAINER, "leaf-a");
  36     private static final NodeIdentifier NODE_IDENTIFIER_LIST = NodeIdentifier.create(LIST_MAIN);
  37     private static final NodeIdentifier NODE_IDENTIFIER_LEAF_LIST = NodeIdentifier.create(LEAF_LIST_MAIN);
  38     private static final NodeIdentifier NODE_IDENTIFIER_LEAF = NodeIdentifier.create(LIST_MAIN_CHILD_QNAME_1);
  39     private static final MapEntryNode LIST_MAIN_CHILD_1 = ImmutableNodes.newMapEntryBuilder()
  40         .withNodeIdentifier(NodeIdentifierWithPredicates.of(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1, 1))
  41         .withChild(ImmutableNodes.leafNode(LIST_MAIN_CHILD_QNAME_1, 1))
  42         .build();
  43     private static final MapEntryNode LIST_MAIN_CHILD_2 = ImmutableNodes.newMapEntryBuilder()
  44         .withNodeIdentifier(NodeIdentifierWithPredicates.of(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1, 2))
  45         .withChild(ImmutableNodes.leafNode(LIST_MAIN_CHILD_QNAME_1, 2))
  46         .build();
  47     private static final MapEntryNode LIST_MAIN_CHILD_3 = ImmutableNodes.newMapEntryBuilder()
  48         .withNodeIdentifier(NodeIdentifierWithPredicates.of(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1, 3))
  49         .withChild(ImmutableNodes.leafNode(LIST_MAIN_CHILD_QNAME_1, 3))
  50         .build();
  51     private static final int SIZE = 3;
  52     private static final NodeWithValue<String> BAR_PATH = new NodeWithValue<>(LEAF_LIST_MAIN, "bar");
  53     private static final LeafSetEntryNode<String> LEAF_SET_ENTRY_NODE =
  54             new ImmutableLeafSetEntryNodeBuilder<String>().withNodeIdentifier(BAR_PATH).withValue("bar").build();
  55
  56     @Test
  57     void immutableOrderedMapBuilderTest() {
  58         final var mapEntryPath = NodeIdentifierWithPredicates.of(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1, 1);
  59         final var orderedMapNodeCreateNull = ImmutableNodes.newUserMapBuilder()
  60                 .withNodeIdentifier(NODE_IDENTIFIER_LIST)
  61                 .withChild(LIST_MAIN_CHILD_1)
  62                 .addChild(LIST_MAIN_CHILD_2)
  63                 .withValue(List.of(LIST_MAIN_CHILD_3))
  64                 .build();
  65         final var orderedMapNodeCreateSize = ImmutableNodes.builderFactory().newUserMapBuilder(SIZE)
  66                 .withNodeIdentifier(NODE_IDENTIFIER_LIST)
  67                 .build();
  68         final var orderedMapNodeCreateNode = ImmutableUserMapNodeBuilder.create(orderedMapNodeCreateNull)
  69                 .removeChild(mapEntryPath)
  70                 .build();
  71         final var orderedMapNodeSchemaAware = ImmutableNodes.newUserMapBuilder()
  72                 .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
  73                 .withChild(LIST_MAIN_CHILD_1)
  74                 .build();
  75         final var orderedMapNodeSchemaAwareMapNodeConst =
  76                 ImmutableUserMapNodeBuilder.create(getImmutableUserMapNode())
  77                 .build();
  78
  79         assertEquals(SIZE, orderedMapNodeCreateNull.size());
  80         assertEquals(orderedMapNodeCreateNode.size(), orderedMapNodeCreateNull.size() - 1);
  81         assertEquals(NODE_IDENTIFIER_LIST, orderedMapNodeCreateSize.name());
  82         assertEquals(LIST_MAIN_CHILD_1, orderedMapNodeCreateNull.childAt(0));
  83         assertEquals(SIZE, orderedMapNodeCreateNull.size());
  84         assertEquals(orderedMapNodeSchemaAware.childAt(0), orderedMapNodeSchemaAwareMapNodeConst.childAt(0));
  85     }
  86
  87     @Test
  88     void immutableUserLeafSetNodeBuilderTest() {
  89         final var orderedLeafSet = ImmutableNodes.<String>newUserLeafSetBuilder()
  90                 .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
  91                 .withChild(LEAF_SET_ENTRY_NODE)
  92                 .withChildValue("baz")
  93                 .removeChild(BAR_PATH)
  94                 .build();
  95         final var orderedMapNodeSchemaAware = ImmutableNodes.newUserLeafSetBuilder()
  96             .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
  97             .withChildValue("baz")
  98             .build();
  99
 100         assertNotNull(ImmutableNodes.newAnyxmlBuilder(DOMSource.class));
 101         assertEquals(1, orderedLeafSet.size());
 102         assertEquals("baz", orderedLeafSet.childAt(0).body());
 103         assertNull(orderedLeafSet.childByArg(BAR_PATH));
 104         assertEquals(1, orderedLeafSet.size());
 105         assertEquals(1, orderedMapNodeSchemaAware.size());
 106     }
 107
 108     @Test
 109     void immutableMapNodeBuilderTest() {
 110         final var mapNode = BUILDER_FACTORY.newSystemMapBuilder(1)
 111             .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
 112             .withValue(List.of(LIST_MAIN_CHILD_3))
 113             .build();
 114         assertNotNull(BUILDER_FACTORY.newSystemMapBuilder(mapNode));
 115     }
 116
 117     @Test
 118     void immutableUnkeyedListEntryNodeBuilderTest() {
 119         final var unkeyedListEntryNode = ImmutableNodes.newUnkeyedListEntryBuilder()
 120                 .withNodeIdentifier(NODE_IDENTIFIER_LIST)
 121                 .build();
 122         final var unkeyedListEntryNodeSize = BUILDER_FACTORY.newUnkeyedListEntryBuilder(1)
 123                 .withNodeIdentifier(NODE_IDENTIFIER_LIST)
 124                 .build();
 125         final var unkeyedListEntryNodeNode = ImmutableUnkeyedListEntryNodeBuilder.create(unkeyedListEntryNode).build();
 126         assertEquals(unkeyedListEntryNode.name(), unkeyedListEntryNodeSize.name());
 127         assertEquals(unkeyedListEntryNodeSize.name(), unkeyedListEntryNodeNode.name());
 128     }
 129
 130     @Test
 131     void immutableUnkeyedListNodeBuilderTest() {
 132         final var unkeyedListEntryNode = ImmutableNodes.newUnkeyedListEntryBuilder()
 133                 .withNodeIdentifier(NODE_IDENTIFIER_LEAF)
 134                 .build();
 135         final var immutableUnkeyedListNodeBuilder = ImmutableNodes.newUnkeyedListBuilder();
 136         final var unkeyedListNode = immutableUnkeyedListNodeBuilder
 137                 .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
 138                 .addChild(unkeyedListEntryNode)
 139                 .build();
 140         final var unkeyedListNodeSize = BUILDER_FACTORY.newUnkeyedListBuilder(1)
 141                 .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
 142                 .build();
 143         final var unkeyedListNodeCreated = ImmutableUnkeyedListNodeBuilder.create(unkeyedListNode)
 144                 .build();
 145
 146         assertThrows(IndexOutOfBoundsException.class, () -> unkeyedListNodeSize.childAt(1));
 147
 148         assertNotNull(unkeyedListNodeSize.body());
 149         assertEquals(unkeyedListEntryNode, unkeyedListNodeCreated.childAt(0));
 150         assertEquals(unkeyedListNode.name(), unkeyedListNodeSize.name());
 151         assertNotNull(unkeyedListNodeCreated);
 152     }
 153
 154     @Test
 155     void immutableChoiceNodeBuilderTest() {
 156         final var choiceNode = BUILDER_FACTORY.newChoiceBuilder(1).withNodeIdentifier(NODE_IDENTIFIER_LIST).build();
 157         final var choiceNodeCreated = ImmutableChoiceNodeBuilder.create(choiceNode).build();
 158         assertEquals(choiceNode, choiceNodeCreated);
 159     }
 160
 161     @Test
 162     void immutableContainerNodeBuilderExceptionTest() {
 163         final var containerNode = BUILDER_FACTORY.newContainerBuilder(1)
 164             .withNodeIdentifier(NODE_IDENTIFIER_LIST)
 165             .build();
 166         assertNotNull(containerNode);
 167     }
 168
 169     @Test
 170     void immutableLeafSetNodeBuilderExceptionTest() {
 171         final var leafSetNode = BUILDER_FACTORY.newSystemLeafSetBuilder(1)
 172             .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
 173             .build();
 174         assertNotNull(leafSetNode);
 175     }
 176
 177     @Test
 178     void immutableMapEntryNodeBuilderExceptionTest() {
 179         final var builder = BUILDER_FACTORY.newMapEntryBuilder(1);
 180         assertThrows(NullPointerException.class, builder::build);
 181     }
 182
 183     @Test
 184     void immutableUnkeyedListNodeBuilderExceptionTest() {
 185         final var builder = ImmutableNodes.newUnkeyedListBuilder().withNodeIdentifier(NODE_IDENTIFIER_LEAF);
 186         assertThrows(UnsupportedOperationException.class, () -> builder.removeChild(NODE_IDENTIFIER_LIST));
 187     }
 188
 189     private static UserMapNode getImmutableUserMapNode() {
 190         return ImmutableNodes.newUserMapBuilder()
 191             .withNodeIdentifier(NODE_IDENTIFIER_LIST)
 192             .withChild(LIST_MAIN_CHILD_1)
 193             .build();
 194     }
 195 }