X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fyang-binding%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fbinding%2FInstanceIdentifierTest.java;h=1270d340ea36e65e910eb573b76d5a21e8f41f85;hb=eb7ab8e1bb6a28cfafd22a5a62ea66e5f85a8c2d;hp=97ee4feded7c19fd129672f89de43c02e74c89f7;hpb=470e20edf85dbf3731d1fea7fde5eab7bd3afe95;p=mdsal.git 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 97ee4feded..1270d340ea 100644 --- 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,30 +11,41 @@ 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 org.junit.Test; -import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +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 { @Test public void constructWithPredicates() { - - InstanceIdentifier nodes = InstanceIdentifier.builder(Nodes.class).build(); + final InstanceIdentifier nodes = InstanceIdentifier.builder(Nodes.class).build(); assertNotNull(nodes); assertEquals(Nodes.class, nodes.getTargetType()); - - InstanceIdentifier node = nodes.builder().child(Node.class).build(); + final InstanceIdentifier node = nodes.builder().child(Node.class).build(); assertNotNull(node); assertEquals(Node.class, node.getTargetType()); @@ -44,9 +55,9 @@ public class InstanceIdentifierTest { @Test public void fluentConstruction() { - - InstanceIdentifier nodes = InstanceIdentifier.builder(Nodes.class).build(); - InstanceIdentifier node = InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).build(); + final InstanceIdentifier nodes = InstanceIdentifier.builder(Nodes.class).build(); + final InstanceIdentifier node = + InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).build(); assertNotNull(node); assertEquals(Node.class, node.getTargetType()); @@ -54,16 +65,16 @@ public class InstanceIdentifierTest { assertTrue(nodes.contains(node)); } - @Test public void negativeContains() { - InstanceIdentifier fooChild = InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class).build(); + final InstanceIdentifier fooChild = + InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class).build(); - InstanceIdentifier nodeTen = InstanceIdentifier.builder(Nodes.class) // + final InstanceIdentifier nodeTen = InstanceIdentifier.builder(Nodes.class) // .child(Node.class,new NodeKey(10)).build(); - InstanceIdentifier nodeOne = InstanceIdentifier.builder(Nodes.class) // + final InstanceIdentifier nodeOne = InstanceIdentifier.builder(Nodes.class) // .child(Node.class,new NodeKey(1)).build(); - InstanceIdentifier nodes = InstanceIdentifier.builder(Nodes.class).build(); + final InstanceIdentifier nodes = InstanceIdentifier.builder(Nodes.class).build(); assertFalse(fooChild.contains(nodeTen)); assertFalse(nodeTen.contains(nodes)); @@ -77,19 +88,18 @@ public class InstanceIdentifierTest { @Test public void containsWildcarded() { - InstanceIdentifier nodes = InstanceIdentifier.builder(Nodes.class).build(); - InstanceIdentifier wildcarded = InstanceIdentifier.builder(Nodes.class).child(Node.class).build(); - InstanceIdentifier wildcardedChildren = InstanceIdentifier.builder(Nodes.class) // + final InstanceIdentifier nodes = InstanceIdentifier.builder(Nodes.class).build(); + final InstanceIdentifier wildcarded = InstanceIdentifier.builder(Nodes.class).child(Node.class).build(); + final InstanceIdentifier wildcardedChildren = InstanceIdentifier.builder(Nodes.class) // .child(Node.class) // .child(NodeChild.class).build(); assertTrue(wildcarded.isWildcarded()); assertTrue(wildcardedChildren.isWildcarded()); - - InstanceIdentifier nodeTen = InstanceIdentifier.builder(Nodes.class) // + final InstanceIdentifier nodeTen = InstanceIdentifier.builder(Nodes.class) // .child(Node.class,new NodeKey(10)).build(); - InstanceIdentifier nodeOne = InstanceIdentifier.builder(Nodes.class) // + final InstanceIdentifier nodeOne = InstanceIdentifier.builder(Nodes.class) // .child(Node.class,new NodeKey(1)).build(); assertFalse(nodeTen.isWildcarded()); @@ -97,51 +107,164 @@ public class InstanceIdentifierTest { assertTrue(nodes.containsWildcarded(nodeOne)); assertTrue(wildcarded.containsWildcarded(nodeOne)); assertTrue(wildcarded.containsWildcarded(nodeTen)); + assertFalse(InstanceIdentifier.builder(Nodes.class) + .child(InstantiatedFoo.class).build().containsWildcarded(wildcarded)); - - InstanceIdentifier nodeTenChildWildcarded = InstanceIdentifier.builder(Nodes.class) // + final InstanceIdentifier nodeTenChildWildcarded = InstanceIdentifier.builder(Nodes.class) // .child(Node.class,new NodeKey(10)).child(NodeChild.class).build(); assertTrue(nodeTenChildWildcarded.isWildcarded()); - InstanceIdentifier nodeTenChild = InstanceIdentifier.builder(Nodes.class) // + final InstanceIdentifier nodeTenChild = InstanceIdentifier.builder(Nodes.class) // .child(Node.class,new NodeKey(10)).child(NodeChild.class, new NodeChildKey(10)).build(); - InstanceIdentifier nodeOneChild = InstanceIdentifier.builder(Nodes.class) // + final InstanceIdentifier 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); } @Test public void basicTests() { - InstanceIdentifier instanceIdentifier1 = InstanceIdentifier.create(DataObject.class); - InstanceIdentifier instanceIdentifier2 = InstanceIdentifier.create(DataObject.class); - Object object = new Object(); + final InstanceIdentifier instanceIdentifier1 = InstanceIdentifier.create(FooRoot.class); + final InstanceIdentifier instanceIdentifier2 = InstanceIdentifier.create(FooRoot.class); + final InstanceIdentifier instanceIdentifier4 = InstanceIdentifier.create(FooRoot.class); + final InstanceIdentifier instanceIdentifier3 = InstanceIdentifier.builder(Nodes.class) + .child(Node.class, new NodeKey(10)).child(NodeChild.class).build(); + final Object object = new Object(); assertTrue(instanceIdentifier1.equals(instanceIdentifier1)); assertFalse(instanceIdentifier1.equals(null)); assertFalse(instanceIdentifier1.equals(object)); assertTrue(instanceIdentifier1.equals(instanceIdentifier2)); - assertNotNull(instanceIdentifier1.hashCode()); + 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(Nodes.class).child(Node.class); + Whitebox.setInternalState(instanceIdentifier5, "hash", instanceIdentifier1.hashCode()); + Whitebox.setInternalState(instanceIdentifier5, "wildcarded", false); + + assertNotNull(InstanceIdentifier.create(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(NodeAugmentation.class)); + assertNotNull(instanceIdentifier1.hashCode()); assertNotNull(instanceIdentifier1.toString()); + + final InstanceIdentifierBuilder instanceIdentifierBuilder = instanceIdentifier1.builder(); + assertEquals(instanceIdentifier1.hashCode(), instanceIdentifierBuilder.hashCode()); + assertNotNull(instanceIdentifierBuilder.augmentation(InstantiatedFoo.class)); + assertNotNull(instanceIdentifierBuilder.build()); } @Test public void firstIdentifierOfTest() { - InstanceIdentifier instanceIdentifier = InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).build(); - - InstanceIdentifier nodesIdentifier = instanceIdentifier.firstIdentifierOf(Nodes.class); + final InstanceIdentifier instanceIdentifier = + InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).build(); + final InstanceIdentifier nodesIdentifier = instanceIdentifier.firstIdentifierOf(Nodes.class); assertNotNull(nodesIdentifier); - InstanceIdentifier dataObjectIdentifier = instanceIdentifier.firstIdentifierOf(DataObject.class); + final InstanceIdentifier dataObjectIdentifier = + instanceIdentifier.firstIdentifierOf(DataObject.class); assertNull(dataObjectIdentifier); } + + @Test + public void firstKeyOfTest() { + final InstanceIdentifier instanceIdentifier = + InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build(); + final InstanceIdentifier instanceIdentifier1 = InstanceIdentifier.create(FooRoot.class); + assertNotNull(instanceIdentifier.firstKeyOf(Node.class)); + assertNull(instanceIdentifier1.firstKeyOf(Node.class)); + } + + @Test + public void keyOfTest() { + final Identifier identifier = mock(Identifier.class); + assertEquals(identifier, InstanceIdentifier.keyOf( + new KeyedInstanceIdentifier(Identifiable.class, ImmutableList.of(), false, 0, identifier))); + } + + @Test + public void serializationTest() throws IOException, ClassNotFoundException { + final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); + final ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream); + + final InstanceIdentifier instanceIdentifier = InstanceIdentifier.create(FooRoot.class); + outputStream.writeObject(instanceIdentifier); + outputStream.flush(); + outputStream.close(); + + final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray()); + final ObjectInputStream inputStream = new ObjectInputStream(byteArrayInputStream); + final InstanceIdentifier deserialized = (InstanceIdentifier) inputStream.readObject(); + + assertEquals(instanceIdentifier, deserialized); + } + + @Test + public void equalsTest() { + final InstanceIdentifierBuilder builder1 = InstanceIdentifier.create(FooRoot.class).builder(); + final InstanceIdentifierBuilder builder2 = InstanceIdentifier.create(FooRoot.class).builder(); + final InstanceIdentifierBuilder builder3 = InstanceIdentifier.create(Nodes.class).builder(); + final InstanceIdentifierBuilder builder4 = InstanceIdentifier.create(Nodes.class).builder(); + final Object obj = new Object(); + + assertTrue(builder1.equals(builder2)); + assertTrue(builder2.equals(builder1)); + assertTrue(builder2.equals(builder2)); + assertTrue(builder3.equals(builder4)); + assertTrue(builder4.equals(builder4)); + assertFalse(builder3.equals(builder1)); + assertFalse(builder3.equals(null)); + assertFalse(builder4.equals(null)); + assertFalse(builder1.equals(obj)); + + builder3.child(Node.class, new NodeKey(10)); + assertFalse(builder3.equals(builder4)); + assertFalse(builder4.equals(builder3)); + + builder4.child(Node.class, new NodeKey(20)); + assertFalse(builder3.equals(builder4)); + assertFalse(builder4.equals(builder3)); + + InstanceIdentifierBuilder iib1 = new InstanceIdentifierBuilderImpl<>(null, null, 31, true); + InstanceIdentifierBuilder iib2 = new InstanceIdentifierBuilderImpl<>(null, null, 31, false); + InstanceIdentifierBuilder 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 builder1 = InstanceIdentifier.create(FooRoot.class).builder(); + final InstanceIdentifierBuilder builder2 = InstanceIdentifier.create(FooRoot.class).builder(); + final InstanceIdentifierBuilder builder3 = InstanceIdentifier.create(Nodes.class).builder(); + final InstanceIdentifierBuilder builder4 = InstanceIdentifier.create(Nodes.class).builder(); + final Object obj = new Object(); + + assertTrue(builder1.hashCode() == builder2.hashCode()); + assertTrue(builder1.hashCode() != builder3.hashCode()); + assertTrue(builder3.hashCode() == builder4.hashCode()); + assertTrue(builder2.hashCode() != builder4.hashCode()); + assertTrue(builder1.hashCode() != obj.hashCode()); + + builder3.child(Node.class, new NodeKey(10)); + + assertTrue(builder3.hashCode() != builder4.hashCode()); + } + + @Test + public void verifyTargetTest() { + final InstanceIdentifier nodeId = InstanceIdentifier.create(Nodes.class); + assertSame(nodeId, nodeId.verifyTarget(Nodes.class)); + assertThrows(VerifyException.class, () -> nodeId.verifyTarget(Node.class)); + } + }