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