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 }