data/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.jupiter.api.Assertions.assertEquals;
  11 import static org.junit.jupiter.api.Assertions.assertFalse;
  12 import static org.junit.jupiter.api.Assertions.assertSame;
  13 import static org.junit.jupiter.api.Assertions.assertThrows;
  14 import static org.junit.jupiter.api.Assertions.assertTrue;
  15
  16 import java.util.HashMap;
  17 import java.util.List;
  18 import java.util.Map;
  19 import org.junit.jupiter.api.Test;
  20 import org.opendaylight.yangtools.yang.common.QName;
  21 import org.opendaylight.yangtools.yang.common.QNameModule;
  22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  25
  26 class PathArgumentListTest {
  27     private static final PathArgumentList LIST = new StackedPathArguments(YangInstanceIdentifier.of(),
  28         List.of(new NodeIdentifier(QName.create("foo", "foo"))));
  29
  30     @Test
  31     void testIsEmpty() {
  32         assertFalse(LIST.isEmpty());
  33     }
  34
  35     @Test
  36     void testProtections() {
  37         assertThrows(UnsupportedOperationException.class, () -> LIST.remove(null));
  38         assertThrows(UnsupportedOperationException.class, () -> LIST.addAll(List.of()));
  39         assertThrows(UnsupportedOperationException.class, () -> LIST.removeAll(List.of()));
  40         assertThrows(UnsupportedOperationException.class, () -> LIST.retainAll(List.of()));
  41         assertThrows(UnsupportedOperationException.class, () -> LIST.clear());
  42         assertThrows(UnsupportedOperationException.class, () -> LIST.addAll(0, null));
  43     }
  44
  45     @Test
  46     void testPathArgument() {
  47         final QNameModule qNameModule = QNameModule.of("urn:opendaylight.test2", "2015-08-08");
  48         final QName qNameRoot = QName.create(qNameModule, "root");
  49         final QName qNameList = QName.create(qNameModule, "list");
  50         final QName qNameLeaf = QName.create(qNameModule, "leaf-a");
  51         final Map<QName, Object> entryLeaf = new HashMap<>();
  52         entryLeaf.put(qNameList, "leaf");
  53         final NodeIdentifierWithPredicates nodeIdentifierWithPredicates = NodeIdentifierWithPredicates.of(qNameList,
  54             entryLeaf);
  55         final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.of(qNameRoot, qNameList)
  56                 .node(nodeIdentifierWithPredicates).node(qNameLeaf);
  57         final PathArgument pathArgumentToRoot = yangInstanceIdentifier.getAncestor(1).getPathArguments().iterator()
  58                 .next();
  59         final StackedPathArguments stackedPathArguments = (StackedPathArguments)yangInstanceIdentifier
  60             .getPathArguments();
  61         assertTrue(yangInstanceIdentifier.pathArgumentsEqual(yangInstanceIdentifier));
  62         assertEquals(pathArgumentToRoot, stackedPathArguments.get(0));
  63         assertEquals(4, stackedPathArguments.size());
  64         assertTrue(stackedPathArguments.contains(pathArgumentToRoot));
  65         assertEquals(0, stackedPathArguments.indexOf(pathArgumentToRoot));
  66         assertEquals(0, stackedPathArguments.lastIndexOf(pathArgumentToRoot));
  67
  68         final StackedReversePathArguments stackedReversePathArguments =
  69             (StackedReversePathArguments)yangInstanceIdentifier.getReversePathArguments();
  70         final QName rootQname = pathArgumentToRoot.getNodeType();
  71         final QName leafQname = stackedReversePathArguments.get(0).getNodeType();
  72         assertEquals(qNameRoot, rootQname);
  73         assertEquals(qNameLeaf, leafQname);
  74         assertEquals(4, stackedReversePathArguments.size());
  75         assertTrue(stackedReversePathArguments.contains(pathArgumentToRoot));
  76         assertEquals(3, stackedReversePathArguments.indexOf(pathArgumentToRoot));
  77         assertEquals(3, stackedReversePathArguments.lastIndexOf(pathArgumentToRoot));
  78
  79         final StackedYangInstanceIdentifier stackedYangInstanceIdentifier = (StackedYangInstanceIdentifier)
  80                 yangInstanceIdentifier;
  81         final StackedYangInstanceIdentifier stackedYangInstanceIdentifierClone = stackedYangInstanceIdentifier.clone();
  82         final YangInstanceIdentifier yangInstanceIdentifier1 = stackedYangInstanceIdentifier.getAncestor(4);
  83         assertEquals(stackedYangInstanceIdentifier, stackedYangInstanceIdentifierClone);
  84         assertEquals(stackedReversePathArguments, yangInstanceIdentifier1.getReversePathArguments());
  85         assertSame(stackedYangInstanceIdentifier.getParent(), stackedYangInstanceIdentifier.getAncestor(3));
  86
  87         final IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class,
  88             () -> stackedYangInstanceIdentifier.getAncestor(12));
  89         assertEquals("Depth 12 exceeds maximum depth 4", thrown.getMessage());
  90     }
  91 }