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