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