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