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