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