/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
*/
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 com.google.common.base.Function;
-import com.google.common.collect.Collections2;
-import com.google.common.io.ByteSource;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Collections;
-import org.junit.Before;
+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.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.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
-import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public 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 ID = QName.create(NS, REVISION, "id");
- private SchemaContext ctx;
-
- private final YangInstanceIdentifier.NodeIdentifier rootContainer = new YangInstanceIdentifier.NodeIdentifier(QName.create(NS, REVISION, "test"));
- private final YangInstanceIdentifier.NodeIdentifier outerContainer = new YangInstanceIdentifier.NodeIdentifier(QName.create(NS, REVISION, "outer-container"));
- private final YangInstanceIdentifier.NodeIdentifier augmentedLeaf = new YangInstanceIdentifier.NodeIdentifier(QName.create(NS, REVISION, "augmented-leaf"));
- private final YangInstanceIdentifier.AugmentationIdentifier augmentation = new YangInstanceIdentifier.AugmentationIdentifier(Collections.singleton(augmentedLeaf.getNodeType()));
-
- private final YangInstanceIdentifier.NodeIdentifier outerList = new YangInstanceIdentifier.NodeIdentifier(QName.create(NS, REVISION, "outer-list"));
- private final YangInstanceIdentifier.NodeIdentifierWithPredicates outerListWithKey = new YangInstanceIdentifier.NodeIdentifierWithPredicates(QName.create(NS, REVISION, "outer-list"), ID, 1);
- private final YangInstanceIdentifier.NodeIdentifier choice = new YangInstanceIdentifier.NodeIdentifier(QName.create(NS, REVISION, "outer-choice"));
- private final YangInstanceIdentifier.NodeIdentifier leafFromCase = new YangInstanceIdentifier.NodeIdentifier(QName.create(NS, REVISION, "one"));
-
- private final YangInstanceIdentifier.NodeIdentifier leafList = new YangInstanceIdentifier.NodeIdentifier(QName.create(NS, REVISION, "ordered-leaf-list"));
- private final YangInstanceIdentifier.NodeWithValue leafListWithValue = new YangInstanceIdentifier.NodeWithValue(leafList.getNodeType(), "abcd");
-
- static SchemaContext createTestContext() throws IOException, YangSyntaxErrorException {
- final YangParserImpl parser = new YangParserImpl();
- return parser.parseSources(Collections2.transform(Collections.singletonList("/filter-test.yang"), new Function<String, ByteSource>() {
- @Override
- public ByteSource apply(final String input) {
- return new ByteSource() {
- @Override
- public InputStream openStream() throws IOException {
- return InstanceIdToNodesTest.class.getResourceAsStream(input);
- }
- };
- }
- }));
+ private static final QName FOO = QName.create(ID, "foo");
+ 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 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");
+
+ @BeforeClass
+ public static void setUp() {
+ ctx = YangParserTestUtils.parseYangResources(InstanceIdToNodesTest.class, "/filter-test.yang");
}
- @Before
- public void setUp() throws Exception {
- ctx = createTestContext();
-
+ @AfterClass
+ public static void teardown() {
+ ctx = null;
}
@Test
- public void testInAugment() throws Exception {
- final ContainerNode expectedFilter = Builders.containerBuilder().withNodeIdentifier(rootContainer).withChild(
- Builders.containerBuilder().withNodeIdentifier(outerContainer).withChild(
- Builders.augmentationBuilder().withNodeIdentifier(augmentation).withChild(
- Builders.leafBuilder().withNodeIdentifier(augmentedLeaf).build()
- ).build()
- ).build()
- ).build();
-
- final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx, YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf));
+ 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() throws Exception {
- 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);
+ 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() throws Exception {
- final ContainerNode expectedFilter = Builders.containerBuilder().withNodeIdentifier(rootContainer).withChild(
- Builders.mapBuilder().withNodeIdentifier(outerList).withChild(
- Builders.mapEntryBuilder().withNodeIdentifier(outerListWithKey).withChild(
- Builders.leafBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(ID)).withValue(1).build()
- ).withChild(
- Builders.choiceBuilder().withNodeIdentifier(choice).withChild(
- Builders.leafBuilder().withNodeIdentifier(leafFromCase).build()
- ).build()
- ).build()
- ).build()
- ).build();
-
- final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx, YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey, choice, leafFromCase));
+ 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() throws Exception {
- final ContainerNode expectedStructure = Builders.containerBuilder().withNodeIdentifier(rootContainer).withChild(
- Builders.mapBuilder().withNodeIdentifier(outerList).withChild(
- Builders.mapEntryBuilder().withNodeIdentifier(outerListWithKey).withChild(
- Builders.leafBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(ID)).withValue(1).build()
- ).withChild(
- Builders.choiceBuilder().withNodeIdentifier(choice).withChild(
- Builders.leafBuilder().withNodeIdentifier(leafFromCase).build()
- ).build()
- ).build()
- ).build()
- ).build();
-
- final NormalizedNode<?, ?> filter = ImmutableNodes.fromInstanceId(ctx, YangInstanceIdentifier.create(rootContainer), expectedStructure);
+ 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);
}
@Test
- public void testListLastChildOverride() throws Exception {
- final MapEntryNode outerListEntry = Builders.mapEntryBuilder().withNodeIdentifier(outerListWithKey).withChild(
- Builders.leafBuilder().withNodeIdentifier(new YangInstanceIdentifier.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);
+ 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));
+ filter = ImmutableNodes.fromInstanceId(ctx,
+ YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey));
assertEquals(expectedStructure, filter);
}
@Test
- public void testLeafList() throws Exception {
- 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));
+ 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);
}
-}
\ No newline at end of file
+
+ @Test
+ public void testEmptyInstanceIdentifier() {
+ assertEquals(ImmutableNodes.containerNode(SchemaContext.NAME),
+ ImmutableNodes.fromInstanceId(ctx, YangInstanceIdentifier.empty()));
+ }
+
+ @Test
+ public 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);
+ 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).getValue();
+ assertEquals(1, value.size());
+ final MapEntryNode entry = value.iterator().next();
+
+ // The entry must have a the proper order
+ assertArrayEquals(new Object[] { FOO, BAR }, entry.getIdentifier().keySet().toArray());
+ }
+}