yang/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
   9 package org.opendaylight.yangtools.yang.data.api;
  10
  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;
  38
  39 /**
  40  * Unit tests for InstanceIdentifier.
  41  *
  42  * @author Thomas Pantelis
  43  */
  44 public class YangInstanceIdentifierTest {
  45
  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");
  53
  54     @Test
  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() );
  60     }
  61
  62     @Test
  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));
  66
  67         assertEquals( "hashCode", id1.hashCode(), id2.hashCode() );
  68     }
  69
  70     @Test
  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));
  76
  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() ) );
  83     }
  84
  85     @Test
  86     public void testToString() {
  87         YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
  88
  89         assertNotNull( id.toString() );
  90     }
  91
  92     @Test
  93     public void testNode() {
  94         YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
  95
  96         YangInstanceIdentifier newID = id.node( NODENAME3 );
  97
  98         assertNotNull( "InstanceIdentifier is null", newID );
  99         assertEquals( "Path size", 3, newID.getPathArguments().size() );
 100
 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() );
 105
 106         newID = id.node( new NodeIdentifier( NODENAME3 ) );
 107
 108         assertNotNull( "InstanceIdentifier is null", newID );
 109         assertEquals( "Path size", 3, newID.getPathArguments().size() );
 110
 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() );
 115     }
 116
 117     @Test
 118     public void testRelativeTo() {
 119
 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)));
 125
 126         Optional<YangInstanceIdentifier> relative = id1.relativeTo( id2 );
 127         assertEquals( "isPresent", true, relative.isPresent() );
 128
 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() );
 133
 134         relative = id2.relativeTo( id3 );
 135         assertEquals( "isPresent", true, relative.isPresent() );
 136         assertEquals( "Path size", 0, relative.get().getPathArguments().size() );
 137
 138         relative = id2.relativeTo( id1 );
 139         assertEquals( "isPresent", false, relative.isPresent() );
 140     }
 141
 142     @Test(expected=IllegalArgumentException.class)
 143     public void testContainsNull() {
 144         final YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
 145
 146         id.contains( null );
 147     }
 148
 149     @Test
 150     public void testContains() {
 151
 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));
 157
 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 ) );
 162     }
 163
 164     @Test
 165     public void testOf() {
 166
 167         YangInstanceIdentifier newID = YangInstanceIdentifier.of( NODENAME1 );
 168
 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() );
 172
 173         assertNotNull( newID.toString() ); // for code coverage
 174     }
 175
 176     @Test
 177     public void testBuilder() {
 178
 179         YangInstanceIdentifier newID = YangInstanceIdentifier.builder()
 180                 .node( NODENAME1 )
 181                 .nodeWithKey( NODENAME2, Collections.singletonMap( KEY1, "foo" ) )
 182                 .nodeWithKey( NODENAME3, KEY2, "bar" ).build();
 183
 184         assertNotNull( "InstanceIdentifier is null", newID );
 185         assertEquals( "Path size", 3, newID.getPathArguments().size() );
 186
 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" );
 191
 192         newID = YangInstanceIdentifier.builder( newID ).node( NODENAME4 ).build();
 193
 194         assertNotNull( "InstanceIdentifier is null", newID );
 195         assertEquals( "Path size", 4, newID.getPathArguments().size() );
 196
 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() );
 202
 203         newID = YangInstanceIdentifier.builder().node( NODENAME1 ).build();
 204
 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() );
 208     }
 209
 210     private static void verifyNodeIdentifierWithPredicates(final String prefix,
 211             final PathArgument arg, final QName nodeName, final QName key, final Object value ) {
 212
 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() );
 221     }
 222
 223     @Test
 224     public void testNodeIdentifierWithPredicates() {
 225
 226         NodeIdentifierWithPredicates node1 = new NodeIdentifierWithPredicates( NODENAME1, KEY1, "foo" );
 227         verifyNodeIdentifierWithPredicates( "NodeIdentifierWithPredicates", node1, NODENAME1, KEY1, "foo" );
 228
 229         NodeIdentifierWithPredicates node2 = new NodeIdentifierWithPredicates( NODENAME1, KEY1, "foo" );
 230
 231         assertEquals( "hashCode", node1.hashCode(), node2.hashCode() );
 232         assertEquals( "equals", true, node1.equals( node2 ) );
 233
 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() ) );
 241
 242         assertNotNull( node1.toString() ); // for code coverage
 243         assertNotNull( node1.toRelativeString(node2) );
 244
 245         NodeIdentifierWithPredicates node3 = new NodeIdentifierWithPredicates( NODENAME1,
 246                 ImmutableMap.<QName, Object>builder().put( KEY1, 10 ).put( KEY2, 20 ).build() );
 247
 248         NodeIdentifierWithPredicates node4 = new NodeIdentifierWithPredicates( NODENAME1,
 249                 ImmutableMap.<QName, Object>builder().put( KEY1, 10 ).put( KEY2, 20 ).build() );
 250
 251         assertEquals( "hashCode", node3.hashCode(), node4.hashCode() );
 252         assertEquals( "equals", true, node3.equals( node4 ) );
 253
 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() ) ) );
 258
 259         node1 = new NodeIdentifierWithPredicates( NODENAME1, KEY1, new byte[]{1,2} );
 260         node2 = new NodeIdentifierWithPredicates( NODENAME1, KEY1, new byte[]{1,2} );
 261
 262         assertEquals( "hashCode", node1.hashCode(), node2.hashCode() );
 263         assertEquals( "equals", true, node1.equals( node2 ) );
 264
 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} ) ) );
 271     }
 272
 273     @Test
 274     public void testNodeWithValue() {
 275
 276         NodeWithValue<?> node1 = new NodeWithValue<>( NODENAME1, "foo" );
 277         assertEquals( "getNodeType", NODENAME1, node1.getNodeType() );
 278         assertEquals( "getValue", "foo", node1.getValue() );
 279
 280         NodeWithValue<?> node2 = new NodeWithValue<>( NODENAME1, "foo" );
 281
 282         assertEquals( "hashCode", node1.hashCode(), node2.hashCode() );
 283         assertEquals( "equals", true, node1.equals( node2 ) );
 284
 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() ) );
 288
 289         assertNotNull( node1.toString() ); // for code coverage
 290         assertNotNull( node1.toRelativeString(node2) );
 291
 292         NodeWithValue<?> node3 = new NodeWithValue<>( NODENAME1, new byte[]{1,2} );
 293         NodeWithValue<?> node4 = new NodeWithValue<>( NODENAME1, new byte[]{1,2} );
 294
 295         assertEquals( "hashCode", node3.hashCode(), node4.hashCode() );
 296         assertEquals( "equals", true, node3.equals( node4 ) );
 297
 298         assertEquals( "equals", false, node3.equals( new NodeWithValue<>( NODENAME1, new byte[]{1,3} ) ) );
 299         assertEquals( "equals", false, node3.equals( node1 ) );
 300     }
 301
 302     @Test
 303     public void testNodeIdentifier() {
 304
 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 ) );
 309
 310         assertEquals( "hashCode", node1.hashCode(), node2.hashCode() );
 311         assertEquals( "compareTo", 0, node1.compareTo( node2 ) );
 312         assertEquals( "compareTo", true, node1.compareTo( new NodeIdentifier( NODENAME3 ) ) != 0 );
 313
 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() ) );
 320
 321         assertNotNull( node1.toString() ); // for code coverage
 322     }
 323
 324     @Test(expected=UnsupportedOperationException.class)
 325     public void testAugmentationIdentifierNodeType() {
 326         AugmentationIdentifier node1 = new AugmentationIdentifier( Sets.newHashSet( NODENAME1, NODENAME2 ) );
 327         node1.getNodeType();
 328     }
 329
 330     @Test
 331     public void testAugmentationIdentifier() {
 332
 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 );
 339
 340         assertEquals( "hashCode", node1.hashCode(), node2.hashCode() );
 341
 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() ) );
 347
 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 ) );
 353
 354         assertNotNull( node1.toString() ); // for code coverage
 355         assertNotNull( node1.toRelativeString(node5));
 356     }
 357
 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)) {
 361             oos.writeObject(id);
 362         }
 363
 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());
 369             return ret;
 370         }
 371     }
 372
 373     @Test
 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));
 378
 379         final YangInstanceIdentifier stacked = YangInstanceIdentifier.EMPTY.node(new NodeIdentifier(NODENAME1));
 380         assertEquals(stacked, serdes(stacked));
 381
 382         final YangInstanceIdentifier empty = serdes(YangInstanceIdentifier.EMPTY);
 383         assertSame(YangInstanceIdentifier.EMPTY, empty);
 384     }
 385
 386     @Test
 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));
 392
 393         assertSame(fixed, fixed.toOptimized());
 394
 395         final YangInstanceIdentifier opt = stacked.toOptimized();
 396         assertTrue(opt instanceof FixedYangInstanceIdentifier);
 397         assertEquals(fixed, stacked.toOptimized());
 398     }
 399
 400     @Test
 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));
 405
 406         assertNull(YangInstanceIdentifier.EMPTY.getParent());
 407         assertSame(YangInstanceIdentifier.EMPTY, fixed.getParent());
 408         assertSame(YangInstanceIdentifier.EMPTY, stacked.getParent());
 409         assertSame(stacked, twoStacked.getParent());
 410     }
 411
 412     @Test
 413     public void testIsEmpty() {
 414         final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
 415         final YangInstanceIdentifier stacked = YangInstanceIdentifier.EMPTY.node(new NodeIdentifier(NODENAME1));
 416
 417         assertTrue(YangInstanceIdentifier.EMPTY.isEmpty());
 418         assertFalse(fixed.isEmpty());
 419         assertFalse(stacked.isEmpty());
 420     }
 421 }