git.opendaylight Code Review - yangtools.git/blob

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