data/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/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.impl.schema;
  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 org.junit.jupiter.api.Test;
  18 import org.opendaylight.yangtools.yang.common.QName;
  19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  22 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  23 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  24 import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
  25 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableChoiceNodeBuilder;
  26 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
  27 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
  28 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
  29 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
  30 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
  31 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListEntryNodeBuilder;
  32 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListNodeBuilder;
  33 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUserLeafSetNodeBuilder;
  34 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUserMapNodeBuilder;
  35
  36 class BuilderTest {
  37     private static final QName ROOT_CONTAINER = QName.create("test.namespace.builder.test", "2016-01-01",
  38         "root-container");
  39     private static final QName LIST_MAIN = QName.create(ROOT_CONTAINER, "list-ordered-by-user-with-key");
  40     private static final QName LEAF_LIST_MAIN = QName.create(ROOT_CONTAINER, "leaf-list-ordered-by-user");
  41     private static final QName LIST_MAIN_CHILD_QNAME_1 = QName.create(ROOT_CONTAINER, "leaf-a");
  42     private static final NodeIdentifier NODE_IDENTIFIER_LIST = NodeIdentifier.create(LIST_MAIN);
  43     private static final NodeIdentifier NODE_IDENTIFIER_LEAF_LIST = NodeIdentifier.create(LEAF_LIST_MAIN);
  44     private static final NodeIdentifier NODE_IDENTIFIER_LEAF = NodeIdentifier.create(LIST_MAIN_CHILD_QNAME_1);
  45     private static final MapEntryNode LIST_MAIN_CHILD_1 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1,
  46             1);
  47     private static final MapEntryNode LIST_MAIN_CHILD_2 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1,
  48             2);
  49     private static final MapEntryNode LIST_MAIN_CHILD_3 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1,
  50             3);
  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             ImmutableLeafSetEntryNodeBuilder.<String>create().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 = ImmutableUserMapNodeBuilder.create()
  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 = ImmutableUserMapNodeBuilder.create(SIZE)
  66                 .withNodeIdentifier(NODE_IDENTIFIER_LIST)
  67                 .build();
  68         final var orderedMapNodeCreateNode = ImmutableUserMapNodeBuilder.create(orderedMapNodeCreateNull)
  69                 .removeChild(mapEntryPath)
  70                 .build();
  71         final var orderedMapNodeSchemaAware = ImmutableUserMapNodeBuilder.create()
  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 = ImmutableUserLeafSetNodeBuilder.<String>create()
  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 = ImmutableUserLeafSetNodeBuilder.create()
  96             .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
  97             .withChildValue("baz")
  98             .build();
  99
 100         assertNotNull(Builders.anyXmlBuilder());
 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 = ImmutableMapNodeBuilder.create(1)
 111             .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
 112             .withValue(List.of(LIST_MAIN_CHILD_3))
 113             .build();
 114         assertNotNull(Builders.mapBuilder(mapNode));
 115     }
 116
 117     @Test
 118     void immutableUnkeyedListEntryNodeBuilderTest() {
 119         final var unkeyedListEntryNode = ImmutableUnkeyedListEntryNodeBuilder.create()
 120                 .withNodeIdentifier(NODE_IDENTIFIER_LIST)
 121                 .build();
 122         final var unkeyedListEntryNodeSize = ImmutableUnkeyedListEntryNodeBuilder.create(1)
 123                 .withNodeIdentifier(NODE_IDENTIFIER_LIST)
 124                 .build();
 125         final var unkeyedListEntryNodeNode = ImmutableUnkeyedListEntryNodeBuilder
 126                 .create(unkeyedListEntryNode).build();
 127         assertEquals(unkeyedListEntryNode.name(), unkeyedListEntryNodeSize.name());
 128         assertEquals(unkeyedListEntryNodeSize.name(), unkeyedListEntryNodeNode.name());
 129     }
 130
 131     @Test
 132     void immutableUnkeyedListNodeBuilderTest() {
 133         final var unkeyedListEntryNode = ImmutableUnkeyedListEntryNodeBuilder.create()
 134                 .withNodeIdentifier(NODE_IDENTIFIER_LEAF)
 135                 .build();
 136         final var immutableUnkeyedListNodeBuilder = (ImmutableUnkeyedListNodeBuilder)
 137                 ImmutableUnkeyedListNodeBuilder.create();
 138         final var unkeyedListNode = immutableUnkeyedListNodeBuilder
 139                 .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
 140                 .addChild(unkeyedListEntryNode)
 141                 .build();
 142         final var unkeyedListNodeSize = ImmutableUnkeyedListNodeBuilder.create(1)
 143                 .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
 144                 .build();
 145         final var unkeyedListNodeCreated = ImmutableUnkeyedListNodeBuilder.create(unkeyedListNode)
 146                 .build();
 147
 148         assertThrows(IndexOutOfBoundsException.class, () -> unkeyedListNodeSize.childAt(1));
 149
 150         assertNotNull(unkeyedListNodeSize.body());
 151         assertEquals(unkeyedListEntryNode, unkeyedListNodeCreated.childAt(0));
 152         assertEquals(unkeyedListNode.name(), unkeyedListNodeSize.name());
 153         assertNotNull(unkeyedListNodeCreated);
 154     }
 155
 156     @Test
 157     void immutableChoiceNodeBuilderTest() {
 158         final var choiceNode = ImmutableChoiceNodeBuilder.create(1).withNodeIdentifier(NODE_IDENTIFIER_LIST)
 159                 .build();
 160         final var choiceNodeCreated = ImmutableChoiceNodeBuilder.create(choiceNode).build();
 161         assertEquals(choiceNodeCreated.name(), choiceNode.name());
 162     }
 163
 164     @Test
 165     void immutableContainerNodeBuilderExceptionTest() {
 166         final var immutableContainerNode = ImmutableContainerNodeBuilder.create(1)
 167                 .withNodeIdentifier(NODE_IDENTIFIER_LIST)
 168                 .build();
 169         assertNotNull(immutableContainerNode);
 170     }
 171
 172     @Test
 173     void immutableLeafSetNodeBuilderExceptionTest() {
 174         final var leafSetNode = ImmutableLeafSetNodeBuilder.create(1)
 175                 .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
 176                 .build();
 177         assertNotNull(leafSetNode);
 178     }
 179
 180     @Test
 181     void immutableMapEntryNodeBuilderExceptionTest() {
 182         final var builder = ImmutableMapEntryNodeBuilder.create(1);
 183         assertThrows(NullPointerException.class, builder::build);
 184     }
 185
 186     @Test
 187     void immutableUnkeyedListNodeBuilderExceptionTest() {
 188         final var builder = ImmutableUnkeyedListNodeBuilder.create().withNodeIdentifier(NODE_IDENTIFIER_LEAF);
 189         assertThrows(UnsupportedOperationException.class, () -> builder.removeChild(NODE_IDENTIFIER_LIST));
 190     }
 191
 192     private static UserMapNode getImmutableUserMapNode() {
 193         return ImmutableUserMapNodeBuilder.create()
 194             .withNodeIdentifier(NODE_IDENTIFIER_LIST)
 195             .withChild(LIST_MAIN_CHILD_1)
 196             .build();
 197     }
 198 }