binding/yang-binding/src/test/java/org/opendaylight/yangtools/yang/binding/InstanceIdentifierTest.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.binding;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertNull;
  14 import static org.junit.Assert.assertSame;
  15 import static org.junit.Assert.assertThrows;
  16 import static org.junit.Assert.assertTrue;
  17 import static org.mockito.Mockito.mock;
  18
  19 import com.google.common.base.VerifyException;
  20 import com.google.common.collect.ImmutableList;
  21 import java.io.ByteArrayInputStream;
  22 import java.io.ByteArrayOutputStream;
  23 import java.io.IOException;
  24 import java.io.ObjectInputStream;
  25 import java.io.ObjectOutputStream;
  26 import org.junit.Test;
  27 import org.opendaylight.yangtools.yang.binding.test.mock.FooChild;
  28 import org.opendaylight.yangtools.yang.binding.test.mock.FooRoot;
  29 import org.opendaylight.yangtools.yang.binding.test.mock.InstantiatedFoo;
  30 import org.opendaylight.yangtools.yang.binding.test.mock.Node;
  31 import org.opendaylight.yangtools.yang.binding.test.mock.NodeAugmentation;
  32 import org.opendaylight.yangtools.yang.binding.test.mock.NodeChild;
  33 import org.opendaylight.yangtools.yang.binding.test.mock.NodeChildKey;
  34 import org.opendaylight.yangtools.yang.binding.test.mock.NodeKey;
  35 import org.opendaylight.yangtools.yang.binding.test.mock.Nodes;
  36 import org.powermock.reflect.Whitebox;
  37
  38 public class InstanceIdentifierTest {
  39
  40     @Test
  41     public void constructWithPredicates() {
  42         final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
  43
  44         assertNotNull(nodes);
  45         assertEquals(Nodes.class, nodes.getTargetType());
  46
  47         final InstanceIdentifier<Node> node = nodes.builder().child(Node.class).build();
  48
  49         assertNotNull(node);
  50         assertEquals(Node.class, node.getTargetType());
  51
  52         assertTrue(nodes.contains(node));
  53     }
  54
  55     @Test
  56     public void fluentConstruction() {
  57         final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
  58         final InstanceIdentifier<Node> node =
  59                 InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build();
  60
  61         assertNotNull(node);
  62         assertEquals(Node.class, node.getTargetType());
  63
  64         assertTrue(nodes.contains(node));
  65     }
  66
  67     @Test
  68     public void negativeContains() {
  69         final InstanceIdentifier<FooChild> fooChild =
  70                 InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class).build();
  71
  72         final InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class)
  73                 .child(Node.class, new NodeKey(10)).build();
  74         final InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class)
  75                 .child(Node.class, new NodeKey(1)).build();
  76         final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
  77
  78         assertFalse(fooChild.contains(nodeTen));
  79         assertFalse(nodeTen.contains(nodes));
  80
  81         assertFalse(nodeOne.contains(nodes));
  82         assertTrue(nodes.contains(nodeOne));
  83
  84         assertTrue(nodes.containsWildcarded(nodeOne));
  85         assertFalse(nodeOne.containsWildcarded(nodes));
  86     }
  87
  88     @Test
  89     public void containsWildcarded() {
  90         final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
  91         final InstanceIdentifier<Node> wildcarded = InstanceIdentifier.builder(Nodes.class).child(Node.class).build();
  92         final InstanceIdentifier<NodeChild> wildcardedChildren = InstanceIdentifier.builder(Nodes.class)
  93                 .child(Node.class)
  94                 .child(NodeChild.class).build();
  95
  96         assertTrue(wildcarded.isWildcarded());
  97         assertTrue(wildcardedChildren.isWildcarded());
  98
  99         final InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class)
 100                 .child(Node.class, new NodeKey(10)).build();
 101         final InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class)
 102                 .child(Node.class, new NodeKey(1)).build();
 103
 104         assertFalse(nodeTen.isWildcarded());
 105         assertFalse(nodeOne.isWildcarded());
 106         assertTrue(nodes.containsWildcarded(nodeOne));
 107         assertTrue(wildcarded.containsWildcarded(nodeOne));
 108         assertTrue(wildcarded.containsWildcarded(nodeTen));
 109         assertFalse(InstanceIdentifier.builder(Nodes.class)
 110                 .child(InstantiatedFoo.class).build().containsWildcarded(wildcarded));
 111
 112         final InstanceIdentifier<NodeChild> nodeTenChildWildcarded = InstanceIdentifier.builder(Nodes.class)
 113                 .child(Node.class, new NodeKey(10)).child(NodeChild.class).build();
 114
 115         assertTrue(nodeTenChildWildcarded.isWildcarded());
 116
 117         final InstanceIdentifier<NodeChild> nodeTenChild = InstanceIdentifier.builder(Nodes.class)
 118                 .child(Node.class, new NodeKey(10)).child(NodeChild.class, new NodeChildKey(10)).build();
 119         final InstanceIdentifier<NodeChild> nodeOneChild = InstanceIdentifier.builder(Nodes.class)
 120                 .child(Node.class, new NodeKey(1)).child(NodeChild.class, new NodeChildKey(1)).build();
 121
 122         assertFalse(nodeTenChildWildcarded.containsWildcarded(nodeOneChild));
 123         assertTrue(nodeTenChildWildcarded.containsWildcarded(nodeTenChild));
 124     }
 125
 126     @Test
 127     public void basicTests() {
 128         final InstanceIdentifier<FooRoot> instanceIdentifier1 = InstanceIdentifier.create(FooRoot.class);
 129         final InstanceIdentifier<FooRoot> instanceIdentifier2 = InstanceIdentifier.create(FooRoot.class);
 130         final InstanceIdentifier<FooRoot> instanceIdentifier4 = InstanceIdentifier.create(FooRoot.class);
 131         final InstanceIdentifier<NodeChild> instanceIdentifier3 = InstanceIdentifier.builder(Nodes.class)
 132                 .child(Node.class, new NodeKey(10)).child(NodeChild.class).build();
 133         final Object object = new Object();
 134
 135         assertTrue(instanceIdentifier1.equals(instanceIdentifier1));
 136         assertFalse(instanceIdentifier1.equals(null));
 137         assertFalse(instanceIdentifier1.equals(object));
 138         assertTrue(instanceIdentifier1.equals(instanceIdentifier2));
 139
 140         Whitebox.setInternalState(instanceIdentifier2, "pathArguments", instanceIdentifier1.pathArguments);
 141         Whitebox.setInternalState(instanceIdentifier4, "wildcarded", true);
 142
 143         assertTrue(instanceIdentifier1.equals(instanceIdentifier2));
 144         assertFalse(instanceIdentifier1.equals(instanceIdentifier3));
 145         assertFalse(instanceIdentifier1.equals(instanceIdentifier4));
 146
 147         final InstanceIdentifier<Node> instanceIdentifier5 = InstanceIdentifier.create(Nodes.class).child(Node.class);
 148         Whitebox.setInternalState(instanceIdentifier5, "hash", instanceIdentifier1.hashCode());
 149         Whitebox.setInternalState(instanceIdentifier5, "wildcarded", false);
 150
 151         assertNotNull(InstanceIdentifier.unsafeOf(ImmutableList.copyOf(instanceIdentifier1.getPathArguments())));
 152         assertNotNull(InstanceIdentifier.create(Nodes.class).child(Node.class));
 153         assertNotNull(InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(5)));
 154         assertNotNull(instanceIdentifier5.augmentation(NodeAugmentation.class));
 155         assertNotNull(instanceIdentifier1.hashCode());
 156         assertNotNull(instanceIdentifier1.toString());
 157
 158         final InstanceIdentifier.Builder instanceIdentifierBuilder = instanceIdentifier1.builder();
 159         assertEquals(instanceIdentifier1.hashCode(), instanceIdentifierBuilder.hashCode());
 160         assertNotNull(instanceIdentifierBuilder.augmentation(InstantiatedFoo.class));
 161         assertNotNull(instanceIdentifierBuilder.build());
 162     }
 163
 164     @Test
 165     public void firstIdentifierOfTest() {
 166         final InstanceIdentifier<Node> instanceIdentifier =
 167                 InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build();
 168         final InstanceIdentifier<Nodes> nodesIdentifier = instanceIdentifier.firstIdentifierOf(Nodes.class);
 169         assertNotNull(nodesIdentifier);
 170         final InstanceIdentifier<DataObject> dataObjectIdentifier =
 171                 instanceIdentifier.firstIdentifierOf(DataObject.class);
 172         assertNull(dataObjectIdentifier);
 173     }
 174
 175     @Test
 176     public void firstKeyOfTest() {
 177         final InstanceIdentifier<Node> instanceIdentifier =
 178                 InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build();
 179         final InstanceIdentifier<FooRoot> instanceIdentifier1 = InstanceIdentifier.create(FooRoot.class);
 180         assertNotNull(instanceIdentifier.firstKeyOf(Node.class));
 181         assertNull(instanceIdentifier1.firstKeyOf(Node.class));
 182     }
 183
 184     @Test
 185     public void keyOfTest() {
 186         final Key<?> identifier = mock(Key.class);
 187         assertEquals(identifier, InstanceIdentifier.keyOf(
 188                 new KeyedInstanceIdentifier(KeyAware.class, ImmutableList.of(), false, 0, identifier)));
 189     }
 190
 191     @Test
 192     public void serializationTest() throws IOException, ClassNotFoundException {
 193         final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
 194         final ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
 195
 196         final InstanceIdentifier<FooRoot> instanceIdentifier = InstanceIdentifier.create(FooRoot.class);
 197         outputStream.writeObject(instanceIdentifier);
 198         outputStream.flush();
 199         outputStream.close();
 200
 201         final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
 202         final ObjectInputStream inputStream = new ObjectInputStream(byteArrayInputStream);
 203         final InstanceIdentifier<?> deserialized = (InstanceIdentifier<?>) inputStream.readObject();
 204
 205         assertEquals(instanceIdentifier, deserialized);
 206     }
 207
 208     @Test
 209     public void equalsTest() {
 210         final InstanceIdentifier.Builder<FooRoot> builder1 =  InstanceIdentifier.create(FooRoot.class).builder();
 211         final InstanceIdentifier.Builder<FooRoot> builder2 =  InstanceIdentifier.create(FooRoot.class).builder();
 212         final InstanceIdentifier.Builder<Nodes> builder3 =  InstanceIdentifier.create(Nodes.class).builder();
 213         final InstanceIdentifier.Builder<Nodes> builder4 =  InstanceIdentifier.create(Nodes.class).builder();
 214         final Object obj = new Object();
 215
 216         assertTrue(builder1.equals(builder2));
 217         assertTrue(builder2.equals(builder1));
 218         assertTrue(builder2.equals(builder2));
 219         assertTrue(builder3.equals(builder4));
 220         assertTrue(builder4.equals(builder4));
 221         assertFalse(builder3.equals(builder1));
 222         assertFalse(builder3.equals(null));
 223         assertFalse(builder4.equals(null));
 224         assertFalse(builder1.equals(obj));
 225
 226         builder3.child(Node.class, new NodeKey(10));
 227         assertFalse(builder3.equals(builder4));
 228         assertFalse(builder4.equals(builder3));
 229
 230         builder4.child(Node.class, new NodeKey(20));
 231         assertFalse(builder3.equals(builder4));
 232         assertFalse(builder4.equals(builder3));
 233     }
 234
 235     @Test
 236     public void hashCodeTest() {
 237         final InstanceIdentifier.Builder<FooRoot> builder1 =  InstanceIdentifier.create(FooRoot.class).builder();
 238         final InstanceIdentifier.Builder<FooRoot> builder2 =  InstanceIdentifier.create(FooRoot.class).builder();
 239         final InstanceIdentifier.Builder<Nodes> builder3 =  InstanceIdentifier.create(Nodes.class).builder();
 240         final InstanceIdentifier.Builder<Nodes> builder4 =  InstanceIdentifier.create(Nodes.class).builder();
 241         final Object obj = new Object();
 242
 243         assertTrue(builder1.hashCode() == builder2.hashCode());
 244         assertTrue(builder1.hashCode() != builder3.hashCode());
 245         assertTrue(builder3.hashCode() == builder4.hashCode());
 246         assertTrue(builder2.hashCode() != builder4.hashCode());
 247         assertTrue(builder1.hashCode() != obj.hashCode());
 248
 249         builder3.child(Node.class, new NodeKey(10));
 250
 251         assertTrue(builder3.hashCode() != builder4.hashCode());
 252     }
 253
 254     @Test
 255     public void verifyTargetTest() {
 256         final InstanceIdentifier<Nodes> nodeId = InstanceIdentifier.create(Nodes.class);
 257         assertSame(nodeId, nodeId.verifyTarget(Nodes.class));
 258         assertThrows(VerifyException.class, () -> nodeId.verifyTarget(Node.class));
 259     }
 260 }