*/
package org.opendaylight.yangtools.yang.data.impl.schema;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.isA;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.fromInstanceId;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
import java.util.Map;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.util.ImmutableOffsetMap;
import org.opendaylight.yangtools.yang.common.QName;
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.NodeIdentifierWithPredicates;
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.LeafNode;
-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.spi.node.ImmutableNodes;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
-public class InstanceIdToNodesTest {
+class InstanceIdToNodesTest {
private static final String NS = "urn:opendaylight:params:xml:ns:yang:controller:md:sal:normalization:test";
private static final String REVISION = "2014-03-13";
private static final QName BAR = QName.create(ID, "bar");
private static final NodeIdentifier TWO_KEY_LIST = NodeIdentifier.create(QName.create(ID, "two-key-list"));
- private static SchemaContext ctx;
+ private static EffectiveModelContext ctx;
private final NodeIdentifier rootContainer = new NodeIdentifier(QName.create(NS, REVISION, "test"));
- private final NodeIdentifier outerContainer = new NodeIdentifier(QName.create(NS, REVISION, "outer-container"));
- private final NodeIdentifier augmentedLeaf = new NodeIdentifier(QName.create(NS, REVISION, "augmented-leaf"));
- private final AugmentationIdentifier augmentation = new AugmentationIdentifier(
- ImmutableSet.of(augmentedLeaf.getNodeType()));
-
private final NodeIdentifier outerList = new NodeIdentifier(QName.create(NS, REVISION, "outer-list"));
private final NodeIdentifierWithPredicates outerListWithKey = NodeIdentifierWithPredicates.of(
QName.create(NS, REVISION, "outer-list"), ID, 1);
- private final NodeIdentifier choice = new NodeIdentifier(QName.create(NS, REVISION, "outer-choice"));
- private final NodeIdentifier leafFromCase = new NodeIdentifier(QName.create(NS, REVISION, "one"));
private final NodeIdentifier leafList = new NodeIdentifier(QName.create(NS, REVISION, "ordered-leaf-list"));
- private final NodeWithValue<?> leafListWithValue = new NodeWithValue<>(leafList.getNodeType(), "abcd");
+ private final NodeWithValue<String> leafListWithValue = new NodeWithValue<>(leafList.getNodeType(), "abcd");
- @BeforeClass
- public static void setUp() {
+ @BeforeAll
+ static void setUp() {
ctx = YangParserTestUtils.parseYangResources(InstanceIdToNodesTest.class, "/filter-test.yang");
}
- @AfterClass
- public static void teardown() {
+ @AfterAll
+ static void teardown() {
ctx = null;
}
@Test
- public void testInAugment() {
- final LeafNode<?> leaf = Builders.leafBuilder().withNodeIdentifier(augmentedLeaf).withValue("").build();
- final ContainerNode expectedFilter = Builders
- .containerBuilder()
- .withNodeIdentifier(rootContainer)
- .withChild(
- Builders.containerBuilder()
- .withNodeIdentifier(outerContainer)
- .withChild(
- Builders.augmentationBuilder()
- .withNodeIdentifier(augmentation)
- .withChild(
- leaf).build()).build()).build();
-
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf), leaf);
- assertEquals(expectedFilter, filter);
- }
-
- @Test
- public void testInAugmentLeafOverride() {
- final LeafNode<Object> lastLeaf = Builders.leafBuilder().withNodeIdentifier(augmentedLeaf)
- .withValue("randomValue").build();
-
- final ContainerNode expectedFilter = Builders
- .containerBuilder()
- .withNodeIdentifier(rootContainer)
- .withChild(
- Builders.containerBuilder()
- .withNodeIdentifier(outerContainer)
- .withChild(
- Builders.augmentationBuilder().withNodeIdentifier(augmentation)
- .withChild(lastLeaf).build()).build()).build();
-
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf), lastLeaf);
- assertEquals(expectedFilter, filter);
- }
-
- @Test
- public void testListChoice() {
- final LeafNode<?> leaf = Builders.leafBuilder().withNodeIdentifier(leafFromCase).withValue("").build();
- final ContainerNode expectedFilter = Builders
- .containerBuilder()
- .withNodeIdentifier(rootContainer)
- .withChild(
- Builders.mapBuilder()
- .withNodeIdentifier(outerList)
- .withChild(
- Builders.mapEntryBuilder()
- .withNodeIdentifier(outerListWithKey)
- .withChild(
- Builders.leafBuilder()
- .withNodeIdentifier(
- new NodeIdentifier(ID))
- .withValue(1).build())
- .withChild(
- Builders.choiceBuilder()
- .withNodeIdentifier(choice)
- .withChild(leaf)
- .build())
- .build())
- .build())
- .build();
-
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey, choice, leafFromCase), leaf);
- assertEquals(expectedFilter, filter);
- }
-
- @Test
- public void testTopContainerLastChildOverride() {
- final ContainerNode expectedStructure = Builders
- .containerBuilder()
- .withNodeIdentifier(rootContainer)
- .withChild(
- Builders.mapBuilder()
- .withNodeIdentifier(outerList)
- .withChild(
- Builders.mapEntryBuilder()
- .withNodeIdentifier(outerListWithKey)
- .withChild(
- Builders.leafBuilder()
- .withNodeIdentifier(
- new NodeIdentifier(ID))
- .withValue(1).build())
- .withChild(
- Builders.choiceBuilder()
- .withNodeIdentifier(choice)
- .withChild(
- Builders.leafBuilder()
- .withNodeIdentifier(leafFromCase)
- .withValue("")
- .build()).build()).build()).build())
- .build();
-
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer), expectedStructure);
- assertEquals(expectedStructure, filter);
+ void testListLastChildOverride() {
+ assertEquals(ImmutableNodes.newContainerBuilder()
+ .withNodeIdentifier(rootContainer)
+ .withChild(ImmutableNodes.newSystemMapBuilder()
+ .withNodeIdentifier(outerList)
+ .withChild(ImmutableNodes.newMapEntryBuilder()
+ .withNodeIdentifier(outerListWithKey)
+ .withChild(ImmutableNodes.leafNode(new NodeIdentifier(ID), 1))
+ .build())
+ .build())
+ .build(),
+ fromInstanceId(ctx, YangInstanceIdentifier.of(rootContainer, outerList, outerListWithKey)));
}
@Test
- public void testListLastChildOverride() {
- final MapEntryNode outerListEntry = Builders
- .mapEntryBuilder()
- .withNodeIdentifier(outerListWithKey)
- .withChild(
- Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(ID))
- .withValue(1).build()).build();
- final MapNode lastChild = Builders.mapBuilder().withNodeIdentifier(this.outerList).withChild(outerListEntry)
- .build();
- final ContainerNode expectedStructure = Builders.containerBuilder().withNodeIdentifier(rootContainer)
- .withChild(lastChild).build();
-
- NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey), outerListEntry);
- assertEquals(expectedStructure, filter);
- filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey));
- assertEquals(expectedStructure, filter);
- }
-
- @Test
- public void testLeafList() {
- final ContainerNode expectedFilter = Builders
- .containerBuilder()
- .withNodeIdentifier(rootContainer)
- .withChild(
- Builders.orderedLeafSetBuilder()
- .withNodeIdentifier(leafList)
- .withChild(
- Builders.leafSetEntryBuilder().withNodeIdentifier(leafListWithValue)
- .withValue(leafListWithValue.getValue()).build()).build()).build();
-
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, leafList, leafListWithValue));
- assertEquals(expectedFilter, filter);
+ void testLeafList() {
+ assertEquals(ImmutableNodes.newContainerBuilder()
+ .withNodeIdentifier(rootContainer)
+ .withChild(Builders.<String>orderedLeafSetBuilder()
+ .withNodeIdentifier(leafList)
+ .withChild(Builders.<String>leafSetEntryBuilder()
+ .withNodeIdentifier(leafListWithValue)
+ .withValue(leafListWithValue.getValue())
+ .build())
+ .build())
+ .build(),
+ fromInstanceId(ctx, YangInstanceIdentifier.of(rootContainer, leafList, leafListWithValue)));
}
@Test
- public void testEmptyInstanceIdentifier() {
- assertEquals(ImmutableNodes.containerNode(SchemaContext.NAME),
- ImmutableNodes.fromInstanceId(ctx, YangInstanceIdentifier.empty()));
+ void testEmptyInstanceIdentifier() {
+ assertEquals(ImmutableNodes.newContainerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(SchemaContext.NAME))
+ .build(), fromInstanceId(ctx, YangInstanceIdentifier.of()));
}
@Test
- public void testKeyOrdering() {
+ void testKeyOrdering() {
final Map<QName, Object> misordered = ImmutableOffsetMap.orderedCopyOf(ImmutableMap.of(BAR, "bar", FOO, "foo"));
- final NodeIdentifierWithPredicates id = NodeIdentifierWithPredicates.of(TWO_KEY_LIST.getNodeType(), misordered);
+ final var id = NodeIdentifierWithPredicates.of(TWO_KEY_LIST.getNodeType(), misordered);
assertArrayEquals(new Object[] { BAR, FOO }, id.keySet().toArray());
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(TWO_KEY_LIST, id));
- assertThat(filter, isA(MapNode.class));
- final Collection<MapEntryNode> value = ((MapNode) filter).body();
+ final var filter = fromInstanceId(ctx, YangInstanceIdentifier.of(TWO_KEY_LIST, id));
+ final var value = assertInstanceOf(MapNode.class, filter).body();
assertEquals(1, value.size());
- final MapEntryNode entry = value.iterator().next();
+ final var entry = value.iterator().next();
// The entry must have a the proper order
- assertArrayEquals(new Object[] { FOO, BAR }, entry.getIdentifier().keySet().toArray());
+ assertArrayEquals(new Object[] { FOO, BAR }, entry.name().keySet().toArray());
}
}
Code Review / yangtools.git / blobdiff