parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/EffectiveModulesAndSubmodulesTest.java

   1 /*
   2  * Copyright (c) 2016 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.stmt;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
  14
  15 import java.util.Collection;
  16 import java.util.Optional;
  17 import org.junit.Test;
  18 import org.opendaylight.yangtools.yang.common.QName;
  19 import org.opendaylight.yangtools.yang.common.QNameModule;
  20 import org.opendaylight.yangtools.yang.common.XMLNamespace;
  21 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  22 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  23 import org.opendaylight.yangtools.yang.model.api.Module;
  24 import org.opendaylight.yangtools.yang.model.api.ModuleLike;
  25 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  26 import org.opendaylight.yangtools.yang.model.api.Submodule;
  27 import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
  28 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  29 import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 public class EffectiveModulesAndSubmodulesTest {
  34     private static final Logger LOG = LoggerFactory.getLogger(EffectiveModulesAndSubmodulesTest.class);
  35     private static final StatementStreamSource ROOT_MODULE = sourceForResource(
  36             "/stmt-test/submodules/root-module.yang");
  37     private static final StatementStreamSource IMPORTED_MODULE = sourceForResource(
  38             "/stmt-test/submodules/imported-module.yang");
  39     private static final StatementStreamSource SUBMODULE_1 = sourceForResource(
  40             "/stmt-test/submodules/submodule-1.yang");
  41     private static final StatementStreamSource SUBMODULE_2 = sourceForResource(
  42             "/stmt-test/submodules/submodule-2.yang");
  43     private static final StatementStreamSource SUBMODULE_TO_SUBMODULE_1 = sourceForResource(
  44             "/stmt-test/submodules/submodule-to-submodule-1.yang");
  45
  46     private static final QNameModule ROOT = QNameModule.create(XMLNamespace.of("root-module"));
  47
  48     @Test
  49     public void modulesAndSubmodulesSimpleReferencesTest() throws ReactorException {
  50         final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
  51                 .addSources(ROOT_MODULE, IMPORTED_MODULE, SUBMODULE_1, SUBMODULE_2, SUBMODULE_TO_SUBMODULE_1)
  52                 .buildEffective();
  53
  54         assertNotNull(result);
  55
  56         final Collection<? extends Module> modules = result.getModules();
  57         assertNotNull(modules);
  58         assertEquals(2, modules.size());
  59
  60         Module root = null;
  61         Module imported = null;
  62         for (final Module module : modules) {
  63             switch (module.getName()) {
  64                 case "root-module":
  65                     root = module;
  66                     break;
  67                 case "imported-module":
  68                     imported = module;
  69                     break;
  70                 default:
  71             }
  72             printReferences(module, false, "");
  73             printChilds(module.getChildNodes(), "      ");
  74         }
  75
  76         assertNotNull(root);
  77         assertNotNull(imported);
  78
  79         final Collection<? extends DataSchemaNode> rootChildNodes = root.getChildNodes();
  80         final Collection<? extends DataSchemaNode> importedChildNodes = imported.getChildNodes();
  81
  82         assertNotNull(rootChildNodes);
  83         assertNotNull(importedChildNodes);
  84
  85         assertEquals(3, rootChildNodes.size());
  86         assertEquals(1, importedChildNodes.size());
  87
  88         final Collection<? extends Submodule> rootSubmodules = root.getSubmodules();
  89         final Collection<? extends Submodule> importedSubmodules = imported.getSubmodules();
  90
  91         assertNotNull(rootSubmodules);
  92         assertNotNull(importedSubmodules);
  93
  94         assertEquals(2, rootSubmodules.size());
  95         assertEquals(0, importedSubmodules.size());
  96
  97         Submodule sub1 = null;
  98         Submodule sub2 = null;
  99         for (final Submodule rootSubmodule : rootSubmodules) {
 100             switch (rootSubmodule.getName()) {
 101                 case "submodule-1":
 102                     sub1 = rootSubmodule;
 103                     break;
 104                 case "submodule-2":
 105                     sub2 = rootSubmodule;
 106                     break;
 107                 default:
 108             }
 109         }
 110
 111         assertNotNull(sub1);
 112         assertNotNull(sub2);
 113
 114         assertEquals(ROOT, sub1.getQNameModule());
 115         assertEquals(ROOT, sub2.getQNameModule());
 116
 117         final Collection<? extends DataSchemaNode> sub1ChildNodes = sub1.getChildNodes();
 118         final Collection<? extends DataSchemaNode> sub2ChildNodes = sub2.getChildNodes();
 119
 120         assertNotNull(sub1ChildNodes);
 121         assertNotNull(sub2ChildNodes);
 122
 123         assertEquals(1, sub1ChildNodes.size());
 124         assertEquals(1, sub2ChildNodes.size());
 125
 126         final Collection<? extends Submodule> sub1Submodules = sub1.getSubmodules();
 127         final Collection<? extends Submodule> sub2Submodules = sub2.getSubmodules();
 128
 129         assertNotNull(sub1Submodules);
 130         assertNotNull(sub2Submodules);
 131
 132         assertEquals(1, sub1Submodules.size());
 133         assertEquals(0, sub2Submodules.size());
 134
 135         Submodule sub1Submodule = null;
 136         for (final Submodule submodule : sub1Submodules) {
 137             switch (submodule.getName()) {
 138                 case "submodule-to-submodule-1":
 139                     sub1Submodule = submodule;
 140                     break;
 141                 default:
 142             }
 143         }
 144
 145         assertNotNull(sub1Submodule);
 146
 147         assertEquals(ROOT, sub1Submodule.getQNameModule());
 148
 149         final Collection<? extends DataSchemaNode> sub1SubmoduleChildNodes = sub1Submodule.getChildNodes();
 150         assertNotNull(sub1SubmoduleChildNodes);
 151         assertEquals(1, sub1SubmoduleChildNodes.size());
 152
 153         final Collection<? extends Submodule> sub1SubmoduleSubmodules = sub1Submodule.getSubmodules();
 154         assertNotNull(sub1SubmoduleSubmodules);
 155         assertEquals(0, sub1SubmoduleSubmodules.size());
 156
 157         findModulesSubTest(result, root, imported);
 158
 159         getDataChildByNameSubTest(result, root);
 160     }
 161
 162     private static void getDataChildByNameSubTest(final SchemaContext result, final Module root) {
 163         final DataSchemaNode containerInRoot = result.getDataChildByName(QName
 164                 .create(root.getQNameModule(), "container-in-root-module"));
 165         assertNotNull(containerInRoot);
 166         assertEquals(Optional.of("desc"), containerInRoot.getDescription());
 167     }
 168
 169     private static void findModulesSubTest(final SchemaContext result, final Module root, final Module imported) {
 170         final Module foundRoot = result.findModule("root-module").get();
 171         final Collection<? extends Module> foundRoots = result.findModules(XMLNamespace.of("root-module"));
 172         final Module foundRoot3 = result.findModule(XMLNamespace.of("root-module")).get();
 173
 174         assertNotNull(foundRoot);
 175         assertNotNull(foundRoots);
 176         assertEquals(1, foundRoots.size());
 177         final Module foundRoot2 = foundRoots.iterator().next();
 178
 179         assertNotNull(foundRoot2);
 180         assertNotNull(foundRoot3);
 181
 182         assertEquals(root, foundRoot);
 183         assertEquals(root, foundRoot2);
 184         assertEquals(root, foundRoot3);
 185
 186         final Module foundImported = result.findModule("imported-module").get();
 187         final Collection<? extends Module> foundImporteds = result.findModules(XMLNamespace.of("imported-module"));
 188         final Module foundImported3 = result.findModule(XMLNamespace.of("imported-module")).get();
 189
 190         assertNotNull(foundImported);
 191         assertNotNull(foundImporteds);
 192         assertEquals(1, foundImporteds.size());
 193         final Module foundImported2 = foundImporteds.iterator().next();
 194
 195         assertNotNull(foundImported2);
 196         assertNotNull(foundImported3);
 197
 198         assertEquals(imported, foundImported);
 199         assertEquals(imported, foundImported2);
 200         assertEquals(imported, foundImported3);
 201
 202         assertFalse(root.equals(imported));
 203     }
 204
 205     private static void printReferences(final ModuleLike module, final boolean isSubmodule, final String indent) {
 206         LOG.debug("{}{} {}", indent, isSubmodule ? "Submodule" : "Module", module.getName());
 207         for (final Submodule submodule : module.getSubmodules()) {
 208             printReferences(submodule, true, indent + "      ");
 209             printChilds(submodule.getChildNodes(), indent + "            ");
 210         }
 211     }
 212
 213     private static void printChilds(final Collection<? extends DataSchemaNode> childNodes, final String indent) {
 214         for (final DataSchemaNode child : childNodes) {
 215             LOG.debug("{}{} {}", indent, "Child", child.getQName().getLocalName());
 216             if (child instanceof DataNodeContainer) {
 217                 printChilds(((DataNodeContainer) child).getChildNodes(), indent + "      ");
 218             }
 219         }
 220     }
 221 }