import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.mock;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
import java.io.File;
-import java.io.FileNotFoundException;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.LinkedList;
import org.junit.Test;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+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.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-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.OrderedLeafSetNode;
-import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.SystemLeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
-import org.opendaylight.yangtools.yang.data.impl.TestUtils;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
+import org.opendaylight.yangtools.yang.data.api.schema.UserLeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAugmentationNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableChoiceNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeSchemaAwareBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeSchemaAwareBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeSchemaAwareBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeSchemaAwareBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedLeafSetNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedLeafSetNodeSchemaAwareBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedMapNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedMapNodeSchemaAwareBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListEntryNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableYangModeledAnyXmlNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUserLeafSetNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUserMapNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.YangModeledAnyXmlSchemaNode;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContainerEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class BuilderTest {
- private static final QName ROOT_CONTAINER = QName.create("test.namespace.builder.test", "2016-01-01", "root-container");
+ private static final QName ROOT_CONTAINER = QName.create("test.namespace.builder.test", "2016-01-01",
+ "root-container");
private static final QName LIST_MAIN = QName.create(ROOT_CONTAINER, "list-ordered-by-user-with-key");
private static final QName LEAF_LIST_MAIN = QName.create(ROOT_CONTAINER, "leaf-list-ordered-by-user");
private static final QName LIST_MAIN_CHILD_QNAME_1 = QName.create(ROOT_CONTAINER, "leaf-a");
- private static final YangInstanceIdentifier.NodeIdentifier NODE_IDENTIFIER_LIST = YangInstanceIdentifier.NodeIdentifier
- .create(LIST_MAIN);
- private static final YangInstanceIdentifier.NodeIdentifier NODE_IDENTIFIER_LEAF_LIST = YangInstanceIdentifier.NodeIdentifier
- .create(LEAF_LIST_MAIN);
- private static final YangInstanceIdentifier.NodeIdentifier NODE_IDENTIFIER_LEAF = YangInstanceIdentifier
- .NodeIdentifier.create(LIST_MAIN_CHILD_QNAME_1);
- private static final MapEntryNode LIST_MAIN_CHILD_1 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1, 1);
- private static final MapEntryNode LIST_MAIN_CHILD_2 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1, 2);
- private static final MapEntryNode LIST_MAIN_CHILD_3 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1, 3);
- private static final Integer SIZE = 3;
- private static final YangInstanceIdentifier.NodeWithValue BAR_PATH = new YangInstanceIdentifier
- .NodeWithValue(LEAF_LIST_MAIN, "bar");
- private static final LeafSetEntryNode LEAF_SET_ENTRY_NODE = ImmutableLeafSetEntryNodeBuilder.create()
+ private static final NodeIdentifier NODE_IDENTIFIER_LIST = NodeIdentifier.create(LIST_MAIN);
+ private static final NodeIdentifier NODE_IDENTIFIER_LEAF_LIST = NodeIdentifier.create(LEAF_LIST_MAIN);
+ private static final NodeIdentifier NODE_IDENTIFIER_LEAF = NodeIdentifier.create(LIST_MAIN_CHILD_QNAME_1);
+ private static final MapEntryNode LIST_MAIN_CHILD_1 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1,
+ 1);
+ private static final MapEntryNode LIST_MAIN_CHILD_2 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1,
+ 2);
+ private static final MapEntryNode LIST_MAIN_CHILD_3 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1,
+ 3);
+ private static final int SIZE = 3;
+ private static final NodeWithValue<String> BAR_PATH = new NodeWithValue<>(LEAF_LIST_MAIN, "bar");
+ private static final LeafSetEntryNode<String> LEAF_SET_ENTRY_NODE =
+ ImmutableLeafSetEntryNodeBuilder.<String>create()
.withNodeIdentifier(BAR_PATH)
.withValue("bar")
.build();
private LeafListSchemaNode leafList;
@Before
- public void setup() throws FileNotFoundException, ReactorException, URISyntaxException {
+ public void setup() throws URISyntaxException {
final File leafRefTestYang = new File(getClass().getResource("/builder-test/immutable-ordered-map-node.yang")
.toURI());
- final SchemaContext schema = TestUtils.parseYangSources(leafRefTestYang);
+ final SchemaContext schema = YangParserTestUtils.parseYangFiles(leafRefTestYang);
final Module module = schema.getModules().iterator().next();
- final DataSchemaNode root = module.getDataChildByName(ROOT_CONTAINER);
- list = (ListSchemaNode)((ContainerEffectiveStatementImpl) root).getDataChildByName(LIST_MAIN);
- leafList = (LeafListSchemaNode)((ContainerEffectiveStatementImpl) root).getDataChildByName(LEAF_LIST_MAIN);
+ final DataSchemaNode root = module.findDataChildByName(ROOT_CONTAINER).get();
+ list = (ListSchemaNode)((ContainerSchemaNode) root).findDataChildByName(LIST_MAIN).get();
+ leafList = (LeafListSchemaNode)((ContainerSchemaNode) root).findDataChildByName(LEAF_LIST_MAIN).get();
}
@Test
public void immutableOrderedMapBuilderTest() {
- final LinkedList<MapEntryNode> mapEntryNodeColl = new LinkedList();
+ final LinkedList<MapEntryNode> mapEntryNodeColl = new LinkedList<>();
mapEntryNodeColl.add(LIST_MAIN_CHILD_3);
final Map<QName, Object> keys = new HashMap<>();
keys.put(LIST_MAIN_CHILD_QNAME_1, 1);
- final YangInstanceIdentifier.NodeIdentifierWithPredicates mapEntryPath = new YangInstanceIdentifier
- .NodeIdentifierWithPredicates(LIST_MAIN, keys);
- final OrderedMapNode orderedMapNodeCreateNull = ImmutableOrderedMapNodeBuilder.create()
+ final NodeIdentifierWithPredicates mapEntryPath = NodeIdentifierWithPredicates.of(LIST_MAIN, keys);
+ final UserMapNode orderedMapNodeCreateNull = ImmutableUserMapNodeBuilder.create()
.withNodeIdentifier(NODE_IDENTIFIER_LIST)
.withChild(LIST_MAIN_CHILD_1)
.addChild(LIST_MAIN_CHILD_2)
.withValue(mapEntryNodeColl)
.build();
- final OrderedMapNode orderedMapNodeCreateSize = ImmutableOrderedMapNodeBuilder.create(SIZE)
+ final UserMapNode orderedMapNodeCreateSize = ImmutableUserMapNodeBuilder.create(SIZE)
.withNodeIdentifier(NODE_IDENTIFIER_LIST)
.build();
- final OrderedMapNode orderedMapNodeCreateNode = ImmutableOrderedMapNodeBuilder.create(orderedMapNodeCreateNull)
+ final UserMapNode orderedMapNodeCreateNode = ImmutableUserMapNodeBuilder.create(orderedMapNodeCreateNull)
.removeChild(mapEntryPath)
.build();
- final OrderedMapNode orderedMapNodeSchemaAware = ImmutableOrderedMapNodeSchemaAwareBuilder.create(list)
+ final UserMapNode orderedMapNodeSchemaAware = ImmutableUserMapNodeBuilder.create()
+ .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
.withChild(LIST_MAIN_CHILD_1)
.build();
- final OrderedMapNode orderedMapNodeSchemaAwareMapNodeConst = ImmutableOrderedMapNodeSchemaAwareBuilder.create
- (list, getImmutableOrderedMapNode())
+ final UserMapNode orderedMapNodeSchemaAwareMapNodeConst =
+ ImmutableUserMapNodeBuilder.create(getImmutableUserMapNode())
.build();
- assertNotNull(Builders.orderedMapBuilder(list));
- assertEquals(SIZE, (Integer) orderedMapNodeCreateNull.getSize());
- assertEquals(orderedMapNodeCreateNode.getSize(), orderedMapNodeCreateNull.getSize() - 1);
+ assertEquals(SIZE, orderedMapNodeCreateNull.size());
+ assertEquals(orderedMapNodeCreateNode.size(), orderedMapNodeCreateNull.size() - 1);
assertEquals(NODE_IDENTIFIER_LIST, orderedMapNodeCreateSize.getIdentifier());
- assertEquals(orderedMapNodeCreateNull.getChild(0), LIST_MAIN_CHILD_1);
- assertEquals((Integer) orderedMapNodeCreateNull.getValue().size(), SIZE);
- assertNotNull(orderedMapNodeCreateNull.hashCode());
- assertEquals((Integer) orderedMapNodeCreateNull.getValue().size(), SIZE);
- assertEquals(orderedMapNodeSchemaAware.getChild(0), orderedMapNodeSchemaAwareMapNodeConst.getChild(0));
+ assertEquals(LIST_MAIN_CHILD_1, orderedMapNodeCreateNull.childAt(0));
+ assertEquals(SIZE, orderedMapNodeCreateNull.size());
+ assertEquals(orderedMapNodeSchemaAware.childAt(0), orderedMapNodeSchemaAwareMapNodeConst.childAt(0));
}
@Test
- public void immutableOrderedLeafSetNodeBuilderTest() {
- final NormalizedNode orderedLeafSet = ImmutableOrderedLeafSetNodeBuilder.create()
+ public void immutableUserLeafSetNodeBuilderTest() {
+ final UserLeafSetNode<String> orderedLeafSet = ImmutableUserLeafSetNodeBuilder.<String>create()
.withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
.withChild(LEAF_SET_ENTRY_NODE)
.withChildValue("baz")
.removeChild(BAR_PATH)
.build();
- final LinkedList<LeafSetNode> mapEntryNodeColl = new LinkedList();
- mapEntryNodeColl.add((LeafSetNode)orderedLeafSet);
- final UnmodifiableCollection leafSetCollection = (UnmodifiableCollection)orderedLeafSet.getValue();
- final NormalizedNode orderedMapNodeSchemaAware = ImmutableOrderedLeafSetNodeSchemaAwareBuilder.create(leafList)
- .withChildValue("baz")
- .build();
- final UnmodifiableCollection SchemaAwareleafSetCollection = (UnmodifiableCollection)orderedMapNodeSchemaAware
- .getValue();
- final NormalizedNode orderedLeafSetShemaAware = ImmutableOrderedLeafSetNodeSchemaAwareBuilder.create(leafList,
- (LeafSetNode)orderedLeafSet)
- .build();
+ final LinkedList<LeafSetNode<?>> mapEntryNodeColl = new LinkedList<>();
+ mapEntryNodeColl.add(orderedLeafSet);
+ final UnmodifiableCollection<?> leafSetCollection = (UnmodifiableCollection<?>)orderedLeafSet.body();
+ final NormalizedNode orderedMapNodeSchemaAware = ImmutableUserLeafSetNodeBuilder.create()
+ .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
+ .withChildValue("baz")
+ .build();
+ final UnmodifiableCollection<?> SchemaAwareleafSetCollection =
+ (UnmodifiableCollection<?>) orderedMapNodeSchemaAware.body();
- assertNotNull(Builders.orderedLeafSetBuilder(leafList));
assertNotNull(Builders.anyXmlBuilder());
- assertNotNull(orderedLeafSetShemaAware.hashCode());
- assertNotNull(orderedLeafSetShemaAware);
- assertEquals(1, ((OrderedLeafSetNode)orderedLeafSet).getSize());
- assertEquals("baz", ((OrderedLeafSetNode)orderedLeafSet).getChild(0).getValue());
- assertNotNull(((OrderedLeafSetNode)orderedLeafSet).getChild(BAR_PATH));
+ assertEquals(1, ((UserLeafSetNode<?>)orderedLeafSet).size());
+ assertEquals("baz", orderedLeafSet.childAt(0).body());
+ assertNull(orderedLeafSet.childByArg(BAR_PATH));
assertEquals(1, leafSetCollection.size());
assertEquals(1, SchemaAwareleafSetCollection.size());
}
@Test
public void immutableMapNodeBuilderTest() {
- final LinkedList<MapEntryNode> mapEntryNodeColl = new LinkedList();
+ final LinkedList<MapEntryNode> mapEntryNodeColl = new LinkedList<>();
mapEntryNodeColl.add(LIST_MAIN_CHILD_3);
- final CollectionNodeBuilder<MapEntryNode, MapNode> collectionNodeBuilder = ImmutableMapNodeBuilder.create(1);
+ final CollectionNodeBuilder<MapEntryNode, SystemMapNode> collectionNodeBuilder =
+ ImmutableMapNodeBuilder.create(1);
assertNotNull(collectionNodeBuilder);
collectionNodeBuilder.withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST);
collectionNodeBuilder.withValue(mapEntryNodeColl);
- final MapNode mapNode = collectionNodeBuilder.build();
- assertNotNull(mapNode.hashCode());
- final MapNode mapNodeSchemaAware = ImmutableMapNodeSchemaAwareBuilder.create(list, getImmutableMapNode()).build();
- assertNotNull(mapNodeSchemaAware);
+ final SystemMapNode mapNode = collectionNodeBuilder.build();
assertNotNull(Builders.mapBuilder(mapNode));
}
final UnkeyedListEntryNode unkeyedListEntryNodeSize = ImmutableUnkeyedListEntryNodeBuilder.create(1)
.withNodeIdentifier(NODE_IDENTIFIER_LIST)
.build();
- final UnkeyedListEntryNode unkeyedListEntryNodeNode = ImmutableUnkeyedListEntryNodeBuilder.create(unkeyedListEntryNode)
- .build();
- assertEquals(unkeyedListEntryNode.getNodeType().getLocalName(), unkeyedListEntryNodeSize.getNodeType()
- .getLocalName());
- assertEquals(unkeyedListEntryNodeSize.getNodeType().getLocalName(), unkeyedListEntryNodeNode.getNodeType()
- .getLocalName());
+ final UnkeyedListEntryNode unkeyedListEntryNodeNode = ImmutableUnkeyedListEntryNodeBuilder
+ .create(unkeyedListEntryNode).build();
+ assertEquals(unkeyedListEntryNode.getIdentifier(), unkeyedListEntryNodeSize.getIdentifier());
+ assertEquals(unkeyedListEntryNodeSize.getIdentifier(), unkeyedListEntryNodeNode.getIdentifier());
}
@Test
.build();
final ImmutableUnkeyedListNodeBuilder immutableUnkeyedListNodeBuilder = (ImmutableUnkeyedListNodeBuilder)
ImmutableUnkeyedListNodeBuilder.create();
- final UnkeyedListNode unkeyedListNode = immutableUnkeyedListNodeBuilder.withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
+ final UnkeyedListNode unkeyedListNode = immutableUnkeyedListNodeBuilder
+ .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
.addChild(unkeyedListEntryNode)
.build();
final UnkeyedListNode unkeyedListNodeSize = ImmutableUnkeyedListNodeBuilder.create(1)
.build();
final UnkeyedListNode unkeyedListNodeCreated = ImmutableUnkeyedListNodeBuilder.create(unkeyedListNode)
.build();
- try {
- unkeyedListNodeSize.getChild(1);
- } catch (IndexOutOfBoundsException e) {
- }
- assertNotNull(unkeyedListNodeSize.getSize());
- assertNotNull(unkeyedListNodeSize.getValue());
- assertEquals(unkeyedListEntryNode, unkeyedListNodeCreated.getChild(0));
- assertEquals(unkeyedListNode.getNodeType().getLocalName(), unkeyedListNodeSize.getNodeType()
- .getLocalName());
+ assertThrows(IndexOutOfBoundsException.class, () -> unkeyedListNodeSize.childAt(1));
+
+ assertNotNull(unkeyedListNodeSize.body());
+ assertEquals(unkeyedListEntryNode, unkeyedListNodeCreated.childAt(0));
+ assertEquals(unkeyedListNode.getIdentifier(), unkeyedListNodeSize.getIdentifier());
assertNotNull(unkeyedListNodeCreated);
}
}
- @Test(expected=NullPointerException.class)
+ @Test
public void immutableAugmentationNodeBuilderExceptionTest() {
- ImmutableAugmentationNodeBuilder.create(1).build();
+ final var builder = ImmutableAugmentationNodeBuilder.create(1);
+ assertThrows(NullPointerException.class, builder::build);
}
- @Test(expected=NullPointerException.class)
+ @Test
public void immutableContainerNodeBuilderExceptionTest() {
final ContainerNode immutableContainerNode = ImmutableContainerNodeBuilder.create(1)
.withNodeIdentifier(NODE_IDENTIFIER_LIST)
.build();
assertNotNull(immutableContainerNode);
- final ContainerSchemaNode containerSchemaNode = mock(ContainerSchemaNode.class);
- ImmutableContainerNodeSchemaAwareBuilder.create(containerSchemaNode, immutableContainerNode)
- .withNodeIdentifier(NODE_IDENTIFIER_LIST)
- .build();
}
- @Test(expected=NullPointerException.class)
+ @Test
public void immutableLeafSetNodeBuilderExceptionTest() {
- final LeafSetNode leafSetNode = ImmutableLeafSetNodeBuilder.create(1).withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
+ final SystemLeafSetNode<Object> leafSetNode = ImmutableLeafSetNodeBuilder.create(1)
+ .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST)
.build();
assertNotNull(leafSetNode);
- ImmutableLeafSetNodeSchemaAwareBuilder.create(mock(LeafListSchemaNode.class), leafSetNode).build();
}
- @Test(expected=UnsupportedOperationException.class)
- public void immutableLeafSetEntryNodeSchemaAwareBuilderExceptionTest() {
- final LeafListSchemaNode leafListSchemaNode = mock(LeafListSchemaNode.class);
- ImmutableLeafSetEntryNodeSchemaAwareBuilder.create(leafListSchemaNode).withNodeIdentifier(BAR_PATH).build();
- }
-
- @Test(expected=NullPointerException.class)
+ @Test
public void immutableMapEntryNodeBuilderExceptionTest() {
- ImmutableMapEntryNodeBuilder.create(1).build();
- }
-
- @Test(expected=NullPointerException.class)
- public void immutableYangModeledAnyXmlNodeBuilderExceptionTest() {
- ImmutableYangModeledAnyXmlNodeBuilder.create(mock(YangModeledAnyXmlSchemaNode.class), 1);
+ final var builder = ImmutableMapEntryNodeBuilder.create(1);
+ assertThrows(NullPointerException.class, builder::build);
}
- @Test(expected=UnsupportedOperationException.class)
+ @Test
public void immutableUnkeyedListNodeBuilderExceptionTest() {
- ImmutableUnkeyedListNodeBuilder.create().withNodeIdentifier(NODE_IDENTIFIER_LEAF)
- .removeChild(NODE_IDENTIFIER_LIST).build();
- }
-
- @Test(expected=UnsupportedOperationException.class)
- public void immutableOrderedMapNotSchemaAwareExceptionTest1() {
- ImmutableOrderedMapNodeBuilder.create(getImmutableMapNode()).build();
- }
-
- @Test(expected=UnsupportedOperationException.class)
- public void immutableMapNodeSchemaAwareExceptionTest() {
- ImmutableMapNodeSchemaAwareBuilder.create(list, getImmutableMapNode()).withNodeIdentifier(NODE_IDENTIFIER_LIST).build();
- }
-
- @Test(expected=UnsupportedOperationException.class)
- public void immutableOrderedMapSchemaAwareExceptionTest1() {
- ImmutableOrderedMapNodeSchemaAwareBuilder.create(list).withNodeIdentifier(NODE_IDENTIFIER_LIST).build();
- }
-
- @Test(expected=UnsupportedOperationException.class)
- public void immutableOrderedMapSchemaAwareExceptionTest2() {
- ImmutableOrderedMapNodeSchemaAwareBuilder.create(list, getImmutableMapNode()).build();
+ final var builder = ImmutableUnkeyedListNodeBuilder.create().withNodeIdentifier(NODE_IDENTIFIER_LEAF);
+ assertThrows(UnsupportedOperationException.class, () -> builder.removeChild(NODE_IDENTIFIER_LIST));
}
- @Test(expected=UnsupportedOperationException.class)
- public void immutableOrderedLeafSetNodeExceptionTest1() {
- ImmutableOrderedLeafSetNodeBuilder.create(getImmutableLeafSetNode()).build();
- }
-
- @Test(expected=UnsupportedOperationException.class)
- public void immutableOrderedLeafSetNodeSchemaAwareExceptionTest1() {
- ImmutableOrderedLeafSetNodeSchemaAwareBuilder.create(leafList).withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST).build();
- }
-
- private static LeafSetNode getImmutableLeafSetNode() {
- final ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafSetBuilder = Builders.leafSetBuilder();
- leafSetBuilder.withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST);
- leafSetBuilder.addChild(LEAF_SET_ENTRY_NODE);
- return leafSetBuilder.build();
- }
-
- private static MapNode getImmutableMapNode() {
- return ImmutableMapNodeBuilder.create().withNodeIdentifier(NODE_IDENTIFIER_LIST).withChild(LIST_MAIN_CHILD_1).build();
+ private static SystemMapNode getImmutableMapNode() {
+ return ImmutableMapNodeBuilder.create()
+ .withNodeIdentifier(NODE_IDENTIFIER_LIST)
+ .withChild(LIST_MAIN_CHILD_1)
+ .build();
}
- private static MapNode getImmutableOrderedMapNode() {
- return ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier(NODE_IDENTIFIER_LIST).withChild(LIST_MAIN_CHILD_1)
- .build();
+ private static UserMapNode getImmutableUserMapNode() {
+ return ImmutableUserMapNodeBuilder.create()
+ .withNodeIdentifier(NODE_IDENTIFIER_LIST)
+ .withChild(LIST_MAIN_CHILD_1)
+ .build();
}
-}
\ No newline at end of file
+}
Code Review / yangtools.git / blobdiff