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