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