yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/PathArgumentListTest.java

   1 /*
   2  * Copyright (c) 2015 Cisco 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 package org.opendaylight.yangtools.yang.data.api;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.junit.Assert.fail;
  14
  15 import com.google.common.collect.UnmodifiableIterator;
  16 import java.net.URI;
  17 import java.util.Collections;
  18 import java.util.HashMap;
  19 import java.util.Map;
  20 import java.util.NoSuchElementException;
  21 import org.junit.Test;
  22 import org.opendaylight.yangtools.yang.common.QName;
  23 import org.opendaylight.yangtools.yang.common.QNameModule;
  24 import org.opendaylight.yangtools.yang.common.Revision;
  25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  27
  28 public class PathArgumentListTest {
  29     private static final class TestClass extends PathArgumentList {
  30         @Override
  31         public UnmodifiableIterator<PathArgument> iterator() {
  32             return new UnmodifiableIterator<PathArgument>() {
  33                 @Override
  34                 public boolean hasNext() {
  35                     return false;
  36                 }
  37
  38                 @Override
  39                 public PathArgument next() {
  40                     throw new NoSuchElementException();
  41                 }
  42             };
  43         }
  44
  45         @Override
  46         public PathArgument get(final int index) {
  47             return null;
  48         }
  49
  50         @Override
  51         public int size() {
  52             return 0;
  53         }
  54     }
  55
  56     @Test
  57     public void testIsEmpty() {
  58         assertFalse(new TestClass().isEmpty());
  59     }
  60
  61     @Test
  62     public void testProtections() {
  63         final PathArgumentList l = new TestClass();
  64
  65         try {
  66             l.remove(null);
  67             fail();
  68         } catch (UnsupportedOperationException e) {
  69             // Expected
  70         }
  71
  72         try {
  73             l.addAll(Collections.emptyList());
  74             fail();
  75         } catch (UnsupportedOperationException e) {
  76             // Expected
  77         }
  78
  79         try {
  80             l.removeAll(Collections.emptyList());
  81             fail();
  82         } catch (UnsupportedOperationException e) {
  83             // Expected
  84         }
  85
  86         try {
  87             l.retainAll(Collections.emptyList());
  88             fail();
  89         } catch (UnsupportedOperationException e) {
  90             // Expected
  91         }
  92
  93         try {
  94             l.clear();
  95             fail();
  96         } catch (UnsupportedOperationException e) {
  97             // Expected
  98         }
  99
 100         try {
 101             l.addAll(0, null);
 102             fail();
 103         } catch (UnsupportedOperationException e) {
 104             // Expected
 105         }
 106     }
 107
 108     @Test
 109     public void testPathArgument() {
 110         final QNameModule qNameModule = QNameModule.create(URI.create("urn:opendaylight.test2"),
 111             Revision.of("2015-08-08"));
 112         final QName qNameRoot = QName.create(qNameModule, "root");
 113         final QName qNameList = QName.create(qNameModule, "list");
 114         final QName qNameLeaf = QName.create(qNameModule, "leaf-a");
 115         final Map<QName, Object> entryLeaf = new HashMap<>();
 116         entryLeaf.put(qNameList, "leaf");
 117         final NodeIdentifierWithPredicates nodeIdentifierWithPredicates = NodeIdentifierWithPredicates.of(qNameList,
 118             entryLeaf);
 119         final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.of(qNameRoot).node(qNameList)
 120                 .node(nodeIdentifierWithPredicates).node(qNameLeaf);
 121         final PathArgument pathArgumentToRoot = yangInstanceIdentifier.getAncestor(1).getPathArguments().iterator()
 122                 .next();
 123         final StackedPathArguments stackedPathArguments = (StackedPathArguments)yangInstanceIdentifier
 124             .getPathArguments();
 125         assertTrue(yangInstanceIdentifier.pathArgumentsEqual(yangInstanceIdentifier));
 126         assertEquals(pathArgumentToRoot, stackedPathArguments.get(0));
 127         assertEquals(4, stackedPathArguments.size());
 128         assertTrue(stackedPathArguments.contains(pathArgumentToRoot));
 129         assertEquals(0, stackedPathArguments.indexOf(pathArgumentToRoot));
 130         assertEquals(0, stackedPathArguments.lastIndexOf(pathArgumentToRoot));
 131
 132         final StackedReversePathArguments stackedReversePathArguments =
 133             (StackedReversePathArguments)yangInstanceIdentifier.getReversePathArguments();
 134         final QName rootQname = pathArgumentToRoot.getNodeType();
 135         final QName leafQname = stackedReversePathArguments.get(0).getNodeType();
 136         assertEquals(qNameRoot, rootQname);
 137         assertEquals(qNameLeaf, leafQname);
 138         assertEquals(4, stackedReversePathArguments.size());
 139         assertTrue(stackedReversePathArguments.contains(pathArgumentToRoot));
 140         assertEquals(3, stackedReversePathArguments.indexOf(pathArgumentToRoot));
 141         assertEquals(3, stackedReversePathArguments.lastIndexOf(pathArgumentToRoot));
 142
 143         final StackedYangInstanceIdentifier stackedYangInstanceIdentifier = (StackedYangInstanceIdentifier)
 144                 yangInstanceIdentifier;
 145         final StackedYangInstanceIdentifier stackedYangInstanceIdentifierClone = stackedYangInstanceIdentifier.clone();
 146         final YangInstanceIdentifier yangInstanceIdentifier1 = stackedYangInstanceIdentifier.getAncestor(4);
 147         assertEquals(stackedYangInstanceIdentifier, stackedYangInstanceIdentifierClone);
 148         assertEquals(stackedReversePathArguments, yangInstanceIdentifier1.getReversePathArguments());
 149
 150         try {
 151             stackedYangInstanceIdentifier.getAncestor(12);
 152             fail();
 153         } catch (IllegalArgumentException e) {
 154             // Expected
 155         }
 156     }
 157 }