* 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.yangtools.yang.binding.test;\r
-\r
-import static org.junit.Assert.*;\r
-\r
-import org.junit.Test;\r
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
-import org.opendaylight.yangtools.yang.binding.test.mock.FooChild;\r
-import org.opendaylight.yangtools.yang.binding.test.mock.InstantiatedFoo;\r
-import org.opendaylight.yangtools.yang.binding.test.mock.Node;\r
-import org.opendaylight.yangtools.yang.binding.test.mock.NodeChild;\r
-import org.opendaylight.yangtools.yang.binding.test.mock.NodeChildKey;\r
-import org.opendaylight.yangtools.yang.binding.test.mock.NodeKey;\r
-import org.opendaylight.yangtools.yang.binding.test.mock.Nodes;\r
-\r
-public class InstanceIdentifierTest {\r
-\r
- @Test\r
- public void constructWithPredicates() {\r
- \r
- InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).toInstance();\r
- \r
- assertNotNull(nodes);\r
- assertEquals(Nodes.class, nodes.getTargetType());\r
- \r
- \r
- InstanceIdentifier<Node> node = InstanceIdentifier.builder(nodes).node(Node.class).toInstance();\r
- \r
- assertNotNull(node);\r
- assertEquals(Node.class, node.getTargetType());\r
- \r
- assertTrue(nodes.contains(node));\r
- }\r
-\r
- @Test\r
- public void fluentConstruction() {\r
-\r
- InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).toInstance();\r
- InstanceIdentifier<Node> node = InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).toInstance();\r
-\r
- assertNotNull(node);\r
- assertEquals(Node.class, node.getTargetType());\r
-\r
- assertTrue(nodes.contains(node));\r
- }\r
- \r
- \r
- @Test\r
- public void negativeContains() {\r
- InstanceIdentifier<FooChild> fooChild = InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class).build();\r
- \r
- InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //\r
- .child(Node.class,new NodeKey(10)).toInstance();\r
- InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //\r
- .child(Node.class,new NodeKey(1)).toInstance();\r
- InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).toInstance();\r
- \r
- assertFalse(fooChild.contains(nodeTen));\r
- assertFalse(nodeTen.contains(nodes));\r
- \r
- assertFalse(nodeOne.contains(nodes));\r
- assertTrue(nodes.contains(nodeOne));\r
- }\r
- \r
- @Test\r
- public void containsWildcarded() {\r
- InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).toInstance();\r
- InstanceIdentifier<Node> wildcarded = InstanceIdentifier.builder(Nodes.class).child(Node.class).build();\r
- InstanceIdentifier<NodeChild> wildcardedChildren = InstanceIdentifier.builder(Nodes.class) //\r
- .child(Node.class) //\r
- .child(NodeChild.class).build();\r
- \r
- assertTrue(wildcarded.isWildcarded());\r
- assertTrue(wildcardedChildren.isWildcarded());\r
- \r
- \r
- InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //\r
- .child(Node.class,new NodeKey(10)).toInstance();\r
- InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //\r
- .child(Node.class,new NodeKey(1)).toInstance();\r
- \r
- assertFalse(nodeTen.isWildcarded());\r
- assertFalse(nodeOne.isWildcarded());\r
- assertTrue(nodes.containsWildcarded(nodeOne));\r
- assertTrue(wildcarded.containsWildcarded(nodeOne));\r
- assertTrue(wildcarded.containsWildcarded(nodeTen));\r
- \r
- \r
- InstanceIdentifier<NodeChild> nodeTenChildWildcarded = InstanceIdentifier.builder(Nodes.class) //\r
- .child(Node.class,new NodeKey(10)).child(NodeChild.class).toInstance();\r
- \r
- assertTrue(nodeTenChildWildcarded.isWildcarded());\r
- \r
- InstanceIdentifier<NodeChild> nodeTenChild = InstanceIdentifier.builder(Nodes.class) //\r
- .child(Node.class,new NodeKey(10)).child(NodeChild.class, new NodeChildKey(10)).toInstance();\r
- InstanceIdentifier<NodeChild> nodeOneChild = InstanceIdentifier.builder(Nodes.class) //\r
- .child(Node.class,new NodeKey(1)).child(NodeChild.class, new NodeChildKey(1)).toInstance();\r
-\r
- \r
- assertFalse(nodeTenChildWildcarded.containsWildcarded(nodeOneChild));\r
- assertTrue(nodeTenChildWildcarded.containsWildcarded(nodeTenChild));\r
- \r
- }\r
- \r
- \r
- void childOfTest() {\r
- InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class);\r
- }\r
-\r
-}\r
+package org.opendaylight.yangtools.yang.binding.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.test.mock.FooChild;
+import org.opendaylight.yangtools.yang.binding.test.mock.InstantiatedFoo;
+import org.opendaylight.yangtools.yang.binding.test.mock.Node;
+import org.opendaylight.yangtools.yang.binding.test.mock.NodeChild;
+import org.opendaylight.yangtools.yang.binding.test.mock.NodeChildKey;
+import org.opendaylight.yangtools.yang.binding.test.mock.NodeKey;
+import org.opendaylight.yangtools.yang.binding.test.mock.Nodes;
+
+public class InstanceIdentifierTest {
+
+ @Test
+ public void constructWithPredicates() {
+
+ InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
+
+ assertNotNull(nodes);
+ assertEquals(Nodes.class, nodes.getTargetType());
+
+
+ InstanceIdentifier<Node> node = nodes.builder().child(Node.class).build();
+
+ assertNotNull(node);
+ assertEquals(Node.class, node.getTargetType());
+
+ assertTrue(nodes.contains(node));
+ }
+
+ @Test
+ public void fluentConstruction() {
+
+ InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
+ InstanceIdentifier<Node> node = InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).build();
+
+ assertNotNull(node);
+ assertEquals(Node.class, node.getTargetType());
+
+ assertTrue(nodes.contains(node));
+ }
+
+
+ @Test
+ public void negativeContains() {
+ InstanceIdentifier<FooChild> fooChild = InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class).build();
+
+ InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //
+ .child(Node.class,new NodeKey(10)).build();
+ InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //
+ .child(Node.class,new NodeKey(1)).build();
+ InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
+
+ assertFalse(fooChild.contains(nodeTen));
+ assertFalse(nodeTen.contains(nodes));
+
+ assertFalse(nodeOne.contains(nodes));
+ assertTrue(nodes.contains(nodeOne));
+ }
+
+ @Test
+ public void containsWildcarded() {
+ InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
+ InstanceIdentifier<Node> wildcarded = InstanceIdentifier.builder(Nodes.class).child(Node.class).build();
+ InstanceIdentifier<NodeChild> wildcardedChildren = InstanceIdentifier.builder(Nodes.class) //
+ .child(Node.class) //
+ .child(NodeChild.class).build();
+
+ assertTrue(wildcarded.isWildcarded());
+ assertTrue(wildcardedChildren.isWildcarded());
+
+
+ InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //
+ .child(Node.class,new NodeKey(10)).build();
+ InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //
+ .child(Node.class,new NodeKey(1)).build();
+
+ assertFalse(nodeTen.isWildcarded());
+ assertFalse(nodeOne.isWildcarded());
+ assertTrue(nodes.containsWildcarded(nodeOne));
+ assertTrue(wildcarded.containsWildcarded(nodeOne));
+ assertTrue(wildcarded.containsWildcarded(nodeTen));
+
+
+ InstanceIdentifier<NodeChild> nodeTenChildWildcarded = InstanceIdentifier.builder(Nodes.class) //
+ .child(Node.class,new NodeKey(10)).child(NodeChild.class).build();
+
+ assertTrue(nodeTenChildWildcarded.isWildcarded());
+
+ InstanceIdentifier<NodeChild> nodeTenChild = InstanceIdentifier.builder(Nodes.class) //
+ .child(Node.class,new NodeKey(10)).child(NodeChild.class, new NodeChildKey(10)).build();
+ InstanceIdentifier<NodeChild> nodeOneChild = InstanceIdentifier.builder(Nodes.class) //
+ .child(Node.class,new NodeKey(1)).child(NodeChild.class, new NodeChildKey(1)).build();
+
+
+ assertFalse(nodeTenChildWildcarded.containsWildcarded(nodeOneChild));
+ assertTrue(nodeTenChildWildcarded.containsWildcarded(nodeTenChild));
+
+ }
+
+
+ void childOfTest() {
+ InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class);
+ }
+
+}
Code Review / yangtools.git / blobdiff