X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-clustering-commons%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Fnode%2Futils%2Ftransformer%2FNormalizedNodePrunerTest.java;h=14b7bc85687d4e73e99ead5e77a8b7151637c275;hb=f40e99a51cd3fc2c9be3ac8aa0772bdb6b6ce479;hp=50ade7875f8383366a327ccfcfc89f908fb780f7;hpb=33da69fa2c632e6229c5064d546c2f20ae9dd3f3;p=controller.git diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java index 50ade7875f..14b7bc8568 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/NormalizedNodePrunerTest.java @@ -5,76 +5,75 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.controller.cluster.datastore.node.utils.transformer; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.mock; import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntry; import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder; import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder; -import com.google.common.collect.Sets; import java.io.IOException; +import java.util.Optional; import java.util.concurrent.atomic.AtomicInteger; import javax.xml.transform.dom.DOMSource; -import org.junit.Assert; -import org.junit.Before; import org.junit.Test; -import org.mockito.MockitoAnnotations; +import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnitRunner; import org.opendaylight.controller.cluster.datastore.node.utils.NormalizedNodeNavigator; import org.opendaylight.controller.cluster.datastore.util.TestModel; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; -import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue; +import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode; import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode; +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.stream.NormalizedNodeWriter; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder; -import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class NormalizedNodePrunerTest { - private static final SchemaContext NO_TEST_SCHEMA = TestModel.createTestContextWithoutTestSchema(); - private static final SchemaContext NO_AUG_SCHEMA = TestModel.createTestContextWithoutAugmentationSchema(); - private static final SchemaContext FULL_SCHEMA = TestModel.createTestContext(); - - @Before - public void setUp() { - MockitoAnnotations.initMocks(this); - } - - private static NormalizedNodePruner prunerFullSchema(final YangInstanceIdentifier path) { - return new NormalizedNodePruner(path, FULL_SCHEMA); + private static final EffectiveModelContext NO_TEST_SCHEMA = TestModel.createTestContextWithoutTestSchema(); + private static final EffectiveModelContext NO_AUG_SCHEMA = TestModel.createTestContextWithoutAugmentationSchema(); + private static final EffectiveModelContext FULL_SCHEMA = TestModel.createTestContext(); + + private static AbstractNormalizedNodePruner prunerFullSchema(final YangInstanceIdentifier path) { + final ReusableNormalizedNodePruner pruner = ReusableNormalizedNodePruner.forSchemaContext(FULL_SCHEMA); + pruner.initializeForPath(path); + return pruner; } - private static NormalizedNodePruner prunerNoAugSchema(final YangInstanceIdentifier path) { - return new NormalizedNodePruner(path, NO_AUG_SCHEMA); + private static AbstractNormalizedNodePruner prunerNoAugSchema(final YangInstanceIdentifier path) { + final ReusableNormalizedNodePruner pruner = ReusableNormalizedNodePruner.forSchemaContext(NO_AUG_SCHEMA); + pruner.initializeForPath(path); + return pruner; } - private static NormalizedNodePruner prunerNoTestSchema(final YangInstanceIdentifier path) { - return new NormalizedNodePruner(path, NO_TEST_SCHEMA); + private static AbstractNormalizedNodePruner prunerNoTestSchema(final YangInstanceIdentifier path) { + final ReusableNormalizedNodePruner pruner = ReusableNormalizedNodePruner.forSchemaContext(NO_TEST_SCHEMA); + pruner.initializeForPath(path); + return pruner; } @Test public void testNodesNotPrunedWhenSchemaPresent() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH); + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH); NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner); - NormalizedNode expected = createTestContainer(); + NormalizedNode expected = createTestContainer(); normalizedNodeWriter.write(expected); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals(expected, actual); @@ -82,15 +81,15 @@ public class NormalizedNodePrunerTest { @Test(expected = IllegalStateException.class) public void testReusePruner() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH); + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH); NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner); - NormalizedNode expected = createTestContainer(); + NormalizedNode expected = createTestContainer(); normalizedNodeWriter.write(expected); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals(expected, actual); @@ -101,17 +100,17 @@ public class NormalizedNodePrunerTest { @Test public void testNodesPrunedWhenAugmentationSchemaMissing() throws IOException { - NormalizedNodePruner pruner = prunerNoAugSchema(TestModel.TEST_PATH); + AbstractNormalizedNodePruner pruner = prunerNoAugSchema(TestModel.TEST_PATH); NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner); - NormalizedNode expected = createTestContainer(); + NormalizedNode expected = createTestContainer(); normalizedNodeWriter.write(expected); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); - Assert.assertNotEquals(expected, actual); + assertNotEquals(expected, actual); // Asserting true here instead of checking actual value because I don't want this assertion to be fragile assertTrue(countNodes(expected, "store:aug") > 0); @@ -122,160 +121,133 @@ public class NormalizedNodePrunerTest { @Test public void testNodesPrunedWhenTestSchemaMissing() throws IOException { - NormalizedNodePruner pruner = prunerNoTestSchema(TestModel.TEST_PATH); + AbstractNormalizedNodePruner pruner = prunerNoTestSchema(TestModel.TEST_PATH); NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner); - NormalizedNode expected = createTestContainer(); + NormalizedNode expected = createTestContainer(); normalizedNodeWriter.write(expected); - NormalizedNode actual = pruner.normalizedNode(); - - // Since top level schema is missing null is returned - assertNull(actual); + // Since top level schema is missing empty is returned + assertEquals(Optional.empty(), pruner.getResult()); // Asserting true here instead of checking actual value because I don't want this assertion to be fragile assertTrue(countNodes(expected, "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test") > 0); } - private static int countNodes(final NormalizedNode normalizedNode, final String namespaceFilter) { + private static int countNodes(final NormalizedNode normalizedNode, final String namespaceFilter) { if (normalizedNode == null) { return 0; } final AtomicInteger count = new AtomicInteger(); new NormalizedNodeNavigator((level, parentPath, normalizedNode1) -> { - if (!(normalizedNode1.getIdentifier() instanceof AugmentationIdentifier)) { - if (normalizedNode1.getIdentifier().getNodeType().getNamespace().toString().contains(namespaceFilter)) { - count.incrementAndGet(); - } + if (normalizedNode1.name().getNodeType().getNamespace().toString().contains(namespaceFilter)) { + count.incrementAndGet(); } - }).navigate(YangInstanceIdentifier.empty().toString(), normalizedNode); + }).navigate(YangInstanceIdentifier.of().toString(), normalizedNode); return count.get(); } @Test public void testLeafNodeNotPrunedWhenHasNoParent() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.DESC_QNAME)); - NormalizedNode input = Builders.leafBuilder().withNodeIdentifier( + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.DESC_QNAME)); + NormalizedNode input = Builders.leafBuilder().withNodeIdentifier( new NodeIdentifier(TestModel.DESC_QNAME)).withValue("test").build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); - assertEquals("normalizedNode", input, actual); - } - - @Test - public void testLeafNodePrunedWhenHasAugmentationParentAndSchemaMissing() throws IOException { - AugmentationIdentifier augId = new AugmentationIdentifier(Sets.newHashSet(TestModel.AUG_CONT_QNAME)); - NormalizedNodePruner pruner = prunerFullSchema(YangInstanceIdentifier.builder() - .node(TestModel.TEST_QNAME).node(TestModel.AUGMENTED_LIST_QNAME) - .node(TestModel.AUGMENTED_LIST_QNAME).node(augId).build()); - LeafNode child = Builders.leafBuilder().withNodeIdentifier( - new NodeIdentifier(TestModel.INVALID_QNAME)).withValue("test").build(); - NormalizedNode input = Builders.augmentationBuilder().withNodeIdentifier(augId).withChild(child).build(); - NormalizedNodeWriter.forStreamWriter(pruner).write(input); - - NormalizedNode actual = pruner.normalizedNode(); - assertEquals("normalizedNode", Builders.augmentationBuilder().withNodeIdentifier(augId).build(), actual); + assertEquals("normalizedNode", input, pruner.getResult().orElseThrow()); } @Test public void testLeafNodePrunedWhenHasNoParentAndSchemaMissing() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME)); - NormalizedNode input = Builders.leafBuilder().withNodeIdentifier( - new NodeIdentifier(TestModel.INVALID_QNAME)).withValue("test").build(); + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME)); + LeafNode input = ImmutableNodes.leafNode(TestModel.INVALID_QNAME, "test"); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); - assertNull(actual); + assertEquals(Optional.empty(), pruner.getResult()); } - @Test public void testLeafSetEntryNodeNotPrunedWhenHasNoParent() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.SHOE_QNAME)); - NormalizedNode input = Builders.leafSetEntryBuilder().withValue("puma").withNodeIdentifier( + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.SHOE_QNAME)); + LeafSetEntryNode input = Builders.leafSetEntryBuilder().withValue("puma").withNodeIdentifier( new NodeWithValue<>(TestModel.SHOE_QNAME, "puma")).build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals("normalizedNode", input, actual); } @Test public void testLeafSetEntryNodeNotPrunedWhenHasParent() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.SHOE_QNAME)); + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.SHOE_QNAME)); LeafSetEntryNode child = Builders.leafSetEntryBuilder().withValue("puma").withNodeIdentifier( new NodeWithValue<>(TestModel.SHOE_QNAME, "puma")).build(); - NormalizedNode input = Builders.leafSetBuilder().withNodeIdentifier( + NormalizedNode input = Builders.leafSetBuilder().withNodeIdentifier( new NodeIdentifier(TestModel.SHOE_QNAME)).withChild(child).build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals("normalizedNode", input, actual); } @Test public void testLeafSetEntryNodePrunedWhenHasNoParentAndSchemaMissing() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME)); - NormalizedNode input = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier( + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME)); + NormalizedNode input = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier( new NodeWithValue<>(TestModel.INVALID_QNAME, "test")).build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); - assertNull(actual); + assertEquals(Optional.empty(), pruner.getResult()); } @Test public void testLeafSetEntryNodePrunedWhenHasParentAndSchemaMissing() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME)); + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME)); LeafSetEntryNode child = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier( new NodeWithValue<>(TestModel.INVALID_QNAME, "test")).build(); - NormalizedNode input = Builders.leafSetBuilder().withNodeIdentifier( + NormalizedNode input = Builders.leafSetBuilder().withNodeIdentifier( new NodeIdentifier(TestModel.INVALID_QNAME)).withChild(child).build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); - assertNull(actual); + assertEquals(Optional.empty(), pruner.getResult()); } @Test public void testAnyXMLNodeNotPrunedWhenHasNoParent() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.ANY_XML_QNAME)); - NormalizedNode input = Builders.anyXmlBuilder().withNodeIdentifier( + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.ANY_XML_QNAME)); + NormalizedNode input = Builders.anyXmlBuilder().withNodeIdentifier( new NodeIdentifier(TestModel.ANY_XML_QNAME)).withValue(mock(DOMSource.class)).build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals("normalizedNode", input, actual); } - @Test public void testAnyXMLNodeNotPrunedWhenHasParent() throws IOException { - NormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH); + AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH); DOMSourceAnyxmlNode child = Builders.anyXmlBuilder().withNodeIdentifier( new NodeIdentifier(TestModel.ANY_XML_QNAME)).withValue(mock(DOMSource.class)).build(); - NormalizedNode input = Builders.containerBuilder().withNodeIdentifier( + NormalizedNode input = Builders.containerBuilder().withNodeIdentifier( new NodeIdentifier(TestModel.TEST_QNAME)).withChild(child).build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals("normalizedNode", input, actual); } @Test public void testAnyXmlNodePrunedWhenHasNoParentAndSchemaMissing() throws IOException { - NormalizedNodePruner pruner = prunerNoTestSchema(TestModel.TEST_PATH.node(TestModel.ANY_XML_QNAME)); - NormalizedNode input = Builders.anyXmlBuilder().withNodeIdentifier( + AbstractNormalizedNodePruner pruner = prunerNoTestSchema(TestModel.TEST_PATH.node(TestModel.ANY_XML_QNAME)); + NormalizedNode input = Builders.anyXmlBuilder().withNodeIdentifier( new NodeIdentifier(TestModel.ANY_XML_QNAME)).withValue(mock(DOMSource.class)).build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); - assertNull(actual); + assertEquals(Optional.empty(), pruner.getResult()); } @Test @@ -284,12 +256,12 @@ public class NormalizedNodePrunerTest { .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) .node(TestModel.INNER_LIST_QNAME).nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one") .node(TestModel.INNER_CONTAINER_QNAME).build(); - NormalizedNodePruner pruner = prunerFullSchema(path); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); - NormalizedNode input = ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME); + NormalizedNode input = ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals("normalizedNode", input, actual); } @@ -299,13 +271,12 @@ public class NormalizedNodePrunerTest { .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) .node(TestModel.INNER_LIST_QNAME).nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one") .node(TestModel.INVALID_QNAME).build(); - NormalizedNodePruner pruner = prunerFullSchema(path); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); - NormalizedNode input = ImmutableNodes.containerNode(TestModel.INVALID_QNAME); + ContainerNode input = ImmutableNodes.containerNode(TestModel.INVALID_QNAME); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); - assertNull(actual); + assertEquals(Optional.empty(), pruner.getResult()); } @Test @@ -313,19 +284,19 @@ public class NormalizedNodePrunerTest { YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(TestModel.TEST_QNAME) .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) .build(); - NormalizedNodePruner pruner = prunerFullSchema(path); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); MapNode innerList = mapNodeBuilder(TestModel.INNER_LIST_QNAME).withChild(mapEntryBuilder( TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one").withChild( ImmutableNodes.containerNode(TestModel.INVALID_QNAME)).build()).build(); - NormalizedNode input = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + MapEntryNode input = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) .withChild(innerList).build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode expected = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + MapEntryNode expected = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) .withChild(mapNodeBuilder(TestModel.INNER_LIST_QNAME).withChild(mapEntryBuilder( TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one").build()).build()).build(); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals("normalizedNode", expected, actual); } @@ -334,14 +305,14 @@ public class NormalizedNodePrunerTest { YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(TestModel.TEST_QNAME) .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) .node(TestModel.INNER_LIST_QNAME).build(); - NormalizedNodePruner pruner = prunerFullSchema(path); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); MapNode input = mapNodeBuilder(TestModel.INNER_LIST_QNAME).withChild(mapEntryBuilder( TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one").withChild( ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME)).build()).build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals("normalizedNode", input, actual); } @@ -350,15 +321,14 @@ public class NormalizedNodePrunerTest { YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(TestModel.TEST_QNAME) .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) .node(TestModel.INVALID_QNAME).build(); - NormalizedNodePruner pruner = prunerFullSchema(path); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); MapNode input = mapNodeBuilder(TestModel.INVALID_QNAME).withChild(mapEntryBuilder( TestModel.INVALID_QNAME, TestModel.NAME_QNAME, "one").withChild( ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME)).build()).build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode actual = pruner.normalizedNode(); - assertNull(actual); + assertEquals(Optional.empty(), pruner.getResult()); } @Test @@ -366,33 +336,38 @@ public class NormalizedNodePrunerTest { YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(TestModel.TEST_QNAME) .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) .build(); - NormalizedNodePruner pruner = prunerFullSchema(path); + AbstractNormalizedNodePruner pruner = prunerFullSchema(path); MapNode innerList = mapNodeBuilder(TestModel.INVALID_QNAME).withChild(mapEntryBuilder( TestModel.INVALID_QNAME, TestModel.NAME_QNAME, "one").withChild( ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME)).build()).build(); - NormalizedNode input = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) + NormalizedNode input = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1) .withChild(innerList).build(); NormalizedNodeWriter.forStreamWriter(pruner).write(input); - NormalizedNode expected = mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1); - NormalizedNode actual = pruner.normalizedNode(); + NormalizedNode expected = mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1); + NormalizedNode actual = pruner.getResult().orElseThrow(); assertEquals("normalizedNode", expected, actual); } - private static NormalizedNode createTestContainer() { + private static NormalizedNode createTestContainer() { byte[] bytes1 = {1, 2, 3}; - LeafSetEntryNode entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier( - new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).withValue(bytes1).build(); + LeafSetEntryNode entry1 = Builders.leafSetEntryBuilder() + .withNodeIdentifier(new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)) + .withValue(bytes1) + .build(); byte[] bytes2 = {}; - LeafSetEntryNode entry2 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier( - new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes2)).withValue(bytes2).build(); + LeafSetEntryNode entry2 = Builders.leafSetEntryBuilder() + .withNodeIdentifier(new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes2)) + .withValue(bytes2).build(); return TestModel.createBaseTestContainerBuilder() - .withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier( - new NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME)) - .withChild(entry1).withChild(entry2).build()) + .withChild(Builders.leafSetBuilder() + .withNodeIdentifier(new NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME)) + .withChild(entry1) + .withChild(entry2) + .build()) .withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1, 2, 3, 4})) .build(); }