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.ObjectInputStream;
  24 import java.io.ObjectOutputStream;
  25 import java.lang.reflect.Field;
  26 import org.junit.Test;
  27 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  28 import org.opendaylight.yangtools.yang.binding.test.mock.FooChild;
  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
  37 public class InstanceIdentifierTest {
  38
  39     @Test
  40     public void constructWithPredicates() {
  41         final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
  42
  43         assertNotNull(nodes);
  44         assertEquals(Nodes.class, nodes.getTargetType());
  45
  46         final InstanceIdentifier<Node> node = nodes.builder().child(Node.class).build();
  47
  48         assertNotNull(node);
  49         assertEquals(Node.class, node.getTargetType());
  50
  51         assertTrue(nodes.contains(node));
  52     }
  53
  54     @Test
  55     public void fluentConstruction() {
  56         final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
  57         final InstanceIdentifier<Node> node =
  58                 InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).build();
  59
  60         assertNotNull(node);
  61         assertEquals(Node.class, node.getTargetType());
  62
  63         assertTrue(nodes.contains(node));
  64     }
  65
  66     @Test
  67     public void negativeContains() {
  68         final InstanceIdentifier<FooChild> fooChild =
  69                 InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class).build();
  70
  71         final InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //
  72                 .child(Node.class,new NodeKey(10)).build();
  73         final InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //
  74                 .child(Node.class,new NodeKey(1)).build();
  75         final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
  76
  77         assertFalse(fooChild.contains(nodeTen));
  78         assertFalse(nodeTen.contains(nodes));
  79
  80         assertFalse(nodeOne.contains(nodes));
  81         assertTrue(nodes.contains(nodeOne));
  82
  83         assertTrue(nodes.containsWildcarded(nodeOne));
  84         assertFalse(nodeOne.containsWildcarded(nodes));
  85     }
  86
  87     @Test
  88     public void containsWildcarded() {
  89         final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
  90         final InstanceIdentifier<Node> wildcarded = InstanceIdentifier.builder(Nodes.class).child(Node.class).build();
  91         final InstanceIdentifier<NodeChild> wildcardedChildren = InstanceIdentifier.builder(Nodes.class) //
  92                 .child(Node.class) //
  93                 .child(NodeChild.class).build();
  94
  95         assertTrue(wildcarded.isWildcarded());
  96         assertTrue(wildcardedChildren.isWildcarded());
  97
  98         final InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //
  99                 .child(Node.class,new NodeKey(10)).build();
 100         final InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //
 101                 .child(Node.class,new NodeKey(1)).build();
 102
 103         assertFalse(nodeTen.isWildcarded());
 104         assertFalse(nodeOne.isWildcarded());
 105         assertTrue(nodes.containsWildcarded(nodeOne));
 106         assertTrue(wildcarded.containsWildcarded(nodeOne));
 107         assertTrue(wildcarded.containsWildcarded(nodeTen));
 108         assertFalse(InstanceIdentifier.builder(Nodes.class)
 109                 .child(InstantiatedFoo.class).build().containsWildcarded(wildcarded));
 110
 111         final InstanceIdentifier<NodeChild> nodeTenChildWildcarded = InstanceIdentifier.builder(Nodes.class) //
 112                 .child(Node.class,new NodeKey(10)).child(NodeChild.class).build();
 113
 114         assertTrue(nodeTenChildWildcarded.isWildcarded());
 115
 116         final InstanceIdentifier<NodeChild> nodeTenChild = InstanceIdentifier.builder(Nodes.class) //
 117                 .child(Node.class,new NodeKey(10)).child(NodeChild.class, new NodeChildKey(10)).build();
 118         final InstanceIdentifier<NodeChild> nodeOneChild = InstanceIdentifier.builder(Nodes.class) //
 119                 .child(Node.class,new NodeKey(1)).child(NodeChild.class, new NodeChildKey(1)).build();
 120
 121         assertFalse(nodeTenChildWildcarded.containsWildcarded(nodeOneChild));
 122         assertTrue(nodeTenChildWildcarded.containsWildcarded(nodeTenChild));
 123     }
 124
 125     @Test
 126     public void basicTests() throws Exception {
 127         final InstanceIdentifier<DataObject> instanceIdentifier1 = InstanceIdentifier.create(DataObject.class);
 128         final InstanceIdentifier<DataObject> instanceIdentifier2 = InstanceIdentifier.create(DataObject.class);
 129         final InstanceIdentifier<DataObject> instanceIdentifier4 = InstanceIdentifier.create(DataObject.class);
 130         final InstanceIdentifier<NodeChild> instanceIdentifier3 = InstanceIdentifier.builder(Nodes.class)
 131                 .child(Node.class, new NodeKey(10)).child(NodeChild.class).build();
 132         final Object object = new Object();
 133
 134         assertTrue(instanceIdentifier1.equals(instanceIdentifier1));
 135         assertFalse(instanceIdentifier1.equals(null));
 136         assertFalse(instanceIdentifier1.equals(object));
 137         assertTrue(instanceIdentifier1.equals(instanceIdentifier2));
 138
 139         final Field pathArgumentsField = InstanceIdentifier.class.getDeclaredField("pathArguments");
 140         final Field wildCardField = InstanceIdentifier.class.getDeclaredField("wildcarded");
 141         pathArgumentsField.setAccessible(true);
 142         wildCardField.setAccessible(true);
 143         pathArgumentsField.set(instanceIdentifier2, instanceIdentifier1.pathArguments);
 144         wildCardField.set(instanceIdentifier4, true);
 145
 146         assertTrue(instanceIdentifier1.equals(instanceIdentifier2));
 147
 148         assertFalse(instanceIdentifier1.equals(instanceIdentifier3));
 149         assertFalse(instanceIdentifier1.equals(instanceIdentifier4));
 150         final InstanceIdentifier<Node> instanceIdentifier5 = InstanceIdentifier.create(Node.class);
 151         final Field hashField = InstanceIdentifier.class.getDeclaredField("hash");
 152         hashField.setAccessible(true);
 153         hashField.set(instanceIdentifier5, instanceIdentifier1.hashCode());
 154         wildCardField.set(instanceIdentifier5, false);
 155
 156         assertFalse(instanceIdentifier1.equals(instanceIdentifier5));
 157         assertNotNull(InstanceIdentifier.create(ImmutableList.copyOf(instanceIdentifier1.getPathArguments())));
 158         assertNotNull(InstanceIdentifier.create(Nodes.class).child(Node.class));
 159         assertNotNull(InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(5)));
 160         assertNotNull(instanceIdentifier5.augmentation(NodeAugmentation.class));
 161         assertNotNull(instanceIdentifier1.hashCode());
 162         assertNotNull(instanceIdentifier1.toString());
 163
 164         final InstanceIdentifierBuilder instanceIdentifierBuilder = instanceIdentifier1.builder();
 165         assertEquals(instanceIdentifier1.hashCode(), instanceIdentifierBuilder.hashCode());
 166         assertNotNull(instanceIdentifierBuilder.augmentation(InstantiatedFoo.class));
 167         assertNotNull(instanceIdentifierBuilder.build());
 168     }
 169
 170     @Test
 171     public void firstIdentifierOfTest() {
 172         final InstanceIdentifier<Node> instanceIdentifier =
 173                 InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).build();
 174         final InstanceIdentifier<Nodes> nodesIdentifier = instanceIdentifier.firstIdentifierOf(Nodes.class);
 175         assertNotNull(nodesIdentifier);
 176         final InstanceIdentifier<DataObject> dataObjectIdentifier =
 177                 instanceIdentifier.firstIdentifierOf(DataObject.class);
 178         assertNull(dataObjectIdentifier);
 179     }
 180
 181     @Test
 182     public void firstKeyOfTest() {
 183         final InstanceIdentifier<Node> instanceIdentifier =
 184                 InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build();
 185         final InstanceIdentifier<DataObject> instanceIdentifier1 = InstanceIdentifier.create(DataObject.class);
 186         assertNotNull(instanceIdentifier.firstKeyOf(Node.class));
 187         assertNull(instanceIdentifier1.firstKeyOf(Node.class));
 188     }
 189
 190     @Test
 191     public void keyOfTest() throws Exception {
 192         final Identifier<?> identifier = mock(Identifier.class);
 193         assertEquals(identifier, InstanceIdentifier.keyOf(
 194                 new KeyedInstanceIdentifier(Identifiable.class, ImmutableList.of(), false, 0, identifier)));
 195     }
 196
 197     @Test
 198     public void serializationTest() throws Exception {
 199         final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
 200         final ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
 201
 202         final InstanceIdentifier<DataObject> instanceIdentifier = InstanceIdentifier.create(DataObject.class);
 203         outputStream.writeObject(instanceIdentifier);
 204         outputStream.flush();
 205         outputStream.close();
 206
 207         final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
 208         final ObjectInputStream inputStream = new ObjectInputStream(byteArrayInputStream);
 209         final InstanceIdentifier<?> deserialized = (InstanceIdentifier<?>) inputStream.readObject();
 210
 211         assertEquals(instanceIdentifier, deserialized);
 212     }
 213
 214     @Test
 215     public void equalsTest() {
 216         final InstanceIdentifierBuilder<DataObject> builder1 =  InstanceIdentifier.create(DataObject.class).builder();
 217         final InstanceIdentifierBuilder<DataObject> builder2 =  InstanceIdentifier.create(DataObject.class).builder();
 218         final InstanceIdentifierBuilder<Nodes> builder3 =  InstanceIdentifier.create(Nodes.class).builder();
 219         final InstanceIdentifierBuilder<Nodes> builder4 =  InstanceIdentifier.create(Nodes.class).builder();
 220         final Object obj = new Object();
 221
 222         assertTrue(builder1.equals(builder2));
 223         assertTrue(builder2.equals(builder1));
 224         assertTrue(builder2.equals(builder2));
 225         assertTrue(builder3.equals(builder4));
 226         assertTrue(builder4.equals(builder4));
 227         assertFalse(builder3.equals(builder1));
 228         assertFalse(builder3.equals(null));
 229         assertFalse(builder4.equals(null));
 230         assertFalse(builder1.equals(obj));
 231
 232         builder3.child(Node.class, new NodeKey(10));
 233         assertFalse(builder3.equals(builder4));
 234         assertFalse(builder4.equals(builder3));
 235
 236         builder4.child(Node.class, new NodeKey(20));
 237         assertFalse(builder3.equals(builder4));
 238         assertFalse(builder4.equals(builder3));
 239
 240         InstanceIdentifierBuilder<Nodes> iib1 = new InstanceIdentifierBuilderImpl<>(null, null, 31, true);
 241         InstanceIdentifierBuilder<Nodes> iib2 = new InstanceIdentifierBuilderImpl<>(null, null, 31, false);
 242         InstanceIdentifierBuilder<Nodes> iib3 = new InstanceIdentifierBuilderImpl<>(null, null, 31, true);
 243         assertFalse(iib1.equals(iib2));
 244         assertFalse(iib2.equals(iib1));
 245         assertTrue(iib1.equals(iib3));
 246         assertTrue(iib3.equals(iib1));
 247     }
 248
 249     @Test
 250     public void hashCodeTest() {
 251         final InstanceIdentifierBuilder<DataObject> builder1 =  InstanceIdentifier.create(DataObject.class).builder();
 252         final InstanceIdentifierBuilder<DataObject> builder2 =  InstanceIdentifier.create(DataObject.class).builder();
 253         final InstanceIdentifierBuilder<Nodes> builder3 =  InstanceIdentifier.create(Nodes.class).builder();
 254         final InstanceIdentifierBuilder<Nodes> builder4 =  InstanceIdentifier.create(Nodes.class).builder();
 255         final Object obj = new Object();
 256
 257         assertTrue(builder1.hashCode() == builder2.hashCode());
 258         assertTrue(builder1.hashCode() != builder3.hashCode());
 259         assertTrue(builder3.hashCode() == builder4.hashCode());
 260         assertTrue(builder2.hashCode() != builder4.hashCode());
 261         assertTrue(builder1.hashCode() != obj.hashCode());
 262
 263         builder3.child(Node.class, new NodeKey(10));
 264
 265         assertTrue(builder3.hashCode() != builder4.hashCode());
 266     }
 267
 268     @Test
 269     public void verifyTargetTest() {
 270         final InstanceIdentifier<Nodes> nodeId = InstanceIdentifier.create(Nodes.class);
 271         assertSame(nodeId, nodeId.verifyTarget(Nodes.class));
 272         assertThrows(VerifyException.class, () -> nodeId.verifyTarget(Node.class));
 273     }
 274
 275 }