import java.net.URI;
import java.util.Map;
import org.jaxen.Function;
-import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
public class DerefXPathFunctionTest {
- private static JaxenSchemaContextFactory jaxenSchemaContextFactory;
-
- private static QNameModule fooModule;
- private static QName myContainer;
- private static QName myInnerContainer;
- private static QName myList;
- private static QName keyLeafA;
- private static QName keyLeafB;
- private static QName iidLeaf;
- private static QName referencedLeaf;
- private static QName referencedLeafList;
- private static QName absLeafrefLeaf;
- private static QName relLeafrefLeaf;
- private static QName leafListLeafrefLeaf;
- private static QName ordinaryLeafA;
- private static QName ordinaryLeafB;
-
- @BeforeClass
- public static void setup() {
- jaxenSchemaContextFactory = new JaxenSchemaContextFactory();
-
- fooModule = QNameModule.create(URI.create("foo-ns"), Revision.of("2017-04-03"));
- myContainer = QName.create(fooModule, "my-container");
- myInnerContainer = QName.create(fooModule, "my-inner-container");
- myList = QName.create(fooModule, "my-list");
- keyLeafA = QName.create(fooModule, "key-leaf-a");
- keyLeafB = QName.create(fooModule, "key-leaf-b");
- iidLeaf = QName.create(fooModule, "iid-leaf");
- referencedLeaf = QName.create(fooModule, "referenced-leaf");
- referencedLeafList = QName.create(fooModule, "referenced-leaf-list");
- absLeafrefLeaf = QName.create(fooModule, "abs-leafref-leaf");
- relLeafrefLeaf = QName.create(fooModule, "rel-leafref-leaf");
- leafListLeafrefLeaf = QName.create(fooModule, "leaf-list-leafref-leaf");
- ordinaryLeafA = QName.create(fooModule, "ordinary-leaf-a");
- ordinaryLeafB = QName.create(fooModule, "ordinary-leaf-b");
- }
+ private static JaxenSchemaContextFactory jaxenSchemaContextFactory = new JaxenSchemaContextFactory();
+
+ private static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo-ns"), Revision.of("2017-04-03"));
+ private static final QName MY_CONTAINER = QName.create(FOO_MODULE, "my-container");
+ private static final QName MY_INNER_CONTAINER = QName.create(FOO_MODULE, "my-inner-container");
+ private static final QName MY_LIST = QName.create(FOO_MODULE, "my-list");
+ private static final QName KEY_LEAF_A = QName.create(FOO_MODULE, "key-leaf-a");
+ private static final QName KEY_LEAF_B = QName.create(FOO_MODULE, "key-leaf-b");
+ private static final QName IID_LEAF = QName.create(FOO_MODULE, "iid-leaf");
+ private static final QName REFERENCED_LEAF = QName.create(FOO_MODULE, "referenced-leaf");
+ private static final QName REFERENCED_LEAFLIST = QName.create(FOO_MODULE, "referenced-leaf-list");
+ private static final QName ABS_LEAFREF_LEAF = QName.create(FOO_MODULE, "abs-leafref-leaf");
+ private static final QName REL_LEAFREF_LEAF = QName.create(FOO_MODULE, "rel-leafref-leaf");
+ private static final QName LEAFLIST_LEAFREF_LEAF = QName.create(FOO_MODULE, "leaf-list-leafref-leaf");
+ private static final QName ORDINARY_LEAF_A = QName.create(FOO_MODULE, "ordinary-leaf-a");
+ private static final QName ORDINARY_LEAF_B = QName.create(FOO_MODULE, "ordinary-leaf-b");
@Test
public void testDerefFunctionForInstanceIdentifier() throws Exception {
final XPathSchemaContext jaxenSchemaContext = jaxenSchemaContextFactory.createContext(schemaContext);
final LeafNode<?> referencedLeafNode = Builders.leafBuilder().withNodeIdentifier(
- new NodeIdentifier(referencedLeaf)).withValue("referenced-leaf-node-value").build();
+ new NodeIdentifier(REFERENCED_LEAF)).withValue("referenced-leaf-node-value").build();
final XPathDocument jaxenDocument = jaxenSchemaContext.createDocument(buildMyContainerNodeForIIdTest(
referencedLeafNode));
final BiMap<String, QNameModule> converterBiMap = HashBiMap.create();
- converterBiMap.put("foo-prefix", fooModule);
+ converterBiMap.put("foo-prefix", FOO_MODULE);
final NormalizedNodeContextSupport normalizedNodeContextSupport = NormalizedNodeContextSupport.create(
(JaxenDocument) jaxenDocument, Maps.asConverter(converterBiMap));
final XPathSchemaContext jaxenSchemaContext = jaxenSchemaContextFactory.createContext(schemaContext);
final LeafNode<?> referencedLeafNode = Builders.leafBuilder().withNodeIdentifier(
- new NodeIdentifier(referencedLeaf)).withValue("referenced-leaf-node-value").build();
+ new NodeIdentifier(REFERENCED_LEAF)).withValue("referenced-leaf-node-value").build();
final XPathDocument jaxenDocument = jaxenSchemaContext.createDocument(buildMyContainerNodeForLeafrefTest(
referencedLeafNode));
final BiMap<String, QNameModule> converterBiMap = HashBiMap.create();
- converterBiMap.put("foo-prefix", fooModule);
+ converterBiMap.put("foo-prefix", FOO_MODULE);
final NormalizedNodeContextSupport normalizedNodeContextSupport = NormalizedNodeContextSupport.create(
(JaxenDocument) jaxenDocument, Maps.asConverter(converterBiMap));
- final YangInstanceIdentifier absLeafrefPath = YangInstanceIdentifier.of(myInnerContainer).node(absLeafrefLeaf);
+ final YangInstanceIdentifier absLeafrefPath = YangInstanceIdentifier.of(MY_INNER_CONTAINER)
+ .node(ABS_LEAFREF_LEAF);
NormalizedNodeContext normalizedNodeContext = normalizedNodeContextSupport.createContext(absLeafrefPath);
final Function derefFunction = normalizedNodeContextSupport.getFunctionContext()
assertTrue(derefResult instanceof NormalizedNode<?, ?>);
assertSame(referencedLeafNode, derefResult);
- final YangInstanceIdentifier relLeafrefPath = YangInstanceIdentifier.of(myInnerContainer).node(relLeafrefLeaf);
+ final YangInstanceIdentifier relLeafrefPath = YangInstanceIdentifier.of(MY_INNER_CONTAINER)
+ .node(REL_LEAFREF_LEAF);
normalizedNodeContext = normalizedNodeContextSupport.createContext(relLeafrefPath);
derefResult = derefFunction.call(normalizedNodeContext, ImmutableList.of());
final XPathSchemaContext jaxenSchemaContext = jaxenSchemaContextFactory.createContext(schemaContext);
final LeafSetNode<?> referencedLeafListNode = Builders.leafSetBuilder().withNodeIdentifier(
- new NodeIdentifier(referencedLeafList))
+ new NodeIdentifier(REFERENCED_LEAFLIST))
.withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
- new NodeWithValue<>(referencedLeafList, "referenced-node-entry-value-a"))
+ new NodeWithValue<>(REFERENCED_LEAFLIST, "referenced-node-entry-value-a"))
.withValue("referenced-node-entry-value-a").build())
.withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
- new NodeWithValue<>(referencedLeafList, "referenced-node-entry-value-b"))
+ new NodeWithValue<>(REFERENCED_LEAFLIST, "referenced-node-entry-value-b"))
.withValue("referenced-node-entry-value-b").build())
.withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
- new NodeWithValue<>(referencedLeafList, "referenced-node-entry-value-c"))
+ new NodeWithValue<>(REFERENCED_LEAFLIST, "referenced-node-entry-value-c"))
.withValue("referenced-node-entry-value-c").build())
.build();
referencedLeafListNode));
final BiMap<String, QNameModule> converterBiMap = HashBiMap.create();
- converterBiMap.put("foo-prefix", fooModule);
+ converterBiMap.put("foo-prefix", FOO_MODULE);
final NormalizedNodeContextSupport normalizedNodeContextSupport = NormalizedNodeContextSupport.create(
(JaxenDocument) jaxenDocument, Maps.asConverter(converterBiMap));
- final YangInstanceIdentifier leafListLeafrefPath = YangInstanceIdentifier.of(myInnerContainer)
- .node(leafListLeafrefLeaf);
+ final YangInstanceIdentifier leafListLeafrefPath = YangInstanceIdentifier.of(MY_INNER_CONTAINER)
+ .node(LEAFLIST_LEAFREF_LEAF);
final NormalizedNodeContext normalizedNodeContext = normalizedNodeContextSupport
.createContext(leafListLeafrefPath);
assertTrue(derefResult instanceof NormalizedNode<?, ?>);
final LeafSetEntryNode<?> referencedLeafListNodeEntry = referencedLeafListNode.getChild(
- new NodeWithValue<>(referencedLeafList, "referenced-node-entry-value-b")).get();
+ new NodeWithValue<>(REFERENCED_LEAFLIST, "referenced-node-entry-value-b")).get();
assertSame(referencedLeafListNodeEntry, derefResult);
}
private static ContainerNode buildMyContainerNodeForIIdTest(final LeafNode<?> referencedLeafNode) {
- final Map<QName, Object> keyValues = ImmutableMap.of(keyLeafA, "key-value-a", keyLeafB, "key-value-b");
- final YangInstanceIdentifier iidPath = YangInstanceIdentifier.of(myContainer).node(myList)
- .node(new NodeIdentifierWithPredicates(myList, keyValues)).node(referencedLeaf);
+ final Map<QName, Object> keyValues = ImmutableMap.of(KEY_LEAF_A, "key-value-a", KEY_LEAF_B, "key-value-b");
+ final YangInstanceIdentifier iidPath = YangInstanceIdentifier.of(MY_CONTAINER).node(MY_LIST)
+ .node(new NodeIdentifierWithPredicates(MY_LIST, keyValues)).node(REFERENCED_LEAF);
- final LeafNode<?> iidLeafNode = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(iidLeaf))
+ final LeafNode<?> iidLeafNode = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(IID_LEAF))
.withValue(iidPath).build();
- final MapNode myListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myList))
+ final MapNode myListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(MY_LIST))
.withChild(Builders.mapEntryBuilder().withNodeIdentifier(
- new NodeIdentifierWithPredicates(myList, keyValues))
+ new NodeIdentifierWithPredicates(MY_LIST, keyValues))
.withChild(iidLeafNode)
.withChild(referencedLeafNode).build())
.build();
final ContainerNode myContainerNode = Builders.containerBuilder().withNodeIdentifier(
- new NodeIdentifier(myContainer)).withChild(myListNode).build();
+ new NodeIdentifier(MY_CONTAINER)).withChild(myListNode).build();
return myContainerNode;
}
private static YangInstanceIdentifier buildPathToIIdLeafNode() {
- final Map<QName, Object> keyValues = ImmutableMap.of(keyLeafA, "key-value-a", keyLeafB, "key-value-b");
- final YangInstanceIdentifier path = YangInstanceIdentifier.of(myList)
- .node(new NodeIdentifierWithPredicates(myList, keyValues)).node(iidLeaf);
+ final Map<QName, Object> keyValues = ImmutableMap.of(KEY_LEAF_A, "key-value-a", KEY_LEAF_B, "key-value-b");
+ final YangInstanceIdentifier path = YangInstanceIdentifier.of(MY_LIST)
+ .node(new NodeIdentifierWithPredicates(MY_LIST, keyValues)).node(IID_LEAF);
return path;
}
// variant for a leafref that references a leaf
private static ContainerNode buildMyContainerNodeForLeafrefTest(final LeafNode<?> referencedLeafNode) {
- final Map<QName, Object> keyValues = ImmutableMap.of(keyLeafA, "value-a", keyLeafB, "value-b");
+ final Map<QName, Object> keyValues = ImmutableMap.of(KEY_LEAF_A, "value-a", KEY_LEAF_B, "value-b");
- final LeafNode<?> absLeafrefNode = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(absLeafrefLeaf))
+ final LeafNode<?> absLeafrefNode = Builders.leafBuilder()
+ .withNodeIdentifier(new NodeIdentifier(ABS_LEAFREF_LEAF))
.withValue("referenced-leaf-node-value").build();
- final LeafNode<?> relLeafrefNode = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(relLeafrefLeaf))
+ final LeafNode<?> relLeafrefNode = Builders.leafBuilder()
+ .withNodeIdentifier(new NodeIdentifier(REL_LEAFREF_LEAF))
.withValue("referenced-leaf-node-value").build();
final LeafNode<?> ordinaryLeafANode = Builders.leafBuilder().withNodeIdentifier(
- new NodeIdentifier(ordinaryLeafA)).withValue("value-a").build();
+ new NodeIdentifier(ORDINARY_LEAF_A)).withValue("value-a").build();
final LeafNode<?> ordinaryLeafBNode = Builders.leafBuilder().withNodeIdentifier(
- new NodeIdentifier(ordinaryLeafB)).withValue("value-b").build();
+ new NodeIdentifier(ORDINARY_LEAF_B)).withValue("value-b").build();
- final MapNode myListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myList))
+ final MapNode myListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(MY_LIST))
.withChild(Builders.mapEntryBuilder().withNodeIdentifier(
- new NodeIdentifierWithPredicates(myList, keyValues))
+ new NodeIdentifierWithPredicates(MY_LIST, keyValues))
.withChild(referencedLeafNode).build())
.build();
final ContainerNode myInnerContainerNode = Builders.containerBuilder().withNodeIdentifier(
- new NodeIdentifier(myInnerContainer))
+ new NodeIdentifier(MY_INNER_CONTAINER))
.withChild(absLeafrefNode)
.withChild(relLeafrefNode)
.withChild(ordinaryLeafANode)
.withChild(ordinaryLeafBNode).build();
final ContainerNode myContainerNode = Builders.containerBuilder().withNodeIdentifier(
- new NodeIdentifier(myContainer))
+ new NodeIdentifier(MY_CONTAINER))
.withChild(myListNode)
.withChild(myInnerContainerNode).build();
return myContainerNode;
// variant for a leafref that references a leaf-list
private static ContainerNode buildMyContainerNodeForLeafrefTest(final LeafSetNode<?> referencedLeafListNode) {
final LeafNode<?> leafListLeafrefNode = Builders.leafBuilder().withNodeIdentifier(
- new NodeIdentifier(leafListLeafrefLeaf)).withValue("referenced-node-entry-value-b").build();
+ new NodeIdentifier(LEAFLIST_LEAFREF_LEAF)).withValue("referenced-node-entry-value-b").build();
final LeafNode<?> ordinaryLeafANode = Builders.leafBuilder().withNodeIdentifier(
- new NodeIdentifier(ordinaryLeafA)).withValue("value-a").build();
+ new NodeIdentifier(ORDINARY_LEAF_A)).withValue("value-a").build();
final LeafNode<?> ordinaryLeafBNode = Builders.leafBuilder().withNodeIdentifier(
- new NodeIdentifier(ordinaryLeafB)).withValue("value-b").build();
+ new NodeIdentifier(ORDINARY_LEAF_B)).withValue("value-b").build();
final ContainerNode myInnerContainerNode = Builders.containerBuilder().withNodeIdentifier(
- new NodeIdentifier(myInnerContainer))
+ new NodeIdentifier(MY_INNER_CONTAINER))
.withChild(leafListLeafrefNode)
.withChild(ordinaryLeafANode)
.withChild(ordinaryLeafBNode).build();
- final Map<QName, Object> keyValues = ImmutableMap.of(keyLeafA, "value-a", keyLeafB, "value-b");
+ final Map<QName, Object> keyValues = ImmutableMap.of(KEY_LEAF_A, "value-a", KEY_LEAF_B, "value-b");
- final MapNode myListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myList))
+ final MapNode myListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(MY_LIST))
.withChild(Builders.mapEntryBuilder().withNodeIdentifier(
- new NodeIdentifierWithPredicates(myList, keyValues))
+ new NodeIdentifierWithPredicates(MY_LIST, keyValues))
.withChild(referencedLeafListNode).build())
.build();
final ContainerNode myContainerNode = Builders.containerBuilder().withNodeIdentifier(
- new NodeIdentifier(myContainer))
+ new NodeIdentifier(MY_CONTAINER))
.withChild(myListNode)
.withChild(myInnerContainerNode).build();
return myContainerNode;
Code Review / yangtools.git / blobdiff