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