X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-data-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fdata%2Fimpl%2Fschema%2FBuilderTest.java;h=d1e1d72fb6c68b637e34a79529854e360457b34c;hb=1e8209bb1e52b827e0e1e783a9c11cb6b8241d12;hp=10bf9a2380dbb3faa3ae26cc9b39ce0f692ed5f4;hpb=c3ff09884178e03dc325b75b0944fd8239319058;p=yangtools.git diff --git a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/BuilderTest.java b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/BuilderTest.java index 10bf9a2380..d1e1d72fb6 100644 --- a/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/BuilderTest.java +++ b/yang/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/BuilderTest.java @@ -10,10 +10,10 @@ package org.opendaylight.yangtools.yang.data.impl.schema; 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; @@ -22,67 +22,60 @@ import org.junit.Before; 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 BAR_PATH = new NodeWithValue<>(LEAF_LIST_MAIN, "bar"); + private static final LeafSetEntryNode LEAF_SET_ENTRY_NODE = + ImmutableLeafSetEntryNodeBuilder.create() .withNodeIdentifier(BAR_PATH) .withValue("bar") .build(); @@ -90,97 +83,87 @@ public class BuilderTest { 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 mapEntryNodeColl = new LinkedList(); + final LinkedList mapEntryNodeColl = new LinkedList<>(); mapEntryNodeColl.add(LIST_MAIN_CHILD_3); final Map 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 orderedLeafSet = ImmutableUserLeafSetNodeBuilder.create() .withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST) .withChild(LEAF_SET_ENTRY_NODE) .withChildValue("baz") .removeChild(BAR_PATH) .build(); - final LinkedList 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> 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 mapEntryNodeColl = new LinkedList(); + final LinkedList mapEntryNodeColl = new LinkedList<>(); mapEntryNodeColl.add(LIST_MAIN_CHILD_3); - final CollectionNodeBuilder collectionNodeBuilder = ImmutableMapNodeBuilder.create(1); + final CollectionNodeBuilder 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)); } @@ -192,12 +175,10 @@ public class BuilderTest { 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 @@ -207,7 +188,8 @@ public class BuilderTest { .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) @@ -215,16 +197,12 @@ public class BuilderTest { .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); } @@ -237,96 +215,51 @@ public class BuilderTest { } - @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 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> 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 +}