Code Review / mdsal.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Refactor PathArgument to DataObjectStep
[mdsal.git] / binding / yang-binding / src / test / java / org / opendaylight / yangtools / yang / binding / InstanceIdentifierTest.java
diff --git a/binding/yang-binding/src/test/java/org/opendaylight/yangtools/yang/binding/InstanceIdentifierTest.java b/binding/yang-binding/src/test/java/org/opendaylight/yangtools/yang/binding/InstanceIdentifierTest.java
index 62f55028f175954d5e42066032a4f6cf1e69f66d..bf173a65abbd72f6f4b055f8b1bac8b9e6709f4f 100644 (file)
--- a/binding/yang-binding/src/test/java/org/opendaylight/yangtools/yang/binding/InstanceIdentifierTest.java
+++ b/binding/yang-binding/src/test/java/org/opendaylight/yangtools/yang/binding/InstanceIdentifierTest.java
@@ -11,24 +11,28 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mock;
 
+import com.google.common.base.VerifyException;
 import com.google.common.collect.ImmutableList;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
-import java.lang.reflect.Field;
 import org.junit.Test;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
 import org.opendaylight.yangtools.yang.binding.test.mock.FooChild;
+import org.opendaylight.yangtools.yang.binding.test.mock.FooRoot;
 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.NodeAugmentation;
 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;
+import org.powermock.reflect.Whitebox;
 
 public class InstanceIdentifierTest {
 
@@ -51,7 +55,7 @@ public class InstanceIdentifierTest {
     public void fluentConstruction() {
         final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
         final InstanceIdentifier<Node> node =
-                InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).build();
+                InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build();
 
         assertNotNull(node);
         assertEquals(Node.class, node.getTargetType());
@@ -64,10 +68,10 @@ public class InstanceIdentifierTest {
         final InstanceIdentifier<FooChild> fooChild =
                 InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class).build();
 
-        final InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //
-                .child(Node.class,new NodeKey(10)).build();
-        final InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //
-                .child(Node.class,new NodeKey(1)).build();
+        final InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class)
+                .child(Node.class, new NodeKey(10)).build();
+        final InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class)
+                .child(Node.class, new NodeKey(1)).build();
         final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
 
         assertFalse(fooChild.contains(nodeTen));
@@ -84,17 +88,17 @@ public class InstanceIdentifierTest {
     public void containsWildcarded() {
         final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
         final InstanceIdentifier<Node> wildcarded = InstanceIdentifier.builder(Nodes.class).child(Node.class).build();
-        final InstanceIdentifier<NodeChild> wildcardedChildren = InstanceIdentifier.builder(Nodes.class) //
-                .child(Node.class) //
+        final InstanceIdentifier<NodeChild> wildcardedChildren = InstanceIdentifier.builder(Nodes.class)
+                .child(Node.class)
                 .child(NodeChild.class).build();
 
         assertTrue(wildcarded.isWildcarded());
         assertTrue(wildcardedChildren.isWildcarded());
 
-        final InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //
-                .child(Node.class,new NodeKey(10)).build();
-        final InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //
-                .child(Node.class,new NodeKey(1)).build();
+        final InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class)
+                .child(Node.class, new NodeKey(10)).build();
+        final InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class)
+                .child(Node.class, new NodeKey(1)).build();
 
         assertFalse(nodeTen.isWildcarded());
         assertFalse(nodeOne.isWildcarded());
@@ -104,25 +108,25 @@ public class InstanceIdentifierTest {
         assertFalse(InstanceIdentifier.builder(Nodes.class)
                 .child(InstantiatedFoo.class).build().containsWildcarded(wildcarded));
 
-        final InstanceIdentifier<NodeChild> nodeTenChildWildcarded = InstanceIdentifier.builder(Nodes.class) //
-                .child(Node.class,new NodeKey(10)).child(NodeChild.class).build();
+        final InstanceIdentifier<NodeChild> nodeTenChildWildcarded = InstanceIdentifier.builder(Nodes.class)
+                .child(Node.class, new NodeKey(10)).child(NodeChild.class).build();
 
         assertTrue(nodeTenChildWildcarded.isWildcarded());
 
-        final InstanceIdentifier<NodeChild> nodeTenChild = InstanceIdentifier.builder(Nodes.class) //
-                .child(Node.class,new NodeKey(10)).child(NodeChild.class, new NodeChildKey(10)).build();
-        final InstanceIdentifier<NodeChild> nodeOneChild = InstanceIdentifier.builder(Nodes.class) //
-                .child(Node.class,new NodeKey(1)).child(NodeChild.class, new NodeChildKey(1)).build();
+        final InstanceIdentifier<NodeChild> nodeTenChild = InstanceIdentifier.builder(Nodes.class)
+                .child(Node.class, new NodeKey(10)).child(NodeChild.class, new NodeChildKey(10)).build();
+        final 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));
     }
 
     @Test
-    public void basicTests() throws Exception {
-        final InstanceIdentifier<DataObject> instanceIdentifier1 = InstanceIdentifier.create(DataObject.class);
-        final InstanceIdentifier<DataObject> instanceIdentifier2 = InstanceIdentifier.create(DataObject.class);
-        final InstanceIdentifier<DataObject> instanceIdentifier4 = InstanceIdentifier.create(DataObject.class);
+    public void basicTests() {
+        final InstanceIdentifier<FooRoot> instanceIdentifier1 = InstanceIdentifier.create(FooRoot.class);
+        final InstanceIdentifier<FooRoot> instanceIdentifier2 = InstanceIdentifier.create(FooRoot.class);
+        final InstanceIdentifier<FooRoot> instanceIdentifier4 = InstanceIdentifier.create(FooRoot.class);
         final InstanceIdentifier<NodeChild> instanceIdentifier3 = InstanceIdentifier.builder(Nodes.class)
                 .child(Node.class, new NodeKey(10)).child(NodeChild.class).build();
         final Object object = new Object();
@@ -132,32 +136,25 @@ public class InstanceIdentifierTest {
         assertFalse(instanceIdentifier1.equals(object));
         assertTrue(instanceIdentifier1.equals(instanceIdentifier2));
 
-        final Field pathArgumentsField = InstanceIdentifier.class.getDeclaredField("pathArguments");
-        final Field wildCardField = InstanceIdentifier.class.getDeclaredField("wildcarded");
-        pathArgumentsField.setAccessible(true);
-        wildCardField.setAccessible(true);
-        pathArgumentsField.set(instanceIdentifier2, instanceIdentifier1.pathArguments);
-        wildCardField.set(instanceIdentifier4, true);
+        Whitebox.setInternalState(instanceIdentifier2, "pathArguments", instanceIdentifier1.pathArguments);
+        Whitebox.setInternalState(instanceIdentifier4, "wildcarded", true);
 
         assertTrue(instanceIdentifier1.equals(instanceIdentifier2));
-
         assertFalse(instanceIdentifier1.equals(instanceIdentifier3));
         assertFalse(instanceIdentifier1.equals(instanceIdentifier4));
-        final InstanceIdentifier instanceIdentifier5 = InstanceIdentifier.create(Node.class);
-        final Field hashField = InstanceIdentifier.class.getDeclaredField("hash");
-        hashField.setAccessible(true);
-        hashField.set(instanceIdentifier5, instanceIdentifier1.hashCode());
-        wildCardField.set(instanceIdentifier5, false);
-
-        assertFalse(instanceIdentifier1.equals(instanceIdentifier5));
-        assertNotNull(InstanceIdentifier.create(ImmutableList.copyOf(instanceIdentifier1.getPathArguments())));
+
+        final InstanceIdentifier<Node> instanceIdentifier5 = InstanceIdentifier.create(Nodes.class).child(Node.class);
+        Whitebox.setInternalState(instanceIdentifier5, "hash", instanceIdentifier1.hashCode());
+        Whitebox.setInternalState(instanceIdentifier5, "wildcarded", false);
+
+        assertNotNull(InstanceIdentifier.unsafeOf(ImmutableList.copyOf(instanceIdentifier1.getPathArguments())));
         assertNotNull(InstanceIdentifier.create(Nodes.class).child(Node.class));
         assertNotNull(InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(5)));
-        assertNotNull(instanceIdentifier5.augmentation(DataObject.class));
+        assertNotNull(instanceIdentifier5.augmentation(NodeAugmentation.class));
         assertNotNull(instanceIdentifier1.hashCode());
         assertNotNull(instanceIdentifier1.toString());
 
-        final InstanceIdentifierBuilder instanceIdentifierBuilder = instanceIdentifier1.builder();
+        final InstanceIdentifier.Builder instanceIdentifierBuilder = instanceIdentifier1.builder();
         assertEquals(instanceIdentifier1.hashCode(), instanceIdentifierBuilder.hashCode());
         assertNotNull(instanceIdentifierBuilder.augmentation(InstantiatedFoo.class));
         assertNotNull(instanceIdentifierBuilder.build());
@@ -166,7 +163,7 @@ public class InstanceIdentifierTest {
     @Test
     public void firstIdentifierOfTest() {
         final InstanceIdentifier<Node> instanceIdentifier =
-                InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).build();
+                InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build();
         final InstanceIdentifier<Nodes> nodesIdentifier = instanceIdentifier.firstIdentifierOf(Nodes.class);
         assertNotNull(nodesIdentifier);
         final InstanceIdentifier<DataObject> dataObjectIdentifier =
@@ -177,25 +174,25 @@ public class InstanceIdentifierTest {
     @Test
     public void firstKeyOfTest() {
         final InstanceIdentifier<Node> instanceIdentifier =
-                InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).build();
-        final InstanceIdentifier<DataObject> instanceIdentifier1 = InstanceIdentifier.create(DataObject.class);
-        assertNotNull(instanceIdentifier.firstKeyOf(Node.class, null));
+                InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build();
+        final InstanceIdentifier<FooRoot> instanceIdentifier1 = InstanceIdentifier.create(FooRoot.class);
+        assertNotNull(instanceIdentifier.firstKeyOf(Node.class));
         assertNull(instanceIdentifier1.firstKeyOf(Node.class));
     }
 
     @Test
-    public void keyOfTest() throws Exception {
-        final Identifier<?> identifier = mock(Identifier.class);
-        assertEquals(identifier, InstanceIdentifier.keyOf(
-                new KeyedInstanceIdentifier(Identifiable.class, ImmutableList.of(), false, 0, identifier)));
+    public void keyOfTest() {
+        final var key = new NodeKey(42);
+        assertEquals(key, InstanceIdentifier.keyOf(
+            new KeyedInstanceIdentifier<>(new KeyStep<>(Node.class, key), ImmutableList.of(), false, 0)));
     }
 
     @Test
-    public void serializationTest() throws Exception {
+    public void serializationTest() throws IOException, ClassNotFoundException {
         final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
         final ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
 
-        final InstanceIdentifier<DataObject> instanceIdentifier = InstanceIdentifier.create(DataObject.class);
+        final InstanceIdentifier<FooRoot> instanceIdentifier = InstanceIdentifier.create(FooRoot.class);
         outputStream.writeObject(instanceIdentifier);
         outputStream.flush();
         outputStream.close();
@@ -209,10 +206,10 @@ public class InstanceIdentifierTest {
 
     @Test
     public void equalsTest() {
-        final InstanceIdentifierBuilder<DataObject> builder1 =  InstanceIdentifier.create(DataObject.class).builder();
-        final InstanceIdentifierBuilder<DataObject> builder2 =  InstanceIdentifier.create(DataObject.class).builder();
-        final InstanceIdentifierBuilder<Nodes> builder3 =  InstanceIdentifier.create(Nodes.class).builder();
-        final InstanceIdentifierBuilder<Nodes> builder4 =  InstanceIdentifier.create(Nodes.class).builder();
+        final InstanceIdentifier.Builder<FooRoot> builder1 =  InstanceIdentifier.create(FooRoot.class).builder();
+        final InstanceIdentifier.Builder<FooRoot> builder2 =  InstanceIdentifier.create(FooRoot.class).builder();
+        final InstanceIdentifier.Builder<Nodes> builder3 =  InstanceIdentifier.create(Nodes.class).builder();
+        final InstanceIdentifier.Builder<Nodes> builder4 =  InstanceIdentifier.create(Nodes.class).builder();
         final Object obj = new Object();
 
         assertTrue(builder1.equals(builder2));
@@ -232,22 +229,14 @@ public class InstanceIdentifierTest {
         builder4.child(Node.class, new NodeKey(20));
         assertFalse(builder3.equals(builder4));
         assertFalse(builder4.equals(builder3));
-
-        InstanceIdentifierBuilder<Nodes> iib1 = new InstanceIdentifierBuilderImpl(null, null, 31, true);
-        InstanceIdentifierBuilder<Nodes> iib2 = new InstanceIdentifierBuilderImpl(null, null, 31, false);
-        InstanceIdentifierBuilder<Nodes> iib3 = new InstanceIdentifierBuilderImpl(null, null, 31, true);
-        assertFalse(iib1.equals(iib2));
-        assertFalse(iib2.equals(iib1));
-        assertTrue(iib1.equals(iib3));
-        assertTrue(iib3.equals(iib1));
     }
 
     @Test
     public void hashCodeTest() {
-        final InstanceIdentifierBuilder<DataObject> builder1 =  InstanceIdentifier.create(DataObject.class).builder();
-        final InstanceIdentifierBuilder<DataObject> builder2 =  InstanceIdentifier.create(DataObject.class).builder();
-        final InstanceIdentifierBuilder<Nodes> builder3 =  InstanceIdentifier.create(Nodes.class).builder();
-        final InstanceIdentifierBuilder<Nodes> builder4 =  InstanceIdentifier.create(Nodes.class).builder();
+        final InstanceIdentifier.Builder<FooRoot> builder1 =  InstanceIdentifier.create(FooRoot.class).builder();
+        final InstanceIdentifier.Builder<FooRoot> builder2 =  InstanceIdentifier.create(FooRoot.class).builder();
+        final InstanceIdentifier.Builder<Nodes> builder3 =  InstanceIdentifier.create(Nodes.class).builder();
+        final InstanceIdentifier.Builder<Nodes> builder4 =  InstanceIdentifier.create(Nodes.class).builder();
         final Object obj = new Object();
 
         assertTrue(builder1.hashCode() == builder2.hashCode());
@@ -261,4 +250,10 @@ public class InstanceIdentifierTest {
         assertTrue(builder3.hashCode() != builder4.hashCode());
     }
 
+    @Test
+    public void verifyTargetTest() {
+        final InstanceIdentifier<Nodes> nodeId = InstanceIdentifier.create(Nodes.class);
+        assertSame(nodeId, nodeId.verifyTarget(Nodes.class));
+        assertThrows(VerifyException.class, () -> nodeId.verifyTarget(Node.class));
+    }
 }
MD-SAL: Model-Driven Service Adaptation Layer