Remove Augmentation{Identifier,Node}
[yangtools.git] / data / yang-data-api / src / test / java / org / opendaylight / yangtools / yang / data / api / YangInstanceIdentifierTest.java
1 /*
2  * Copyright (c) 2014 Brocade Communications 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.data.api;
9
10 import static org.junit.jupiter.api.Assertions.assertEquals;
11 import static org.junit.jupiter.api.Assertions.assertFalse;
12 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
13 import static org.junit.jupiter.api.Assertions.assertNotNull;
14 import static org.junit.jupiter.api.Assertions.assertNull;
15 import static org.junit.jupiter.api.Assertions.assertSame;
16 import static org.junit.jupiter.api.Assertions.assertThrows;
17 import static org.junit.jupiter.api.Assertions.assertTrue;
18
19 import java.io.ByteArrayInputStream;
20 import java.io.ByteArrayOutputStream;
21 import java.io.IOException;
22 import java.io.ObjectInputStream;
23 import java.io.ObjectOutputStream;
24 import java.util.Iterator;
25 import java.util.List;
26 import java.util.Map;
27 import java.util.Map.Entry;
28 import java.util.Optional;
29 import org.junit.jupiter.api.Test;
30 import org.opendaylight.yangtools.yang.common.QName;
31 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
32 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
33 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
34 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
35
36 /**
37  * Unit tests for InstanceIdentifier.
38  *
39  * @author Thomas Pantelis
40  */
41 public class YangInstanceIdentifierTest {
42     private static final QName NODENAME1 = QName.create("test", "2014-05-28", "node1");
43     private static final QName NODENAME2 = QName.create("test", "2014-05-28", "node2");
44     private static final QName NODENAME3 = QName.create("test", "2014-05-28", "node3");
45     private static final QName NODENAME4 = QName.create("test", "2014-05-28", "node4");
46     private static final QName KEY1 = QName.create("test", "2014-05-28", "key1");
47     private static final QName KEY2 = QName.create("test", "2014-05-28", "key2");
48     private static final QName KEY3 = QName.create("test", "2014-05-28", "key3");
49
50     @Test
51     public void testGetLastPathArgument() {
52         YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
53                 new NodeIdentifier(NODENAME2));
54         assertEquals(new NodeIdentifier(NODENAME2), id1.getLastPathArgument());
55         YangInstanceIdentifier id2 = YangInstanceIdentifier.create();
56         assertNull(id2.getLastPathArgument());
57     }
58
59     @Test
60     public void testHashCodeEquals() {
61         YangInstanceIdentifier id1 = YangInstanceIdentifier.create(NodeIdentifier.create(NODENAME1),
62                 new NodeIdentifier(NODENAME2));
63         YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
64                 NodeIdentifier.create(NODENAME2));
65         assertEquals(id1.hashCode(), id2.hashCode());
66     }
67
68     @Test
69     public void testEquals() {
70         final YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
71                 new NodeIdentifier(NODENAME2));
72         final YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
73                 new NodeIdentifier(NODENAME2));
74         final YangInstanceIdentifier id3 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME2),
75                 new NodeIdentifier(NODENAME1));
76         final YangInstanceIdentifier id4 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
77
78         assertFalse(id1.equals(null));
79         assertTrue(id1.equals(id1));
80         assertTrue(id1.equals(id2));
81         assertFalse(id1.equals(id3));
82         assertFalse(id1.equals(id4));
83         assertFalse(id1.equals(new Object()));
84     }
85
86     @Test
87     public void testToString() {
88         YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
89                 new NodeIdentifier(NODENAME2));
90
91         assertNotNull(id.toString());
92     }
93
94     @Test
95     public void testNode() {
96         final YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
97                 new NodeIdentifier(NODENAME2));
98
99         YangInstanceIdentifier newID = id.node(NODENAME3);
100         assertNotNull(newID);
101         assertEquals(3, newID.getPathArguments().size());
102
103         Iterator<PathArgument> it = newID.getPathArguments().iterator();
104         assertEquals(NODENAME1, it.next().getNodeType());
105         assertEquals(NODENAME2, it.next().getNodeType());
106         assertEquals(NODENAME3, it.next().getNodeType());
107
108         newID = id.node(new NodeIdentifier(NODENAME3));
109         assertNotNull(newID);
110         assertEquals(3, newID.getPathArguments().size());
111
112         it = newID.getPathArguments().iterator();
113         assertEquals(NODENAME1, it.next().getNodeType());
114         assertEquals(NODENAME2, it.next().getNodeType());
115         assertEquals(NODENAME3, it.next().getNodeType());
116     }
117
118     @Test
119     public void testRelativeTo() {
120         final YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
121                 new NodeIdentifier(NODENAME2), new NodeIdentifier(NODENAME3), new NodeIdentifier(NODENAME4));
122         final YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
123                 new NodeIdentifier(NODENAME2));
124         final YangInstanceIdentifier id3 = YangInstanceIdentifier.create(List.of(
125                     new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2)));
126
127         Optional<YangInstanceIdentifier> relative = id1.relativeTo(id2);
128         assertTrue(relative.isPresent());
129
130         List<PathArgument> path = relative.orElseThrow().getPathArguments();
131         assertEquals(2, path.size());
132         assertEquals(NODENAME3, path.get(0).getNodeType());
133         assertEquals(NODENAME4, path.get(1).getNodeType());
134
135         relative = id2.relativeTo(id3);
136         assertTrue(relative.isPresent());
137         assertEquals(0, relative.orElseThrow().getPathArguments().size());
138
139         relative = id2.relativeTo(id1);
140         assertFalse(relative.isPresent());
141     }
142
143     @Test
144     public void testContainsNull() {
145         final YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
146
147         assertThrows(IllegalArgumentException.class, () -> id.contains(null));
148     }
149
150     @Test
151     public void testContains() {
152         final YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
153                 new NodeIdentifier(NODENAME2), new NodeIdentifier(NODENAME3), new NodeIdentifier(NODENAME4));
154         final YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
155                 new NodeIdentifier(NODENAME2));
156         final YangInstanceIdentifier id3 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
157                 new NodeIdentifier(NODENAME2));
158         final YangInstanceIdentifier id4 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
159                 new NodeIdentifier(NODENAME3));
160
161         assertTrue(id2.contains(id1));
162         assertTrue(id2.contains(id3));
163         assertFalse(id1.contains(id2));
164         assertFalse(id2.contains(id4));
165     }
166
167     @Test
168     public void testOf() {
169         YangInstanceIdentifier newID = YangInstanceIdentifier.of(NODENAME1);
170         assertNotNull(newID);
171         assertEquals(1, newID.getPathArguments().size());
172         assertEquals(NODENAME1, newID.getPathArguments().get(0).getNodeType());
173
174         // for code coverage
175         assertNotNull(newID.toString());
176     }
177
178     @Test
179     public void testBuilder() {
180         YangInstanceIdentifier newID = YangInstanceIdentifier.builder()
181                 .node(NODENAME1)
182                 .nodeWithKey(NODENAME2, Map.of(KEY1, "foo"))
183                 .nodeWithKey(NODENAME3, KEY2, "bar").build();
184
185         assertNotNull(newID);
186         assertEquals(3, newID.getPathArguments().size());
187
188         Iterator<PathArgument> it = newID.getPathArguments().iterator();
189         assertEquals(NODENAME1, it.next().getNodeType());
190         verifyNodeIdentifierWithPredicates("PathArg 2", it.next(), NODENAME2, KEY1, "foo");
191         verifyNodeIdentifierWithPredicates("PathArg 3", it.next(), NODENAME3, KEY2, "bar");
192
193         newID = YangInstanceIdentifier.builder(newID).node(NODENAME4).build();
194
195         assertNotNull(newID);
196         assertEquals(4, newID.getPathArguments().size());
197
198         it = newID.getPathArguments().iterator();
199         assertEquals(NODENAME1, it.next().getNodeType());
200         assertEquals(NODENAME2, it.next().getNodeType());
201         assertEquals(NODENAME3, it.next().getNodeType());
202         assertEquals(NODENAME4, it.next().getNodeType());
203
204         newID = YangInstanceIdentifier.builder().node(NODENAME1).build();
205
206         assertNotNull(newID);
207         assertEquals(1, newID.getPathArguments().size());
208         assertEquals(NODENAME1, newID.getPathArguments().get(0).getNodeType());
209     }
210
211     private static void verifyNodeIdentifierWithPredicates(final String prefix,
212             final PathArgument arg, final QName nodeName, final QName key, final Object value) {
213
214         assertNotNull(arg, prefix + " is null");
215         assertInstanceOf(NodeIdentifierWithPredicates.class, arg);
216         NodeIdentifierWithPredicates node = (NodeIdentifierWithPredicates)arg;
217         assertEquals(nodeName, node.getNodeType(), prefix + " node type");
218         assertEquals(1, node.size(), prefix + " key values map size");
219         Entry<QName, Object> entry = node.entrySet().iterator().next();
220         assertEquals(key, entry.getKey(), prefix + " key values map entry key");
221         assertEquals(value, entry.getValue(), prefix + " key values map entry value");
222     }
223
224     @Test
225     public void testNodeIdentifierWithPredicates() {
226
227         NodeIdentifierWithPredicates node1 = NodeIdentifierWithPredicates.of(NODENAME1, KEY1, "foo");
228         verifyNodeIdentifierWithPredicates("NodeIdentifierWithPredicates", node1, NODENAME1, KEY1, "foo");
229
230         NodeIdentifierWithPredicates node2 = NodeIdentifierWithPredicates.of(NODENAME1, KEY1, "foo");
231
232         assertEquals(node1.hashCode(), node2.hashCode());
233         assertTrue(node1.equals(node2));
234
235         assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME2, KEY1, "foo")));
236         assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY2, "foo")));
237         assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, "bar")));
238         assertFalse(node1.equals(new Object()));
239
240         // for code coverage
241         assertNotNull(node1.toString());
242         assertNotNull(node1.toRelativeString(node2));
243
244         NodeIdentifierWithPredicates node3 = NodeIdentifierWithPredicates.of(NODENAME1, Map.of(KEY1, 10, KEY2, 20));
245
246         NodeIdentifierWithPredicates node4 = NodeIdentifierWithPredicates.of(NODENAME1, Map.of(KEY1, 10, KEY2, 20));
247
248         assertEquals(node3.hashCode(), node4.hashCode());
249         assertTrue(node3.equals(node4));
250
251         assertFalse(node3.equals(node1));
252         assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, Map.of(KEY1, 10, KEY3, 20))));
253
254         node1 = NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1, 2 });
255         node2 = NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1, 2 });
256
257         assertEquals(node1.hashCode(), node2.hashCode());
258         assertTrue(node1.equals(node2));
259
260         assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1, 3})));
261         assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1 })));
262         assertFalse(node1.equals(NodeIdentifierWithPredicates.of(NODENAME1, KEY1, new byte[]{ 1, 2, 3 })));
263     }
264
265     @Test
266     public void testNodeWithValue() {
267
268         NodeWithValue<?> node1 = new NodeWithValue<>(NODENAME1, "foo");
269         assertEquals(NODENAME1, node1.getNodeType());
270         assertEquals("foo", node1.getValue());
271
272         NodeWithValue<?> node2 = new NodeWithValue<>(NODENAME1, "foo");
273
274         assertEquals(node1.hashCode(), node2.hashCode());
275         assertTrue(node1.equals(node2));
276
277         assertFalse(node1.equals(new NodeWithValue<>(NODENAME1, "bar")));
278         assertFalse(node1.equals(new NodeWithValue<>(NODENAME2, "foo")));
279         assertFalse(node1.equals(new Object()));
280
281         // for code coverage
282         assertNotNull(node1.toString());
283         assertNotNull(node1.toRelativeString(node2));
284
285         NodeWithValue<?> node3 = new NodeWithValue<>(NODENAME1, new byte[]{1,2});
286         NodeWithValue<?> node4 = new NodeWithValue<>(NODENAME1, new byte[]{1,2});
287
288         assertEquals(node3.hashCode(), node4.hashCode());
289         assertTrue(node3.equals(node4));
290
291         assertFalse(node3.equals(new NodeWithValue<>(NODENAME1, new byte[]{1,3})));
292         assertFalse(node3.equals(node1));
293     }
294
295     @Test
296     public void testNodeIdentifier() {
297
298         final NodeIdentifier node1 = new NodeIdentifier(NODENAME1);
299         assertEquals(NODENAME1, node1.getNodeType());
300         final NodeIdentifier node2 = new NodeIdentifier(NODENAME1);
301
302         assertEquals(node1.hashCode(), node2.hashCode());
303         assertEquals(0, node1.compareTo(node2));
304         assertTrue(node1.compareTo(new NodeIdentifier(NODENAME3)) != 0);
305
306         assertFalse(node1.equals(null));
307         assertTrue(node1.equals(node1));
308         assertTrue(node1.equals(node2));
309         assertFalse(node1.equals(new NodeIdentifier(NODENAME3)));
310         assertFalse(node1.equals(new Object()));
311
312         // for code coverage
313         assertNotNull(node1.toString());
314     }
315
316     private static YangInstanceIdentifier serdes(final YangInstanceIdentifier id) throws IOException,
317             ClassNotFoundException {
318         final ByteArrayOutputStream bos = new ByteArrayOutputStream();
319         try (ObjectOutputStream oos = new ObjectOutputStream(bos)) {
320             oos.writeObject(id);
321         }
322
323         final byte[] bytes = bos.toByteArray();
324         final ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
325         try (ObjectInputStream ois = new ObjectInputStream(bis)) {
326             final YangInstanceIdentifier ret = (YangInstanceIdentifier) ois.readObject();
327             assertEquals(0, ois.available());
328             return ret;
329         }
330     }
331
332     @Test
333     public void testSerialization() throws IOException, ClassNotFoundException {
334         final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
335             new NodeIdentifier(NODENAME2));
336         assertEquals(fixed, serdes(fixed));
337
338         final YangInstanceIdentifier stacked = YangInstanceIdentifier.empty().node(new NodeIdentifier(NODENAME1));
339         assertEquals(stacked, serdes(stacked));
340
341         final YangInstanceIdentifier empty = serdes(YangInstanceIdentifier.empty());
342         assertSame(YangInstanceIdentifier.empty(), empty);
343     }
344
345     @Test
346     public void testToOptimized() {
347         final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
348             new NodeIdentifier(NODENAME2));
349         final YangInstanceIdentifier stacked = YangInstanceIdentifier.empty().node(NodeIdentifier.create(NODENAME1))
350                 .node(NodeIdentifier.create(NODENAME2));
351
352         assertSame(fixed, fixed.toOptimized());
353
354         final YangInstanceIdentifier opt = stacked.toOptimized();
355         assertTrue(opt instanceof FixedYangInstanceIdentifier);
356         assertEquals(fixed, stacked.toOptimized());
357     }
358
359     @Test
360     public void testGetParent() {
361         final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
362         final YangInstanceIdentifier stacked = YangInstanceIdentifier.empty().node(new NodeIdentifier(NODENAME1));
363         final YangInstanceIdentifier twoStacked = stacked.node(new NodeIdentifier(NODENAME2));
364
365         assertNull(YangInstanceIdentifier.empty().getParent());
366         assertSame(YangInstanceIdentifier.empty(), fixed.getParent());
367         assertSame(YangInstanceIdentifier.empty(), stacked.getParent());
368         assertSame(stacked, twoStacked.getParent());
369     }
370
371     @Test
372     public void testIsEmpty() {
373         final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
374         final YangInstanceIdentifier stacked = YangInstanceIdentifier.empty().node(new NodeIdentifier(NODENAME1));
375
376         assertTrue(YangInstanceIdentifier.empty().isEmpty());
377         assertFalse(fixed.isEmpty());
378         assertFalse(stacked.isEmpty());
379     }
380 }