yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/TestUtils.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 java.io.File;
  12 import java.io.FileNotFoundException;
  13 import java.io.InputStream;
  14 import java.net.URI;
  15 import java.net.URISyntaxException;
  16 import java.net.URL;
  17 import java.text.DateFormat;
  18 import java.text.ParseException;
  19 import java.text.SimpleDateFormat;
  20 import java.util.ArrayList;
  21 import java.util.Collection;
  22 import java.util.Date;
  23 import java.util.List;
  24 import java.util.Set;
  25 import org.opendaylight.yangtools.yang.common.QName;
  26 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  27 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  28 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  29 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  30 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  31 import org.opendaylight.yangtools.yang.model.api.Module;
  32 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
  33 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  34 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  35 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  36 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  37 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
  38 import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
  39 import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
  40 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
  41 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangStatementSourceImpl;
  42 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YinStatementSourceImpl;
  43 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveSchemaContext;
  44 import org.opendaylight.yangtools.yang.parser.util.NamedFileInputStream;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 public final class TestUtils {
  49     private static final Logger LOG = LoggerFactory.getLogger(TestUtils.class);
  50
  51     private TestUtils() {
  52     }
  53
  54     public static Set<Module> loadModules(final URI resourceDirectory)
  55             throws SourceException, ReactorException {
  56         final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
  57                 .newBuild();
  58         File[] files = new File(resourceDirectory).listFiles();
  59
  60         for (File file : files) {
  61             if (file.getName().endsWith(".yang")) {
  62                 addSources(reactor, new YangStatementSourceImpl(file.getPath(), true));
  63             } else {
  64                 LOG.info("Ignoring non-yang file {}", file);
  65             }
  66         }
  67
  68         EffectiveSchemaContext ctx = reactor.buildEffective();
  69         return ctx.getModules();
  70     }
  71
  72     public static Set<Module> loadYinModules(final URI resourceDirectory) throws ReactorException {
  73         final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
  74
  75         for (File file : new File(resourceDirectory).listFiles()) {
  76             addYinSources(reactor, new YinStatementSourceImpl(file.getPath(), true));
  77         }
  78
  79         EffectiveSchemaContext ctx = reactor.buildEffective();
  80         return ctx.getModules();
  81     }
  82
  83     public static Set<Module> loadModules(final List<InputStream> streams)
  84         throws SourceException, ReactorException {
  85         final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
  86             .newBuild();
  87         for (InputStream inputStream : streams) {
  88             addSources(reactor, new YangStatementSourceImpl(inputStream));
  89         }
  90
  91         EffectiveSchemaContext ctx = reactor.buildEffective();
  92         return ctx.getModules();
  93     }
  94
  95     public static Set<Module> loadYinModules(final List<InputStream> streams) throws SourceException, ReactorException {
  96         final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
  97         for (InputStream inputStream : streams) {
  98             addYinSources(reactor, new YinStatementSourceImpl(inputStream));
  99         }
 100
 101         EffectiveSchemaContext ctx = reactor.buildEffective();
 102         return ctx.getModules();
 103     }
 104
 105     public static Module loadModule(final InputStream stream)
 106         throws SourceException, ReactorException {
 107         final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
 108             .newBuild();
 109         addSources(reactor, new YangStatementSourceImpl(stream));
 110         EffectiveSchemaContext ctx = reactor.buildEffective();
 111         return ctx.getModules().iterator().next();
 112     }
 113
 114     public static Module loadYinModule(final InputStream stream) throws SourceException, ReactorException {
 115         final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
 116         addYinSources(reactor, new YinStatementSourceImpl(stream));
 117         EffectiveSchemaContext ctx = reactor.buildEffective();
 118         return ctx.getModules().iterator().next();
 119     }
 120
 121     public static Module findModule(final Set<Module> modules,
 122         final String moduleName) {
 123         Module result = null;
 124         for (Module module : modules) {
 125             if (module.getName().equals(moduleName)) {
 126                 result = module;
 127                 break;
 128             }
 129         }
 130         return result;
 131     }
 132
 133     public static ModuleImport findImport(final Set<ModuleImport> imports,
 134             final String prefix) {
 135         ModuleImport result = null;
 136         for (ModuleImport moduleImport : imports) {
 137             if (moduleImport.getPrefix().equals(prefix)) {
 138                 result = moduleImport;
 139                 break;
 140             }
 141         }
 142         return result;
 143     }
 144
 145     public static TypeDefinition<?> findTypedef(
 146             final Set<TypeDefinition<?>> typedefs, final String name) {
 147         TypeDefinition<?> result = null;
 148         for (TypeDefinition<?> td : typedefs) {
 149             if (td.getQName().getLocalName().equals(name)) {
 150                 result = td;
 151                 break;
 152             }
 153         }
 154         return result;
 155     }
 156
 157     public static SchemaPath createPath(final boolean absolute,
 158             final URI namespace, final Date revision, final String prefix,
 159             final String... names) {
 160         List<QName> path = new ArrayList<>();
 161         for (String name : names) {
 162             path.add(QName.create(namespace, revision, name));
 163         }
 164         return SchemaPath.create(path, absolute);
 165     }
 166
 167     public static Date createDate(final String date) {
 168         Date result;
 169         final DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
 170         try {
 171             result = simpleDateFormat.parse(date);
 172         } catch (ParseException e) {
 173             result = null;
 174         }
 175         return result;
 176     }
 177
 178     /**
 179      * Test if node has augmenting flag set to expected value. In case this is
 180      * DataNodeContainer/ChoiceNode, check its child nodes/case nodes too.
 181      *
 182      * @param node
 183      *            node to check
 184      * @param expected
 185      *            expected value
 186      */
 187     public static void checkIsAugmenting(final DataSchemaNode node,
 188             final boolean expected) {
 189         assertEquals(expected, node.isAugmenting());
 190         if (node instanceof DataNodeContainer) {
 191             for (DataSchemaNode child : ((DataNodeContainer) node)
 192                     .getChildNodes()) {
 193                 checkIsAugmenting(child, expected);
 194             }
 195         } else if (node instanceof ChoiceSchemaNode) {
 196             for (ChoiceCaseNode caseNode : ((ChoiceSchemaNode) node).getCases()) {
 197                 checkIsAugmenting(caseNode, expected);
 198             }
 199         }
 200     }
 201
 202     /**
 203      * Check if node has addedByUses flag set to expected value. In case this is
 204      * DataNodeContainer/ChoiceNode, check its child nodes/case nodes too.
 205      *
 206      * @param node
 207      *            node to check
 208      * @param expected
 209      *            expected value
 210      */
 211     public static void checkIsAddedByUses(final DataSchemaNode node,
 212             final boolean expected) {
 213         assertEquals(expected, node.isAddedByUses());
 214         if (node instanceof DataNodeContainer) {
 215             for (DataSchemaNode child : ((DataNodeContainer) node)
 216                     .getChildNodes()) {
 217                 checkIsAddedByUses(child, expected);
 218             }
 219         } else if (node instanceof ChoiceSchemaNode) {
 220             for (ChoiceCaseNode caseNode : ((ChoiceSchemaNode) node).getCases()) {
 221                 checkIsAddedByUses(caseNode, expected);
 222             }
 223         }
 224     }
 225
 226     public static void checkIsAddedByUses(final GroupingDefinition node,
 227             final boolean expected) {
 228         assertEquals(expected, node.isAddedByUses());
 229         for (DataSchemaNode child : ((DataNodeContainer) node).getChildNodes()) {
 230             checkIsAddedByUses(child, expected);
 231         }
 232     }
 233
 234     public static List<Module> findModules(final Set<Module> modules,
 235             final String moduleName) {
 236         List<Module> result = new ArrayList<>();
 237         for (Module module : modules) {
 238             if (module.getName().equals(moduleName)) {
 239                 result.add(module);
 240             }
 241         }
 242         return result;
 243     }
 244
 245     private static void addSources(
 246             final CrossSourceStatementReactor.BuildAction reactor,
 247             final YangStatementSourceImpl... sources) {
 248         for (YangStatementSourceImpl source : sources) {
 249             reactor.addSource(source);
 250         }
 251     }
 252
 253     public static SchemaContext parseYangSources(
 254             final StatementStreamSource... sources) throws SourceException,
 255             ReactorException {
 256
 257         CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
 258                 .newBuild();
 259         reactor.addSources(sources);
 260
 261         return reactor.buildEffective();
 262     }
 263
 264     public static SchemaContext parseYangSources(final File... files)
 265             throws SourceException, ReactorException, FileNotFoundException {
 266
 267         StatementStreamSource[] sources = new StatementStreamSource[files.length];
 268
 269         for (int i = 0; i < files.length; i++) {
 270             sources[i] = new YangStatementSourceImpl(new NamedFileInputStream(files[i], files[i].getPath()));
 271         }
 272
 273         return parseYangSources(sources);
 274     }
 275
 276     public static SchemaContext parseYangSources(final Collection<File> files)
 277             throws SourceException, ReactorException, FileNotFoundException {
 278         return parseYangSources(files.toArray(new File[files.size()]));
 279     }
 280
 281     public static SchemaContext parseYangSources(final String yangSourcesDirectoryPath)
 282             throws SourceException, ReactorException, FileNotFoundException,
 283             URISyntaxException {
 284
 285         URL resourceDir = StmtTestUtils.class
 286                 .getResource(yangSourcesDirectoryPath);
 287         File testSourcesDir = new File(resourceDir.toURI());
 288
 289         return parseYangSources(testSourcesDir.listFiles());
 290     }
 291
 292     public static SchemaContext parseYangSource(final String yangSourceFilePath)
 293             throws SourceException, ReactorException, FileNotFoundException,
 294             URISyntaxException {
 295
 296         URL resourceFile = StmtTestUtils.class
 297                 .getResource(yangSourceFilePath);
 298         File testSourcesFile = new File(resourceFile.toURI());
 299
 300         return parseYangSources(testSourcesFile);
 301     }
 302
 303     private static void addYinSources(final CrossSourceStatementReactor.BuildAction reactor,
 304                                       final YinStatementSourceImpl... sources) {
 305         for (YinStatementSourceImpl source : sources) {
 306             reactor.addSource(source);
 307         }
 308     }
 309
 310 }