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