2 * Copyright (c) 2014 Brocade Communications 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
9 package org.opendaylight.yangtools.yang.data.api;
11 import static org.junit.Assert.assertEquals;
12 import static org.junit.Assert.assertFalse;
13 import static org.junit.Assert.assertNotEquals;
14 import static org.junit.Assert.assertNotNull;
15 import static org.junit.Assert.assertNull;
16 import static org.junit.Assert.assertSame;
17 import static org.junit.Assert.assertTrue;
18 import com.google.common.base.Optional;
19 import com.google.common.collect.ImmutableMap;
20 import com.google.common.collect.Lists;
21 import com.google.common.collect.Sets;
22 import java.io.ByteArrayInputStream;
23 import java.io.ByteArrayOutputStream;
24 import java.io.IOException;
25 import java.io.ObjectInputStream;
26 import java.io.ObjectOutputStream;
27 import java.util.Collections;
28 import java.util.Iterator;
29 import java.util.List;
30 import java.util.Map.Entry;
31 import org.junit.Test;
32 import org.opendaylight.yangtools.yang.common.QName;
33 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
34 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
35 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
36 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
37 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
40 * Unit tests for InstanceIdentifier.
42 * @author Thomas Pantelis
44 public class YangInstanceIdentifierTest {
46 private static final QName NODENAME1 = QName.create("test", "2014-5-28", "node1");
47 private static final QName NODENAME2 = QName.create("test", "2014-5-28", "node2");
48 private static final QName NODENAME3 = QName.create("test", "2014-5-28", "node3");
49 private static final QName NODENAME4 = QName.create("test", "2014-5-28", "node4");
50 private static final QName KEY1 = QName.create("test", "2014-5-28", "key1");
51 private static final QName KEY2 = QName.create("test", "2014-5-28", "key2");
52 private static final QName KEY3 = QName.create("test", "2014-5-28", "key3");
55 public void testGetLastPathArgument() {
56 YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
57 assertEquals( "getLastPathArgument", new NodeIdentifier(NODENAME2), id1.getLastPathArgument());
58 YangInstanceIdentifier id2 = YangInstanceIdentifier.create();
59 assertNull( id2.getLastPathArgument() );
63 public void testHashCodeEquals() {
64 YangInstanceIdentifier id1 = YangInstanceIdentifier.create(NodeIdentifier.create(NODENAME1), new NodeIdentifier(NODENAME2));
65 YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), NodeIdentifier.create(NODENAME2));
67 assertEquals( "hashCode", id1.hashCode(), id2.hashCode() );
71 public void testEquals() {
72 YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
73 YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
74 YangInstanceIdentifier id3 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME2), new NodeIdentifier(NODENAME1));
75 YangInstanceIdentifier id4 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
77 assertEquals( "equals", false, id1.equals( null ) );
78 assertEquals( "equals", true, id1.equals( id1 ) );
79 assertEquals( "equals", true, id1.equals( id2 ) );
80 assertEquals( "equals", false, id1.equals( id3 ) );
81 assertEquals( "equals", false, id1.equals( id4 ) );
82 assertEquals( "equals", false, id1.equals( new Object() ) );
86 public void testToString() {
87 YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
89 assertNotNull( id.toString() );
93 public void testNode() {
94 YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
96 YangInstanceIdentifier newID = id.node( NODENAME3 );
98 assertNotNull( "InstanceIdentifier is null", newID );
99 assertEquals( "Path size", 3, newID.getPathArguments().size() );
101 Iterator<PathArgument> it = newID.getPathArguments().iterator();
102 assertEquals( "PathArg 1 node type", NODENAME1, it.next().getNodeType() );
103 assertEquals( "PathArg 2 node type", NODENAME2, it.next().getNodeType() );
104 assertEquals( "PathArg 3 node type", NODENAME3, it.next().getNodeType() );
106 newID = id.node( new NodeIdentifier( NODENAME3 ) );
108 assertNotNull( "InstanceIdentifier is null", newID );
109 assertEquals( "Path size", 3, newID.getPathArguments().size() );
111 it = newID.getPathArguments().iterator();
112 assertEquals( "PathArg 1 node type", NODENAME1, it.next().getNodeType() );
113 assertEquals( "PathArg 2 node type", NODENAME2, it.next().getNodeType() );
114 assertEquals( "PathArg 3 node type", NODENAME3, it.next().getNodeType() );
118 public void testRelativeTo() {
120 YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2),
121 new NodeIdentifier(NODENAME3), new NodeIdentifier(NODENAME4));
122 YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
123 YangInstanceIdentifier id3 = YangInstanceIdentifier.create(
124 Lists.newArrayList(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2)));
126 Optional<YangInstanceIdentifier> relative = id1.relativeTo( id2 );
127 assertEquals( "isPresent", true, relative.isPresent() );
129 List<PathArgument> p = relative.get().getPathArguments();
130 assertEquals( "Path size", 2, p.size() );
131 assertEquals( "PathArg 1 node type", NODENAME3, p.get(0).getNodeType() );
132 assertEquals( "PathArg 2 node type", NODENAME4, p.get(1).getNodeType() );
134 relative = id2.relativeTo( id3 );
135 assertEquals( "isPresent", true, relative.isPresent() );
136 assertEquals( "Path size", 0, relative.get().getPathArguments().size() );
138 relative = id2.relativeTo( id1 );
139 assertEquals( "isPresent", false, relative.isPresent() );
142 @Test(expected=IllegalArgumentException.class)
143 public void testContainsNull() {
144 final YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
150 public void testContains() {
152 YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2),
153 new NodeIdentifier(NODENAME3), new NodeIdentifier(NODENAME4));
154 YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
155 YangInstanceIdentifier id3 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
156 YangInstanceIdentifier id4 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME3));
158 assertEquals( "contains", true, id2.contains( id1 ) );
159 assertEquals( "contains", true, id2.contains( id3 ) );
160 assertEquals( "contains", false, id1.contains( id2 ) );
161 assertEquals( "contains", false, id2.contains( id4 ) );
165 public void testOf() {
167 YangInstanceIdentifier newID = YangInstanceIdentifier.of( NODENAME1 );
169 assertNotNull( "InstanceIdentifier is null", newID );
170 assertEquals( "Path size", 1, newID.getPathArguments().size() );
171 assertEquals( "PathArg 1 node type", NODENAME1, newID.getPathArguments().get(0).getNodeType() );
173 assertNotNull( newID.toString() ); // for code coverage
177 public void testBuilder() {
179 YangInstanceIdentifier newID = YangInstanceIdentifier.builder()
181 .nodeWithKey( NODENAME2, Collections.<QName,Object>singletonMap( KEY1, "foo" ) )
182 .nodeWithKey( NODENAME3, KEY2, "bar" ).build();
184 assertNotNull( "InstanceIdentifier is null", newID );
185 assertEquals( "Path size", 3, newID.getPathArguments().size() );
187 Iterator<PathArgument> it = newID.getPathArguments().iterator();
188 assertEquals( "PathArg 1 node type", NODENAME1, it.next().getNodeType() );
189 verifyNodeIdentifierWithPredicates( "PathArg 2", it.next(), NODENAME2, KEY1, "foo" );
190 verifyNodeIdentifierWithPredicates( "PathArg 3", it.next(), NODENAME3, KEY2, "bar" );
192 newID = YangInstanceIdentifier.builder( newID ).node( NODENAME4 ).build();
194 assertNotNull( "InstanceIdentifier is null", newID );
195 assertEquals( "Path size", 4, newID.getPathArguments().size() );
197 it = newID.getPathArguments().iterator();
198 assertEquals( "PathArg 1 node type", NODENAME1, it.next().getNodeType() );
199 assertEquals( "PathArg 2 node type", NODENAME2, it.next().getNodeType() );
200 assertEquals( "PathArg 3 node type", NODENAME3, it.next().getNodeType() );
201 assertEquals( "PathArg 4 node type", NODENAME4, it.next().getNodeType() );
203 newID = YangInstanceIdentifier.builder().node( NODENAME1 ).build();
205 assertNotNull( "InstanceIdentifier is null", newID );
206 assertEquals( "Path size", 1, newID.getPathArguments().size() );
207 assertEquals( "PathArg 1 node type", NODENAME1, newID.getPathArguments().get(0).getNodeType() );
210 private static void verifyNodeIdentifierWithPredicates(final String prefix,
211 final PathArgument arg, final QName nodeName, final QName key, final Object value ) {
213 assertNotNull( prefix + " is null", arg );
214 assertEquals( prefix + " class", NodeIdentifierWithPredicates.class, arg.getClass() );
215 NodeIdentifierWithPredicates node = (NodeIdentifierWithPredicates)arg;
216 assertEquals( prefix + " node type", nodeName, node.getNodeType() );
217 assertEquals( prefix + " key values map size", 1, node.getKeyValues().size() );
218 Entry<QName, Object> entry = node.getKeyValues().entrySet().iterator().next();
219 assertEquals( prefix + " key values map entry key", key, entry.getKey() );
220 assertEquals( prefix + " key values map entry value", value, entry.getValue() );
224 public void testNodeIdentifierWithPredicates() {
226 NodeIdentifierWithPredicates node1 = new NodeIdentifierWithPredicates( NODENAME1, KEY1, "foo" );
227 verifyNodeIdentifierWithPredicates( "NodeIdentifierWithPredicates", node1, NODENAME1, KEY1, "foo" );
229 NodeIdentifierWithPredicates node2 = new NodeIdentifierWithPredicates( NODENAME1, KEY1, "foo" );
231 assertEquals( "hashCode", node1.hashCode(), node2.hashCode() );
232 assertEquals( "equals", true, node1.equals( node2 ) );
234 assertEquals( "equals", false,
235 node1.equals( new NodeIdentifierWithPredicates( NODENAME2, KEY1, "foo" ) ) );
236 assertEquals( "equals", false,
237 node1.equals( new NodeIdentifierWithPredicates( NODENAME1, KEY2, "foo" ) ) );
238 assertEquals( "equals", false,
239 node1.equals( new NodeIdentifierWithPredicates( NODENAME1, KEY1, "bar" ) ) );
240 assertEquals( "equals", false, node1.equals( new Object() ) );
242 assertNotNull( node1.toString() ); // for code coverage
243 assertNotNull( node1.toRelativeString(node2) );
245 NodeIdentifierWithPredicates node3 = new NodeIdentifierWithPredicates( NODENAME1,
246 ImmutableMap.<QName, Object>builder().put( KEY1, 10 ).put( KEY2, 20 ).build() );
248 NodeIdentifierWithPredicates node4 = new NodeIdentifierWithPredicates( NODENAME1,
249 ImmutableMap.<QName, Object>builder().put( KEY1, 10 ).put( KEY2, 20 ).build() );
251 assertEquals( "hashCode", node3.hashCode(), node4.hashCode() );
252 assertEquals( "equals", true, node3.equals( node4 ) );
254 assertEquals( "equals", false, node3.equals( node1 ) );
255 assertEquals( "equals", false,
256 node1.equals( new NodeIdentifierWithPredicates( NODENAME1,
257 ImmutableMap.<QName, Object>builder().put( KEY1, 10 ).put( KEY3, 20 ).build() ) ) );
259 node1 = new NodeIdentifierWithPredicates( NODENAME1, KEY1, new byte[]{1,2} );
260 node2 = new NodeIdentifierWithPredicates( NODENAME1, KEY1, new byte[]{1,2} );
262 assertEquals( "hashCode", node1.hashCode(), node2.hashCode() );
263 assertEquals( "equals", true, node1.equals( node2 ) );
265 assertEquals( "equals", false,
266 node1.equals( new NodeIdentifierWithPredicates( NODENAME1, KEY1, new byte[]{1,3} ) ) );
267 assertEquals( "equals", false,
268 node1.equals( new NodeIdentifierWithPredicates( NODENAME1, KEY1, new byte[]{1} ) ) );
269 assertEquals( "equals", false,
270 node1.equals( new NodeIdentifierWithPredicates( NODENAME1, KEY1, new byte[]{1,2,3} ) ) );
274 public void testNodeWithValue() {
276 NodeWithValue<?> node1 = new NodeWithValue<>( NODENAME1, "foo" );
277 assertEquals( "getNodeType", NODENAME1, node1.getNodeType() );
278 assertEquals( "getValue", "foo", node1.getValue() );
280 NodeWithValue<?> node2 = new NodeWithValue<>( NODENAME1, "foo" );
282 assertEquals( "hashCode", node1.hashCode(), node2.hashCode() );
283 assertEquals( "equals", true, node1.equals( node2 ) );
285 assertEquals( "equals", false, node1.equals( new NodeWithValue<>( NODENAME1, "bar" ) ) );
286 assertEquals( "equals", false, node1.equals( new NodeWithValue<>( NODENAME2, "foo" ) ) );
287 assertEquals( "equals", false, node1.equals( new Object() ) );
289 assertNotNull( node1.toString() ); // for code coverage
290 assertNotNull( node1.toRelativeString(node2) );
292 NodeWithValue<?> node3 = new NodeWithValue<>( NODENAME1, new byte[]{1,2} );
293 NodeWithValue<?> node4 = new NodeWithValue<>( NODENAME1, new byte[]{1,2} );
295 assertEquals( "hashCode", node3.hashCode(), node4.hashCode() );
296 assertEquals( "equals", true, node3.equals( node4 ) );
298 assertEquals( "equals", false, node3.equals( new NodeWithValue<>( NODENAME1, new byte[]{1,3} ) ) );
299 assertEquals( "equals", false, node3.equals( node1 ) );
303 public void testNodeIdentifier() {
305 NodeIdentifier node1 = new NodeIdentifier( NODENAME1 );
306 assertEquals( "getNodeType", NODENAME1, node1.getNodeType() );
307 NodeIdentifier node2 = new NodeIdentifier( NODENAME1 );
308 AugmentationIdentifier node3 = new AugmentationIdentifier( Sets.newHashSet( NODENAME1, NODENAME2 ) );
310 assertEquals( "hashCode", node1.hashCode(), node2.hashCode() );
311 assertEquals( "compareTo", 0, node1.compareTo( node2 ) );
312 assertEquals( "compareTo", true, node1.compareTo( new NodeIdentifier( NODENAME3 ) ) != 0 );
314 assertEquals( "equals", false, node1.equals( null ) );
315 assertEquals( "equals", false, node1.equals( node3 ) );
316 assertEquals( "equals", true, node1.equals( node1 ) );
317 assertEquals( "equals", true, node1.equals( node2 ) );
318 assertEquals( "equals", false, node1.equals( new NodeIdentifier( NODENAME3 ) ) );
319 assertEquals( "equals", false, node1.equals( new Object() ) );
321 assertNotNull( node1.toString() ); // for code coverage
324 @Test(expected=UnsupportedOperationException.class)
325 public void testAugmentationIdentifierNodeType() {
326 AugmentationIdentifier node1 = new AugmentationIdentifier( Sets.newHashSet( NODENAME1, NODENAME2 ) );
331 public void testAugmentationIdentifier() {
333 AugmentationIdentifier node1 = new AugmentationIdentifier( Sets.newHashSet( NODENAME1, NODENAME2 ) );
334 assertEquals( "getPossibleChildNames", Sets.newHashSet( NODENAME1, NODENAME2 ), node1.getPossibleChildNames() );
335 AugmentationIdentifier node2 = new AugmentationIdentifier( Sets.newHashSet( NODENAME2, NODENAME1 ) );
336 AugmentationIdentifier node3 = new AugmentationIdentifier( Sets.newHashSet( NODENAME1, NODENAME3 ) );
337 AugmentationIdentifier node4 = new AugmentationIdentifier( Sets.newHashSet( NODENAME1, NODENAME2, NODENAME3 ) );
338 NodeIdentifier node5 = new NodeIdentifier( NODENAME3 );
340 assertEquals( "hashCode", node1.hashCode(), node2.hashCode() );
342 assertEquals( "equals", true, node1.equals( node1 ) );
343 assertEquals( "equals", true, node1.equals( node2 ) );
344 assertEquals( "equals", false, node1.equals( node3 ) );
345 assertEquals( "equals", false, node1.equals( new AugmentationIdentifier( Sets.newHashSet( NODENAME1 ) ) ) );
346 assertEquals( "equals", false, node1.equals( new Object() ) );
348 assertEquals( "compareTo", -1, node1.compareTo( node5 ) );
349 assertNotEquals( "compareTo", -1, node1.compareTo( node2 ) );
350 assertEquals( "compareTo", 0, node1.compareTo( node2 ) );
351 assertEquals( "compareTo", 1, node1.compareTo( node4 ) );
352 assertEquals( "compareTo", -1, node4.compareTo( node1 ) );
354 assertNotNull( node1.toString() ); // for code coverage
355 assertNotNull( node1.toRelativeString(node5));
358 private static YangInstanceIdentifier serdes(final YangInstanceIdentifier id) throws IOException, ClassNotFoundException {
359 final ByteArrayOutputStream bos = new ByteArrayOutputStream();
360 try (final ObjectOutputStream oos = new ObjectOutputStream(bos)) {
364 final byte[] bytes = bos.toByteArray();
365 final ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
366 try (final ObjectInputStream ois = new ObjectInputStream(bis)) {
367 final YangInstanceIdentifier ret = (YangInstanceIdentifier) ois.readObject();
368 assertEquals(0, ois.available());
374 public void testSerialization() throws IOException, ClassNotFoundException {
375 final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
376 new NodeIdentifier(NODENAME2));
377 assertEquals(fixed, serdes(fixed));
379 final YangInstanceIdentifier stacked = YangInstanceIdentifier.EMPTY.node(new NodeIdentifier(NODENAME1));
380 assertEquals(stacked, serdes(stacked));
382 final YangInstanceIdentifier empty = serdes(YangInstanceIdentifier.EMPTY);
383 assertSame(YangInstanceIdentifier.EMPTY, empty);
387 public void testToOptimized() {
388 final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
389 new NodeIdentifier(NODENAME2));
390 final YangInstanceIdentifier stacked = YangInstanceIdentifier.EMPTY.node(NodeIdentifier.create(NODENAME1))
391 .node(NodeIdentifier.create(NODENAME2));
393 assertSame(fixed, fixed.toOptimized());
395 final YangInstanceIdentifier opt = stacked.toOptimized();
396 assertTrue(opt instanceof FixedYangInstanceIdentifier);
397 assertEquals(fixed, stacked.toOptimized());
401 public void testGetParent() {
402 final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
403 final YangInstanceIdentifier stacked = YangInstanceIdentifier.EMPTY.node(new NodeIdentifier(NODENAME1));
404 final YangInstanceIdentifier twoStacked = stacked.node(new NodeIdentifier(NODENAME2));
406 assertNull(YangInstanceIdentifier.EMPTY.getParent());
407 assertSame(YangInstanceIdentifier.EMPTY, fixed.getParent());
408 assertSame(YangInstanceIdentifier.EMPTY, stacked.getParent());
409 assertSame(stacked, twoStacked.getParent());
413 public void testIsEmpty() {
414 final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
415 final YangInstanceIdentifier stacked = YangInstanceIdentifier.EMPTY.node(new NodeIdentifier(NODENAME1));
417 assertTrue(YangInstanceIdentifier.EMPTY.isEmpty());
418 assertFalse(fixed.isEmpty());
419 assertFalse(stacked.isEmpty());