2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.yangtools.yang.binding;
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;
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;
38 public class InstanceIdentifierTest {
41 public void constructWithPredicates() {
42 final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
45 assertEquals(Nodes.class, nodes.getTargetType());
47 final InstanceIdentifier<Node> node = nodes.builder().child(Node.class).build();
50 assertEquals(Node.class, node.getTargetType());
52 assertTrue(nodes.contains(node));
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();
62 assertEquals(Node.class, node.getTargetType());
64 assertTrue(nodes.contains(node));
68 public void negativeContains() {
69 final InstanceIdentifier<FooChild> fooChild =
70 InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class).build();
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();
78 assertFalse(fooChild.contains(nodeTen));
79 assertFalse(nodeTen.contains(nodes));
81 assertFalse(nodeOne.contains(nodes));
82 assertTrue(nodes.contains(nodeOne));
84 assertTrue(nodes.containsWildcarded(nodeOne));
85 assertFalse(nodeOne.containsWildcarded(nodes));
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)
94 .child(NodeChild.class).build();
96 assertTrue(wildcarded.isWildcarded());
97 assertTrue(wildcardedChildren.isWildcarded());
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();
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));
112 final InstanceIdentifier<NodeChild> nodeTenChildWildcarded = InstanceIdentifier.builder(Nodes.class)
113 .child(Node.class, new NodeKey(10)).child(NodeChild.class).build();
115 assertTrue(nodeTenChildWildcarded.isWildcarded());
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();
122 assertFalse(nodeTenChildWildcarded.containsWildcarded(nodeOneChild));
123 assertTrue(nodeTenChildWildcarded.containsWildcarded(nodeTenChild));
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();
135 assertTrue(instanceIdentifier1.equals(instanceIdentifier1));
136 assertFalse(instanceIdentifier1.equals(null));
137 assertFalse(instanceIdentifier1.equals(object));
138 assertTrue(instanceIdentifier1.equals(instanceIdentifier2));
140 Whitebox.setInternalState(instanceIdentifier2, "pathArguments", instanceIdentifier1.pathArguments);
141 Whitebox.setInternalState(instanceIdentifier4, "wildcarded", true);
143 assertTrue(instanceIdentifier1.equals(instanceIdentifier2));
144 assertFalse(instanceIdentifier1.equals(instanceIdentifier3));
145 assertFalse(instanceIdentifier1.equals(instanceIdentifier4));
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);
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());
158 final InstanceIdentifier.Builder instanceIdentifierBuilder = instanceIdentifier1.builder();
159 assertEquals(instanceIdentifier1.hashCode(), instanceIdentifierBuilder.hashCode());
160 assertNotNull(instanceIdentifierBuilder.augmentation(InstantiatedFoo.class));
161 assertNotNull(instanceIdentifierBuilder.build());
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);
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));
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)));
192 public void serializationTest() throws IOException, ClassNotFoundException {
193 final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
194 final ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
196 final InstanceIdentifier<FooRoot> instanceIdentifier = InstanceIdentifier.create(FooRoot.class);
197 outputStream.writeObject(instanceIdentifier);
198 outputStream.flush();
199 outputStream.close();
201 final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
202 final ObjectInputStream inputStream = new ObjectInputStream(byteArrayInputStream);
203 final InstanceIdentifier<?> deserialized = (InstanceIdentifier<?>) inputStream.readObject();
205 assertEquals(instanceIdentifier, deserialized);
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();
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));
226 builder3.child(Node.class, new NodeKey(10));
227 assertFalse(builder3.equals(builder4));
228 assertFalse(builder4.equals(builder3));
230 builder4.child(Node.class, new NodeKey(20));
231 assertFalse(builder3.equals(builder4));
232 assertFalse(builder4.equals(builder3));
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();
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());
249 builder3.child(Node.class, new NodeKey(10));
251 assertTrue(builder3.hashCode() != builder4.hashCode());
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));