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.net.URISyntaxException;
  18 import java.text.ParseException;
  19 import java.util.HashMap;
  20 import java.util.Map;
  21 import javax.annotation.Nonnull;
  22 import org.junit.Test;
  23 import org.opendaylight.yangtools.yang.common.QName;
  24 import org.opendaylight.yangtools.yang.common.QNameModule;
  25 import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
  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 null;
  33         }
  34
  35         @Override
  36         public PathArgument get(final int index) {
  37             return null;
  38         }
  39
  40         @Override
  41         public int size() {
  42             return 0;
  43         }
  44     }
  45
  46     @Test
  47     public void testIsEmpty() {
  48         assertFalse(new TestClass().isEmpty());
  49     }
  50
  51     @Test
  52     public void testProtections() {
  53         final PathArgumentList l = new TestClass();
  54
  55         try {
  56             l.remove(null);
  57             fail();
  58         } catch (UnsupportedOperationException e) {
  59         }
  60
  61         try {
  62             l.addAll(null);
  63             fail();
  64         } catch (UnsupportedOperationException e) {
  65         }
  66
  67         try {
  68             l.removeAll(null);
  69             fail();
  70         } catch (UnsupportedOperationException e) {
  71         }
  72
  73         try {
  74             l.retainAll(null);
  75             fail();
  76         } catch (UnsupportedOperationException e) {
  77         }
  78
  79         try {
  80             l.clear();
  81             fail();
  82         } catch (UnsupportedOperationException e) {
  83         }
  84
  85         try {
  86             l.addAll(0, null);
  87             fail();
  88         } catch (UnsupportedOperationException e) {
  89         }
  90     }
  91
  92     @Test
  93     public void testPathArgument() throws URISyntaxException, ParseException {
  94         final QNameModule qNameModule = QNameModule.create(new URI("urn:opendaylight.test2"),
  95                 SimpleDateFormatUtil.getRevisionFormat().parse("2015-08-08"));
  96         final QName qNameRoot = QName.create(qNameModule, "root");
  97         final QName qNameList = QName.create(qNameModule, "list");
  98         final QName qNameLeaf = QName.create(qNameModule, "leaf-a");
  99         final Map<QName, Object> entryLeaf = new HashMap<>();
 100         entryLeaf.put(qNameList, "leaf");
 101         final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifierWithPredicates = new YangInstanceIdentifier
 102                 .NodeIdentifierWithPredicates(qNameList , entryLeaf);
 103         final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.of(qNameRoot).node(qNameList)
 104                 .node(nodeIdentifierWithPredicates).node(qNameLeaf);
 105         final PathArgument pathArgumentToRoot = yangInstanceIdentifier.getAncestor(1).getPathArguments().iterator()
 106                 .next();
 107         final StackedPathArguments stackedPathArguments = (StackedPathArguments)yangInstanceIdentifier.getPathArguments();
 108         assertTrue(yangInstanceIdentifier.pathArgumentsEqual(yangInstanceIdentifier));
 109         assertEquals(pathArgumentToRoot, stackedPathArguments.get(0));
 110         assertEquals(4, stackedPathArguments.size());
 111         assertEquals(true, stackedPathArguments.contains(pathArgumentToRoot));
 112         assertEquals(0, stackedPathArguments.indexOf(pathArgumentToRoot));
 113         assertEquals(0, stackedPathArguments.lastIndexOf(pathArgumentToRoot));
 114
 115         final StackedReversePathArguments stackedReversePathArguments = (StackedReversePathArguments)yangInstanceIdentifier
 116                 .getReversePathArguments();
 117         final QName rootQname = pathArgumentToRoot.getNodeType();
 118         final QName leafQname = stackedReversePathArguments.get(0).getNodeType();
 119         assertEquals(qNameRoot, rootQname);
 120         assertEquals(qNameLeaf, leafQname);
 121         assertEquals(4, stackedReversePathArguments.size());
 122         assertEquals(true, stackedReversePathArguments.contains(pathArgumentToRoot));
 123         assertEquals(3, stackedReversePathArguments.indexOf(pathArgumentToRoot));
 124         assertEquals(3, stackedReversePathArguments.lastIndexOf(pathArgumentToRoot));
 125
 126         final StackedYangInstanceIdentifier stackedYangInstanceIdentifier = (StackedYangInstanceIdentifier)
 127                 yangInstanceIdentifier;
 128         final StackedYangInstanceIdentifier stackedYangInstanceIdentifierClone = stackedYangInstanceIdentifier.clone();
 129         final YangInstanceIdentifier yangInstanceIdentifier1 = stackedYangInstanceIdentifier.getAncestor(4);
 130         assertEquals(stackedYangInstanceIdentifier, stackedYangInstanceIdentifierClone);
 131         assertEquals(stackedReversePathArguments, yangInstanceIdentifier1.getReversePathArguments());
 132
 133         try {
 134             stackedYangInstanceIdentifier.getAncestor(12);
 135             fail();
 136         } catch (IllegalArgumentException e) {
 137         }
 138     }
 139 }