import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
final class SystemTestUtils {
final List<StatementStreamSource> libSources, final Set<QName> supportedFeatures) throws ReactorException {
Preconditions.checkArgument(testSources != null && !testSources.isEmpty(), "No yang sources");
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addLibSources(libSources);
- reactor.addSources(testSources);
+ final BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ .addLibSources(libSources).addSources(testSources);
if (supportedFeatures != null) {
reactor.setSupportedFeatures(supportedFeatures);
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.impl;
+
+import com.google.common.annotations.Beta;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.Builder;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+
+/**
+ * Utility class for instantiating default-configured {@link CrossSourceStatementReactor}s.
+ *
+ * @author Robert Varga
+ */
+@Beta
+public final class DefaultReactors {
+ private static final CrossSourceStatementReactor DEFAULT_REACTOR = createDefaultReactorBuilder().build();
+
+ private DefaultReactors() {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Get a shared default-configured reactor instance. This instance is configured to handle both RFC6020 and RFC7950,
+ * as well as RFC8040's yang-data extension.
+ *
+ * @return a shared default-configured reactor instance.
+ */
+ public static CrossSourceStatementReactor defaultReactor() {
+ return DEFAULT_REACTOR;
+ }
+
+ /**
+ * Return a baseline CrossSourceStatementReactor {@link Builder}. The builder is initialized to the equivalent
+ * of the reactor returned via {@link #defaultReactor()}, but can be further customized before use.
+ *
+ * @return A populated CrossSourceStatementReactor builder.
+ */
+ public static Builder createDefaultReactorBuilder() {
+ // FIXME: customize with extensions
+ return YangInferencePipeline.newReactorBuilder();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+/**
+ * This package holds the 'parser implementation', which really is just glue code holding together the statement
+ * reactor, base RFC6020/RFC7950 support bundles and supported semantic extensions.
+ */
+package org.opendaylight.yangtools.yang.parser.impl;
\ No newline at end of file
import javax.annotation.Nonnull;
import org.antlr.v4.runtime.ParserRuleContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangStatementParser.StatementContext;
-import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
-import org.opendaylight.yangtools.util.concurrent.ReflectiveExceptionMapper;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.impl.util.YangModelDependencyInfo;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
import org.opendaylight.yangtools.yang.parser.util.ASTSchemaSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final class SharedSchemaContextFactory implements SchemaContextFactory {
- private static final ExceptionMapper<SchemaResolutionException> MAPPER = ReflectiveExceptionMapper
- .create("resolve sources", SchemaResolutionException.class);
private static final Logger LOG = LoggerFactory.getLogger(SharedSchemaContextFactory.class);
private final Cache<Collection<SourceIdentifier>, SchemaContext> cache = CacheBuilder.newBuilder().weakValues()
res.getResolvedSources(), res.getUnsatisfiedImports());
}
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild(
- statementParserMode);
+ final BuildAction reactor = DefaultReactors.defaultReactor().newBuild(statementParserMode);
if (supportedFeatures.isPresent()) {
reactor.setSupportedFeatures(supportedFeatures.get());
}
import org.opendaylight.yangtools.yang.parser.stmt.anyxmlschema.AnyxmlSchemaLocationSupport;
import org.opendaylight.yangtools.yang.parser.stmt.openconfig.OpenconfigVersionSupport;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.Builder;
import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.ActionStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.AnydataStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.AugmentStatementRfc7950Support;
.put(ValidationBundleType.SUPPORTED_DATA_NODES, YangValidationBundles.SUPPORTED_DATA_NODES)
.build();
- public static final CrossSourceStatementReactor RFC6020_REACTOR = CrossSourceStatementReactor.builder()
- .setBundle(ModelProcessingPhase.INIT, INIT_BUNDLE)
- .setBundle(ModelProcessingPhase.SOURCE_PRE_LINKAGE, PRE_LINKAGE_BUNDLE)
- .setBundle(ModelProcessingPhase.SOURCE_LINKAGE, LINKAGE_BUNDLE)
- .setBundle(ModelProcessingPhase.STATEMENT_DEFINITION, STMT_DEF_BUNDLE)
- .setBundle(ModelProcessingPhase.FULL_DECLARATION, FULL_DECL_BUNDLE)
- .setBundle(ModelProcessingPhase.EFFECTIVE_MODEL, FULL_DECL_BUNDLE)
- .setValidationBundle(ValidationBundleType.SUPPORTED_REFINE_SUBSTATEMENTS,
+ public static Builder newReactorBuilder() {
+ return CrossSourceStatementReactor.builder()
+ .setBundle(ModelProcessingPhase.INIT, INIT_BUNDLE)
+ .setBundle(ModelProcessingPhase.SOURCE_PRE_LINKAGE, PRE_LINKAGE_BUNDLE)
+ .setBundle(ModelProcessingPhase.SOURCE_LINKAGE, LINKAGE_BUNDLE)
+ .setBundle(ModelProcessingPhase.STATEMENT_DEFINITION, STMT_DEF_BUNDLE)
+ .setBundle(ModelProcessingPhase.FULL_DECLARATION, FULL_DECL_BUNDLE)
+ .setBundle(ModelProcessingPhase.EFFECTIVE_MODEL, FULL_DECL_BUNDLE)
+ .setValidationBundle(ValidationBundleType.SUPPORTED_REFINE_SUBSTATEMENTS,
YangValidationBundles.SUPPORTED_REFINE_SUBSTATEMENTS)
- .setValidationBundle(ValidationBundleType.SUPPORTED_AUGMENT_TARGETS,
+ .setValidationBundle(ValidationBundleType.SUPPORTED_AUGMENT_TARGETS,
YangValidationBundles.SUPPORTED_AUGMENT_TARGETS)
- .setValidationBundle(ValidationBundleType.SUPPORTED_CASE_SHORTHANDS,
+ .setValidationBundle(ValidationBundleType.SUPPORTED_CASE_SHORTHANDS,
YangValidationBundles.SUPPORTED_CASE_SHORTHANDS)
- .setValidationBundle(ValidationBundleType.SUPPORTED_DATA_NODES,
- YangValidationBundles.SUPPORTED_DATA_NODES)
- .build();
+ .setValidationBundle(ValidationBundleType.SUPPORTED_DATA_NODES,
+ YangValidationBundles.SUPPORTED_DATA_NODES);
+ }
private YangInferencePipeline() {
throw new UnsupportedOperationException("Utility class");
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
import static org.junit.Assert.assertEquals;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class ConstraintDefinitionsTest {
@Test
public void testConstraintDefinitions() throws ParseException, ReactorException, URISyntaxException, IOException,
YangSyntaxErrorException {
- final SchemaContext schemaContext = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
.addSource(YangStatementStreamSource.create(
YangTextSchemaSource.forResource("/constraint-definitions-test/foo.yang")))
.buildEffective();
import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
import org.opendaylight.yangtools.yang.stmt.StmtTestUtils;
public class Bug6874Test {
@Test
public void descriptionAndReferenceTest11() throws ReactorException {
- YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ DefaultReactors.defaultReactor().newBuild()
.addSources(ROOT_MODULE, CHILD_MODULE, CHILD_MODULE_1, IMPORTED_MODULE)
.build().getRootStatements().forEach(declaredStmt -> {
if (declaredStmt instanceof ModuleStatement) {
import org.junit.Ignore;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class AugmentArgumentParsingTest {
@Test
public void validAugAbsTest() throws ReactorException {
-
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(IMPORTED, VALID_ARGS);
-
- final EffectiveModelContext result = reactor.build();
+ final EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(IMPORTED, VALID_ARGS)
+ .build();
assertNotNull(result);
}
@Test
public void invalidAugRel1Test() {
-
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(INVALID_REL1);
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(INVALID_REL1);
try {
reactor.build();
@Test
public void invalidAugRel2Test() {
-
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(INVALID_REL2);
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(INVALID_REL2);
try {
reactor.build();
@Test
public void invalidAugAbs() {
-
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(INVALID_ABS);
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(INVALID_ABS);
try {
reactor.build();
@Test
public void invalidAugAbsPrefixedNoImp() {
-
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(INVALID_ABS_PREFIXED_NO_IMP);
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(INVALID_ABS_PREFIXED_NO_IMP);
try {
reactor.build();
@Test(expected = IllegalArgumentException.class)
@Ignore
public void invalidAugEmptyTest() throws ReactorException {
-
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(INVALID_EMPTY);
-
- reactor.build();
+ DefaultReactors.defaultReactor().newBuild().addSources(INVALID_EMPTY).build();
fail("reactor.process should fail due to empty path");
}
@Test(expected = IllegalArgumentException.class)
@Ignore
public void invalidAugXPathTest() throws ReactorException {
-
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(INVALID_XPATH);
- reactor.build();
+ DefaultReactors.defaultReactor().newBuild().addSources(INVALID_XPATH).build();
fail("reactor.process should fail due to invalid XPath");
}
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class AugmentProcessTest {
@Test
public void multipleAugmentsAndMultipleModulesTest() throws ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
.addSources(MULTIPLE_AUGMENT_ROOT, MULTIPLE_AUGMENT_IMPORTED, MULTIPLE_AUGMENT_SUBMODULE)
.buildEffective();
assertNotNull(result);
@Test
public void multipleAugmentTest() throws ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
.addSource(MULTIPLE_AUGMENT)
.buildEffective();
assertNotNull(result);
@Test(expected = SomeModifiersUnresolvedException.class)
public void multipleAugmentIncorrectPathTest() throws ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
.addSource(MULTIPLE_AUGMENT_INCORRECT)
.buildEffective();
assertNull(result);
@Test(expected = SomeModifiersUnresolvedException.class)
public void multipleAugmentIncorrectPathAndGrpTest() throws ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
.addSource(MULTIPLE_AUGMENT_INCORRECT2)
.buildEffective();
assertNull(result);
@Test
public void readAndParseYangFileTest() throws ReactorException {
- final SchemaContext root = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ final SchemaContext root = DefaultReactors.defaultReactor().newBuild()
.addSources(AUGMENTED, ROOT)
.buildEffective();
assertNotNull(root);
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class AugmentSimplestTest {
@Test
public void readAndParseYangFileTest() throws SourceException, ReactorException {
- EffectiveModelContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
.addSources(AUGMENTED, ROOT)
.build();
assertNotNull(result);
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class Bug6150Test {
@Test
public void effectiveAugmentFirstTest() throws ReactorException {
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(TARGET, AUGMENT_FIRST);
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(TARGET, AUGMENT_FIRST)
+ .buildEffective();
assertNotNull(result);
}
@Test
public void effectiveAugmentSecondTest() throws ReactorException {
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(TARGET, AUGMENT_SECOND);
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(TARGET, AUGMENT_SECOND)
+ .buildEffective();
assertNotNull(result);
}
@Test
public void effectiveAugmentBothTest() throws ReactorException {
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(TARGET, AUGMENT_FIRST, AUGMENT_SECOND);
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(TARGET, AUGMENT_FIRST, AUGMENT_SECOND)
+ .buildEffective();
assertNotNull(result);
}
}
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class Bug7480Test {
@Test
public void testHandlingOfMainSourceConflictingWithLibSource() throws Exception {
// parent module as main source and as lib source at the same time
// parser should remove it from the required lib sources and thus avoid module namespace collision
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSource(StmtTestUtils.sourceForResource(
- "/bugs/bug7480/main-source-lib-source-conflict-test/parent-module.yang"));
- reactor.addLibSources(StmtTestUtils.sourceForResource(
- "/bugs/bug7480/main-source-lib-source-conflict-test/child-module.yang"),
- StmtTestUtils.sourceForResource(
- "/bugs/bug7480/main-source-lib-source-conflict-test/parent-module.yang"));
- final SchemaContext schemaContext = reactor.buildEffective();
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSource(StmtTestUtils.sourceForResource(
+ "/bugs/bug7480/main-source-lib-source-conflict-test/parent-module.yang"))
+ .addLibSources(
+ StmtTestUtils.sourceForResource(
+ "/bugs/bug7480/main-source-lib-source-conflict-test/child-module.yang"),
+ StmtTestUtils.sourceForResource(
+ "/bugs/bug7480/main-source-lib-source-conflict-test/parent-module.yang"))
+ .buildEffective();
assertNotNull(schemaContext);
}
public void testHandlingOfMainSourceConflictingWithLibSource2() throws Exception {
// submodule as main source and as lib source at the same time
// parser should remove it from the required lib sources and thus avoid submodule name collision
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSource(StmtTestUtils.sourceForResource(
- "/bugs/bug7480/main-source-lib-source-conflict-test/child-module.yang"));
- reactor.addLibSources(StmtTestUtils.sourceForResource(
- "/bugs/bug7480/main-source-lib-source-conflict-test/parent-module.yang"),
- StmtTestUtils.sourceForResource(
- "/bugs/bug7480/main-source-lib-source-conflict-test/child-module.yang"));
- final SchemaContext schemaContext = reactor.buildEffective();
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSource(StmtTestUtils.sourceForResource(
+ "/bugs/bug7480/main-source-lib-source-conflict-test/child-module.yang"))
+ .addLibSources(
+ StmtTestUtils.sourceForResource(
+ "/bugs/bug7480/main-source-lib-source-conflict-test/parent-module.yang"),
+ StmtTestUtils.sourceForResource(
+ "/bugs/bug7480/main-source-lib-source-conflict-test/child-module.yang"))
+ .buildEffective();
assertNotNull(schemaContext);
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertNotNull;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
public class Bug8307Test {
final Map<QNameModule, Set<QNameModule>> modulesWithSupportedDeviations = ImmutableMap.of(
foo, ImmutableSet.of(bar, baz), bar, ImmutableSet.of(baz));
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE);
- reactor.setModulesWithSupportedDeviations(modulesWithSupportedDeviations);
-
- final SchemaContext schemaContext = reactor.buildEffective();
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE)
+ .setModulesWithSupportedDeviations(modulesWithSupportedDeviations)
+ .buildEffective();
assertNotNull(schemaContext);
assertNull(SchemaContextUtil.findDataSchemaNode(schemaContext, SchemaPath.create(true, myFooContA)));
@Test
public void testDeviationsSupportedInAllModules() throws Exception {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE);
-
- final SchemaContext schemaContext = reactor.buildEffective();
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE)
+ .buildEffective();
assertNotNull(schemaContext);
assertNull(SchemaContextUtil.findDataSchemaNode(schemaContext, SchemaPath.create(true, myFooContA)));
@Test
public void testDeviationsSupportedInNoModule() throws Exception {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE);
- reactor.setModulesWithSupportedDeviations(ImmutableMap.of());
-
- final SchemaContext schemaContext = reactor.buildEffective();
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE)
+ .setModulesWithSupportedDeviations(ImmutableMap.of())
+ .buildEffective();
assertNotNull(schemaContext);
assertNotNull(SchemaContextUtil.findDataSchemaNode(schemaContext, SchemaPath.create(true, myFooContA)));
@Test
public void shouldFailOnAttemptToDeviateTheSameModule() {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(FOO_INVALID_MODULE);
+ final BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(FOO_INVALID_MODULE);
try {
reactor.buildEffective();
@Test
public void shouldFailOnAttemptToDeviateTheSameModule2() {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(BAR_INVALID_MODULE, BAZ_INVALID_MODULE);
+ final BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ .addSources(BAR_INVALID_MODULE, BAZ_INVALID_MODULE);
try {
reactor.buildEffective();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class ChoiceStmtTest {
@Test
public void choiceAndCaseTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(CHOICE_MODULE, IMPORTED_MODULE1, IMPORTED_MODULE2, INCLUDED_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(CHOICE_MODULE, IMPORTED_MODULE1, IMPORTED_MODULE2, INCLUDED_MODULE)
+ .buildEffective();
assertNotNull(result);
final Module testModule = result.findModules("foo").iterator().next();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class DeviationStmtTest {
@Test
public void testDeviationAndDeviate() throws ReactorException, ParseException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(FOO_MODULE, FOO_IMP_MODULE, BAR_MODULE, BAR_IMP_MODULE);
-
- final SchemaContext schemaContext = reactor.buildEffective();
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSources(FOO_MODULE, FOO_IMP_MODULE, BAR_MODULE, BAR_IMP_MODULE)
+ .buildEffective();
assertNotNull(schemaContext);
Module testModule = schemaContext.findModule("foo", Revision.of("2016-06-23")).get();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.Assert.assertEquals;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class EffectiveBuildTest {
@Test
public void effectiveBuildTest() throws ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild().addSources(SIMPLE_MODULE)
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild().addSources(SIMPLE_MODULE)
.buildEffective();
assertNotNull(result);
assertEquals(SchemaPath.create(true, q1, q2, q3), subSubCon.getPath());
assertEquals(SchemaPath.create(true, q4, q5, q6), subSubCon2.getPath());
assertEquals(SchemaPath.create(true, q7, q5, q6), grpSubSubCon2.getPath());
-
}
@Test
public void extensionsTest() throws ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild().addSource(YANG_EXT).buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild().addSource(YANG_EXT).buildEffective();
assertNotNull(result);
Set<GroupingDefinition> groupings = result.getGroupings();
@Test
public void mockTest() throws ReactorException, FileNotFoundException, URISyntaxException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild().addSource(YANG_EXT).buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild().addSource(YANG_EXT).buildEffective();
assertNotNull(result);
}
}
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class EffectiveIdentityTest {
"/stmt-test/identity/cyclic-identity-test.yang");
@Test(expected = SomeModifiersUnresolvedException.class)
- public void cyclicefineTest() throws SourceException, ReactorException,
- URISyntaxException {
+ public void cyclicefineTest() throws SourceException, ReactorException, URISyntaxException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
- .newBuild();
- reactor.addSources(CYCLIC_IDENTITY_TEST);
+ CrossSourceStatementReactor.BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ .addSources(CYCLIC_IDENTITY_TEST);
try {
reactor.buildEffective();
} catch (SomeModifiersUnresolvedException e) {
@Test
public void identityTest() throws SourceException, ReactorException,
URISyntaxException {
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(IDENTITY_TEST);
- SchemaContext result = reactor.buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(IDENTITY_TEST)
+ .buildEffective();
assertNotNull(result);
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class EffectiveModuleTest {
@Test
public void effectiveBuildTest() throws SourceException, ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ROOT_MODULE, IMPORTED_MODULE, SUBMODULE);
- SchemaContext result = reactor.buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(ROOT_MODULE, IMPORTED_MODULE, SUBMODULE)
+ .buildEffective();
assertNotNull(result);
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class EffectiveModulesAndSubmodulesTest {
@Test
public void modulesAndSubmodulesSimpleReferencesTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
- .newBuild();
- reactor.addSources(ROOT_MODULE, IMPORTED_MODULE,
- SUBMODULE_1, SUBMODULE_2, SUBMODULE_TO_SUBMODULE_1);
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(ROOT_MODULE, IMPORTED_MODULE, SUBMODULE_1, SUBMODULE_2, SUBMODULE_TO_SUBMODULE_1)
+ .buildEffective();
assertNotNull(result);
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.util.SimpleSchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveSchemaContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class EffectiveSchemaContextTest {
@Test
public void testEffectiveSchemaContext() throws ReactorException, ParseException, URISyntaxException, IOException,
YangSyntaxErrorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
-
- final YangStatementStreamSource source1 = YangStatementStreamSource.create(YangTextSchemaSource.forResource(
- "/effective-schema-context-test/foo.yang"));
- final YangStatementStreamSource source2 = YangStatementStreamSource.create(YangTextSchemaSource.forResource(
- "/effective-schema-context-test/bar.yang"));
- final YangStatementStreamSource source3 = YangStatementStreamSource.create(YangTextSchemaSource.forResource(
- "/effective-schema-context-test/baz.yang"));
-
- reactor.addSources(source1, source2, source3);
- final SchemaContext schemaContext = reactor.buildEffective();
+ final EffectiveSchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource(
+ "/effective-schema-context-test/foo.yang")))
+ .addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource(
+ "/effective-schema-context-test/bar.yang")))
+ .addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource(
+ "/effective-schema-context-test/baz.yang")))
+ .buildEffective();
assertNotNull(schemaContext);
final Set<DataSchemaNode> dataDefinitions = schemaContext.getDataDefinitions();
Module fooModule = schemaContext.findModule("foo", Revision.of("2016-09-21")).get();
assertEquals(3, schemaContext.getModules().size());
- assertEquals(3, ((EffectiveSchemaContext) schemaContext).getRootDeclaredStatements().size());
- assertEquals(3,((EffectiveSchemaContext) schemaContext).getRootEffectiveStatements().size());
+ assertEquals(3, schemaContext.getRootDeclaredStatements().size());
+ assertEquals(3, schemaContext.getRootEffectiveStatements().size());
final Set<Module> modules = schemaContext.getModules();
final SchemaContext copiedSchemaContext = SimpleSchemaContext.forModules(modules);
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BitsSpecificationEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.Decimal64SpecificationEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.UnionSpecificationEffectiveStatementImpl;
public class EffectiveStatementTypeTest {
-
- private static final StatementStreamSource IMPORTED_MODULE = sourceForResource("/type-tests/types.yang");
private static SchemaContext effectiveSchemaContext;
private static Module types;
@BeforeClass
public static void setup() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSource(IMPORTED_MODULE);
- effectiveSchemaContext = reactor.buildEffective();
+ effectiveSchemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/type-tests/types.yang"))
+ .buildEffective();
types = effectiveSchemaContext.findModules("types").iterator().next();
assertNotNull(types);
}
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class EffectiveUsesRefineAndConstraintsTest {
- private static final StatementStreamSource REFINE_TEST = sourceForResource("/stmt-test/uses/refine-test.yang");
-
@Test
public void refineTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
-
- reactor.addSources(REFINE_TEST);
-
- SchemaContext result = reactor.buildEffective();
-
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/stmt-test/uses/refine-test.yang"))
+ .buildEffective();
assertNotNull(result);
Set<Module> modules = result.getModules();
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class ExtensionStmtTest {
-
- private static final StatementStreamSource EXT_DEF_MODULE = sourceForResource("/model/bar.yang");
- private static final StatementStreamSource EXT_DEF_MODULE2 = sourceForResource(
- "/semantic-statement-parser/ext-typedef.yang");
- private static final StatementStreamSource EXT_USE_MODULE = sourceForResource(
- "/semantic-statement-parser/ext-use.yang");
-
@Test
public void testExtensionDefinition() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(EXT_DEF_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/model/bar.yang"))
+ .buildEffective();
assertNotNull(result);
final Module testModule = result.findModules("bar").iterator().next();
@Test
public void testExtensionUsage() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(EXT_DEF_MODULE2, EXT_USE_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/semantic-statement-parser/ext-typedef.yang"))
+ .addSource(sourceForResource("/semantic-statement-parser/ext-use.yang"))
+ .buildEffective();
assertNotNull(result);
final Module testModule1 = result.findModules("ext-typedef").iterator().next();
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class GroupingAndUsesStmtTest {
@Test
public void groupingTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(MODULE, GROUPING_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(MODULE, GROUPING_MODULE)
+ .buildEffective();
assertNotNull(result);
final Module testModule = result.findModules("baz").iterator().next();
@Test
public void usesAndRefinesTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(MODULE, SUBMODULE, GROUPING_MODULE, USES_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(MODULE, SUBMODULE, GROUPING_MODULE, USES_MODULE)
+ .buildEffective();
assertNotNull(result);
final Module testModule = result.findModules("foo").iterator().next();
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class IdentityStmtTest {
- private static final StatementStreamSource ILLEGAL_IDENTITY_MODULE =
- sourceForResource("/identity/identitytest.yang");
-
+ private static final StatementStreamSource ILLEGAL_IDENTITY_MODULE = sourceForResource(
+ "/identity/identitytest.yang");
private static final StatementStreamSource ILLEGAL_IDENTITY_MODULE2 = sourceForResource(
"/identity/prefixidentitytest.yang");
private static final StatementStreamSource LEGAL_IDENTITY_MODULE = sourceForResource(
@Test(expected = SomeModifiersUnresolvedException.class)
public void selfReferencingIdentityTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ILLEGAL_IDENTITY_MODULE);
-
- SchemaContext result = reactor.buildEffective();
- assertNotNull(result);
+ DefaultReactors.defaultReactor().newBuild().addSource(ILLEGAL_IDENTITY_MODULE).buildEffective();
}
@Test(expected = SomeModifiersUnresolvedException.class)
public void selfReferencingIdentityWithPrefixTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ILLEGAL_IDENTITY_MODULE2);
-
- SchemaContext result = reactor.buildEffective();
- assertNotNull(result);
+ DefaultReactors.defaultReactor().newBuild().addSource(ILLEGAL_IDENTITY_MODULE2).buildEffective();
}
@Test
public void importedIdentityTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(LEGAL_IDENTITY_MODULE, LEGAL_IDENTITY_MODULE2);
-
- SchemaContext result = reactor.buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(LEGAL_IDENTITY_MODULE, LEGAL_IDENTITY_MODULE2)
+ .buildEffective();
assertNotNull(result);
}
@Test(expected = SomeModifiersUnresolvedException.class)
public void selfReferencingIdentityThroughChaining() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ILLEGAL_IDENTITY_MODULE3);
-
- SchemaContext result = reactor.buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(ILLEGAL_IDENTITY_MODULE3)
+ .buildEffective();
assertNotNull(result);
}
@Test
public void chainedIdentityTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(LEGAL_IDENTITY_MODULE3);
-
- SchemaContext result = reactor.buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(LEGAL_IDENTITY_MODULE3)
+ .buildEffective();
assertNotNull(result);
Module testModule = result.findModules("legal-chained-identity-test").iterator().next();
@Test
public void duplicateIdentityTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(DUPLICATE_IDENTITY_MODULE);
-
- SchemaContext result = reactor.buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(DUPLICATE_IDENTITY_MODULE)
+ .buildEffective();
assertNotNull(result);
Module testModule = result.findModules("duplicate-identity-test").iterator().next();
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class IfFeatureResolutionTest {
QName.create("foo-namespace", "test-feature-3"),
QName.create("bar-namespace", "imp-feature"));
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(FOO_MODULE, BAR_MODULE);
- reactor.setSupportedFeatures(supportedFeatures);
-
- final SchemaContext schemaContext = reactor.buildEffective();
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSources(FOO_MODULE, BAR_MODULE)
+ .setSupportedFeatures(supportedFeatures)
+ .buildEffective();
assertNotNull(schemaContext);
final Module testModule = schemaContext.findModule("foo").get();
@Test
public void testAllFeaturesSupported() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(FOO_MODULE, BAR_MODULE);
-
- final SchemaContext schemaContext = reactor.buildEffective();
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSources(FOO_MODULE, BAR_MODULE)
+ .buildEffective();
assertNotNull(schemaContext);
final Module testModule = schemaContext.findModules("foo").iterator().next();
@Test
public void testNoFeaturesSupported() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(FOO_MODULE, BAR_MODULE);
- reactor.setSupportedFeatures(ImmutableSet.of());
-
- final SchemaContext schemaContext = reactor.buildEffective();
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSources(FOO_MODULE, BAR_MODULE)
+ .setSupportedFeatures(ImmutableSet.of())
+ .buildEffective();
assertNotNull(schemaContext);
final Module testModule = schemaContext.findModules("foo").iterator().next();
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class ImportResolutionBasicTest {
@Test
public void inImportOrderTest() throws ReactorException {
- EffectiveModelContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
.addSources(ROOT_WITHOUT_IMPORT, IMPORT_ROOT, IMPORT_DERIVED)
.build();
assertNotNull(result);
@Test
public void inInverseOfImportOrderTest() throws ReactorException {
- EffectiveModelContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
.addSources(IMPORT_DERIVED, IMPORT_ROOT, ROOT_WITHOUT_IMPORT)
.build();
assertNotNull(result);
@Test
public void missingImportedSourceTest() {
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
.addSources(IMPORT_DERIVED, ROOT_WITHOUT_IMPORT);
try {
reactor.build();
@Test
public void circularImportsTest() {
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
.addSources(CYCLE_YIN, CYCLE_YANG);
try {
reactor.build();
@Test
public void selfImportTest() {
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
.addSources(IMPORT_SELF, IMPORT_ROOT, ROOT_WITHOUT_IMPORT);
try {
reactor.build();
@Test
public void bug2649Test() throws ReactorException {
- SchemaContext buildEffective = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ SchemaContext buildEffective = DefaultReactors.defaultReactor().newBuild()
.addSources(FOO, IMPORT)
.buildEffective();
assertNotNull(buildEffective);
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class ImportRevisionsTest {
@Test
public void equalRevisionDatesTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ROOT_WITH_EQUAL_DATE, IMPORTED_WITH_EQUAL_DATE);
-
- EffectiveModelContext result = reactor.build();
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(ROOT_WITH_EQUAL_DATE, IMPORTED_WITH_EQUAL_DATE)
+ .build();
assertNotNull(result);
}
@Test(expected = SomeModifiersUnresolvedException.class)
public void unequalRevisionDatesTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ROOT_WITH_UNEQUAL_DATE, IMPORTED_WITH_UNEQUAL_DATE);
-
- EffectiveModelContext result = reactor.build();
- assertNotNull(result);
-
+ DefaultReactors.defaultReactor().newBuild()
+ .addSources(ROOT_WITH_UNEQUAL_DATE, IMPORTED_WITH_UNEQUAL_DATE)
+ .build();
}
@Test(expected = SomeModifiersUnresolvedException.class)
public void revisionDatesInRootOnlyTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ROOT_WITH_DATE, IMPORTED_WITHOUT_DATE);
-
- EffectiveModelContext result = reactor.build();
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(ROOT_WITH_DATE, IMPORTED_WITHOUT_DATE)
+ .build();
assertNotNull(result);
}
@Test
public void revisionDatesInImportedOnlyTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ROOT_WITHOUT_DATE, IMPORTED_WITH_DATE);
-
- EffectiveModelContext result = reactor.build();
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(ROOT_WITHOUT_DATE, IMPORTED_WITH_DATE)
+ .build();
assertNotNull(result);
}
@Test
public void noRevisionInRootAndImportedTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ROOT_WITH_NO_DATE, IMPORTED_WITH_NO_DATE);
-
- EffectiveModelContext result = reactor.build();
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(ROOT_WITH_NO_DATE, IMPORTED_WITH_NO_DATE)
+ .build();
assertNotNull(result);
}
}
import java.util.logging.Logger;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class IncludeResolutionTest {
@Test
public void includeTest() throws SourceException, ReactorException {
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ROOT, SUBMODULE1, SUBMODULE2);
- EffectiveModelContext result = reactor.build();
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(ROOT, SUBMODULE1, SUBMODULE2)
+ .build();
assertNotNull(result);
}
@Test
public void missingIncludedSourceTest() throws SourceException {
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ERROR_MODULE);
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSource(ERROR_MODULE);
try {
reactor.build();
fail("reactor.process should fail due to missing included source");
@Test
public void missingIncludedSourceTest2() throws SourceException {
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ERROR_SUBMODULE);
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSource(ERROR_SUBMODULE);
try {
reactor.build();
fail("reactor.process should fail due to missing included source");
@Test
public void missingIncludedSourceTest3() throws SourceException, ReactorException {
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(MISSING_PARENT_MODULE);
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSource(MISSING_PARENT_MODULE);
try {
reactor.build();
fail("reactor.process should fail due to missing belongsTo source");
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class IncludeRevisionsTest {
@Test
public void revsEqualTest() throws ReactorException {
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(EQUAL_REV, EQUAL_ROOT);
-
- EffectiveModelContext result = reactor.build();
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(EQUAL_REV, EQUAL_ROOT)
+ .build();
assertNotNull(result);
}
@Test
public void revsUnequalTest() throws ReactorException {
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(UNEQUAL_REV, UNEQUAL_ROOT);
-
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(UNEQUAL_REV, UNEQUAL_ROOT);
try {
reactor.build();
fail("reactor.process should fail due to unequal revisions in include and submodule");
@Test
public void revIncludeOnly() throws ReactorException {
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(SUBMOD_ONLY_REV, SUBMOD_ONLY_ROOT);
-
- EffectiveModelContext result = reactor.build();
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(SUBMOD_ONLY_REV, SUBMOD_ONLY_ROOT)
+ .build();
assertNotNull(result);
}
@Test
public void revInModuleOnly() throws ReactorException {
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(MOD_ONLY_REV, MOD_ONLY_ROOT);
-
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(MOD_ONLY_REV, MOD_ONLY_ROOT);
try {
reactor.build();
fail("reactor.process should fail due to missing revision in included submodule");
@Test
public void revNowhereTest() throws ReactorException {
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(NOWHERE_REV, NOWHERE_ROOT);
-
- EffectiveModelContext result = reactor.build();
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(NOWHERE_REV, NOWHERE_ROOT)
+ .build();
assertNotNull(result);
}
}
import java.util.Iterator;
import java.util.Set;
-import org.junit.Before;
+import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class IncludedStmtsTest {
-
- private static final StatementStreamSource ROOT_MODULE = sourceForResource(
- "/included-statements-test/root-module.yang");
- private static final StatementStreamSource CHILD_MODULE = sourceForResource(
- "/included-statements-test/child-module.yang");
-
- private SchemaContext result;
-
- @Before
- public void setup() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ROOT_MODULE, CHILD_MODULE);
- result = reactor.buildEffective();
+ private static SchemaContext result;
+
+ @BeforeClass
+ public static void setup() throws ReactorException {
+ result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/included-statements-test/root-module.yang"))
+ .addSource(sourceForResource("/included-statements-test/child-module.yang"))
+ .buildEffective();
}
@Test
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class KeyTest {
@Test
public void keySimpleTest() throws ReactorException {
-
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(KEY_SIMPLE_AND_COMP);
-
- EffectiveModelContext result = reactor.build();
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(KEY_SIMPLE_AND_COMP)
+ .build();
assertNotNull(result);
}
@Test
public void keyCompositeInvalid() {
-
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(KEY_COMP_DUPLICATE);
-
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSource(KEY_COMP_DUPLICATE);
try {
reactor.build();
fail("reactor.process should fail due to duplicate name in key");
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
public class ListKeysTest {
@Test
public void correctListKeysTest() throws ReactorException {
-
- final StatementStreamSource yangFile = sourceForResource("/list-keys-test/correct-list-keys-test.yang");
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(yangFile);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/list-keys-test/correct-list-keys-test.yang"))
+ .buildEffective();
assertNotNull(result);
}
@Test
public void incorrectListKeysTest1() {
-
- final StatementStreamSource yangFile = sourceForResource("/list-keys-test/incorrect-list-keys-test.yang");
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(yangFile);
-
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test.yang"));
try {
reactor.buildEffective();
fail("effective build should fail due to list instead of leaf referenced in list key");
@Test
public void incorrectListKeysTest2() {
-
- final StatementStreamSource yangFile = sourceForResource("/list-keys-test/incorrect-list-keys-test2.yang");
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(yangFile);
-
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test2.yang"));
try {
reactor.buildEffective();
fail("effective build should fail due to missing leaf referenced in list key");
@Test
public void incorrectListKeysTest3() {
-
- final StatementStreamSource yangFile = sourceForResource("/list-keys-test/incorrect-list-keys-test3.yang");
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(yangFile);
-
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test3.yang"));
try {
reactor.buildEffective();
fail("effective build should fail due to list instead of leaf in grouping referenced in list key");
@Test
public void incorrectListKeysTest4() {
-
- final StatementStreamSource yangFile = sourceForResource("/list-keys-test/incorrect-list-keys-test4.yang");
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(yangFile);
-
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test4.yang"));
try {
reactor.buildEffective();
fail("effective build should fail due to list instead of leaf in grouping augmented to list referenced "
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class ListTest {
- private static final StatementStreamSource LIST_MODULE = sourceForResource("/list-test/list-test.yang");
-
@Test
public void listAndLeavesTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(LIST_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/list-test/list-test.yang"))
+ .buildEffective();
assertNotNull(result);
final Module testModule = result.findModules("list-test").iterator().next();
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class MoreRevisionsTest {
@Test
public void readAndParseYangFileTest() throws ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild().addSource(REVFILE).buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild().addSource(REVFILE).buildEffective();
assertNotNull(result);
final Module moduleByName = result.getModules().iterator().next();
assertEquals("2015-06-07", moduleByName.getQNameModule().getRevision().get().toString());
@Test
public void twoRevisionsTest() throws ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
.addSources(TED_20130712, TED_20131021, IETF_TYPES)
.buildEffective();
assertNotNull(result);
@Test
public void twoRevisionsTest2() throws ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
.addSources(NETWORK_TOPOLOGY_20130712, NETWORK_TOPOLOGY_20131021, IETF_TYPES)
.buildEffective();
assertNotNull(result);
@Test
public void moreRevisionsListKeyTest() throws ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
.addSources(TED_20130712, TED_20131021, ISIS_20130712, ISIS_20131021, L3_20130712, L3_20131021)
.addSources(IETF_TYPES,NETWORK_TOPOLOGY_20130712, NETWORK_TOPOLOGY_20131021)
.buildEffective();
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class MustAndWhenStmtTest {
-
- private static final StatementStreamSource MUST_MODULE = sourceForResource("/must-when-stmt-test/must-test.yang");
- private static final StatementStreamSource WHEN_MODULE = sourceForResource("/must-when-stmt-test/when-test.yang");
-
@Test
public void mustStmtTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(MUST_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/must-when-stmt-test/must-test.yang"))
+ .buildEffective();
assertNotNull(result);
final Module testModule = result.findModules("must-test").iterator().next();
@Test
public void whenStmtTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(WHEN_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/must-when-stmt-test/when-test.yang"))
+ .buildEffective();
assertNotNull(result);
final Module testModule = result.findModules("when-test").iterator().next();
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class NotificationStmtTest {
- private static final StatementStreamSource NOTIFICATION_MODULE = sourceForResource("/model/baz.yang");
- private static final StatementStreamSource IMPORTED_MODULE = sourceForResource("/model/bar.yang");
-
@Test
public void notificationTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(NOTIFICATION_MODULE, IMPORTED_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(sourceForResource("/model/baz.yang"), sourceForResource("/model/bar.yang"))
+ .buildEffective();
assertNotNull(result);
final Module testModule = result.findModules("baz").iterator().next();
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class RpcStmtTest {
- private static final StatementStreamSource RPC_MODULE = sourceForResource("/model/baz.yang");
- private static final StatementStreamSource IMPORTED_MODULE = sourceForResource("/model/bar.yang");
- private static final StatementStreamSource FOO_MODULE = sourceForResource("/rpc-stmt-test/foo.yang");
-
@Test
public void rpcTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(RPC_MODULE, IMPORTED_MODULE, FOO_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/model/baz.yang"))
+ .addSource(sourceForResource("/model/bar.yang"))
+ .addSource(sourceForResource("/rpc-stmt-test/foo.yang"))
+ .buildEffective();
assertNotNull(result);
final Module testModule = result.findModules("baz").iterator().next();
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.api.YinTextSchemaSource;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YinStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YinTextToDomTransformer;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;
public static SchemaContext parseYangSources(final StatementParserMode statementParserMode,
final Set<QName> supportedFeatures, final Collection<? extends StatementStreamSource> sources)
throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild(
- statementParserMode);
- reactor.addSources(sources);
+ final BuildAction reactor = DefaultReactors.defaultReactor().newBuild(statementParserMode)
+ .addSources(sources);
if (supportedFeatures != null) {
reactor.setSupportedFeatures(supportedFeatures);
}
private static SchemaContext parseYangSources(final StatementStreamSource[] yangSources,
final StatementStreamSource[] libSources, final Set<QName> supportedFeatures) throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(yangSources);
- reactor.addLibSources(libSources);
+ final BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ .addSources(yangSources).addLibSources(libSources);
if (supportedFeatures != null) {
reactor.setSupportedFeatures(supportedFeatures);
}
public static SchemaContext parseYinSources(final StatementParserMode statementParserMode,
final StatementStreamSource... sources) throws ReactorException {
-
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
- .newBuild(statementParserMode);
- reactor.addSources(sources);
-
- return reactor.buildEffective();
+ return DefaultReactors.defaultReactor().newBuild(statementParserMode).addSources(sources).buildEffective();
}
public static Module findImportedModule(final SchemaContext context, final Module rootModule,
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.api.YinTextSchemaSource;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YinStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YinTextToDomTransformer;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;
public static SchemaContext loadModules(final URI resourceDirectory)
throws ReactorException, IOException, YangSyntaxErrorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
+ final BuildAction reactor = DefaultReactors.defaultReactor().newBuild();
File[] files = new File(resourceDirectory).listFiles();
for (File file : files) {
public static SchemaContext loadModuleResources(final Class<?> refClass, final String... resourceNames)
throws IOException, ReactorException, YangSyntaxErrorException {
- final BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
+ final BuildAction reactor = DefaultReactors.defaultReactor().newBuild();
for (String resourceName : resourceNames) {
reactor.addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource(refClass,
public static SchemaContext loadYinModules(final URI resourceDirectory) throws ReactorException, SAXException,
IOException {
- final BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
+ final BuildAction reactor = DefaultReactors.defaultReactor().newBuild();
for (File file : new File(resourceDirectory).listFiles()) {
reactor.addSource(YinStatementStreamSource.create(YinTextToDomTransformer.transformSource(
public static Module loadYinModule(final YinTextSchemaSource source) throws ReactorException, SAXException,
IOException {
- final SchemaContext ctx = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ final SchemaContext ctx = DefaultReactors.defaultReactor().newBuild()
.addSource(YinStatementStreamSource.create(YinTextToDomTransformer.transformSource(source)))
.buildEffective();
return ctx.getModules().iterator().next();
}
public static SchemaContext parseYangSources(final StatementStreamSource... sources) throws ReactorException {
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
- .newBuild();
- reactor.addSources(sources);
-
- return reactor.buildEffective();
+ return DefaultReactors.defaultReactor().newBuild().addSources(sources).buildEffective();
}
public static SchemaContext parseYangSources(final File... files)
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class TypedefSubStmtsTest {
- private static final StatementStreamSource FOOBAR = sourceForResource(
- "/typedef-substmts-test/typedef-substmts-test.yang");
-
@Test
public void typedefSubStmtsTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(FOOBAR);
-
- SchemaContext result = reactor.buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/typedef-substmts-test/typedef-substmts-test.yang"))
+ .buildEffective();
assertNotNull(result);
Set<TypeDefinition<?>> typedefs = result.getTypeDefinitions();
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
public class TypesResolutionTest {
private SchemaContext context;
@Test
public void testUnionWithExt() throws ReactorException {
-
- final StatementStreamSource yangFile1 = sourceForResource("/types/union-with-ext/extdef.yang");
- final StatementStreamSource yangFile2 = sourceForResource("/types/union-with-ext/unionbug.yang");
- final StatementStreamSource yangFile3 = sourceForResource("/ietf/ietf-inet-types@2010-09-24.yang");
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(yangFile1, yangFile2, yangFile3);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/types/union-with-ext/extdef.yang"))
+ .addSource(sourceForResource("/types/union-with-ext/unionbug.yang"))
+ .addSource(sourceForResource("/ietf/ietf-inet-types@2010-09-24.yang"))
+ .buildEffective();
assertNotNull(result);
}
@Test
public void testUnionWithBits() throws ReactorException {
-
- final StatementStreamSource yangFile = sourceForResource("/types/union-with-bits/union-bits-model.yang");
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(yangFile);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/types/union-with-bits/union-bits-model.yang"))
+ .buildEffective();
assertNotNull(result);
}
@Test
public void testUnionInList() {
- final StatementStreamSource yangFile = sourceForResource("/types/union-in-list/unioninlisttest.yang");
-
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(yangFile);
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/types/union-in-list/unioninlisttest.yang"));
try {
final SchemaContext result = reactor.buildEffective();
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.InvalidSubstatementException;
import org.opendaylight.yangtools.yang.parser.spi.meta.MissingSubstatementException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class YangDataExtensionTest {
@Test
public void testIfFeatureStatementBeingIgnoredInYangDataBody() throws Exception {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.setSupportedFeatures(ImmutableSet.of());
- reactor.addSources(FOOBAR_MODULE, IETF_RESTCONF_MODULE);
-
- final SchemaContext schemaContext = reactor.buildEffective();
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .setSupportedFeatures(ImmutableSet.of())
+ .addSources(FOOBAR_MODULE, IETF_RESTCONF_MODULE)
+ .buildEffective();
assertNotNull(schemaContext);
final Module foobar = schemaContext.findModule("foobar", REVISION).get();
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class YangFileStmtTest {
//basic statements to parse and write
private static final StatementStreamSource SUBFOO2 = sourceForResource("/model/subfoo.yang");
@Test
- public void readAndParseYangFileTestModel() throws SourceException, ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
-
- reactor.addSources(BAZ,FOO,BAR,SUBFOO);
- EffectiveModelContext result = reactor.build();
+ public void readAndParseYangFileTestModel() throws ReactorException {
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(BAZ, FOO, BAR, SUBFOO)
+ .build();
assertNotNull(result);
}
@Test
- public void readAndParseYangFileTestModel2() throws SourceException, ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
-
- reactor.addSources(BAZ2,FOO2,BAR2,SUBFOO2);
- EffectiveModelContext result = reactor.build();
+ public void readAndParseYangFileTestModel2() throws ReactorException {
+ EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(BAZ2, FOO2, BAR2, SUBFOO2)
+ .build();
assertNotNull(result);
}
@Test
- public void readAndParseYangFileTest() throws SourceException, ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(YANGFILE, SIMPLENODES, IMPORTEDYANGFILE, FOOBAR);
- reactor.addSources(EXTFILE, EXTUSE);
- SchemaContext result = reactor.buildEffective();
+ public void readAndParseYangFileTest() throws ReactorException {
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(YANGFILE, SIMPLENODES, IMPORTEDYANGFILE, FOOBAR, EXTFILE, EXTUSE)
+ .buildEffective();
assertNotNull(result);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
public class YangParserTest {
private static final QNameModule FOO = QNameModule.create(URI.create("urn:opendaylight.foo"),
@Test
public void unknownStatementBetweenRevisionsTest() throws ReactorException {
-
- final StatementStreamSource yangModule = sourceForResource("/yang-grammar-test/revisions-extension.yang");
- final StatementStreamSource yangSubmodule = sourceForResource(
- "/yang-grammar-test/submodule-header-extension.yang");
-
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(yangModule, yangSubmodule);
-
- final SchemaContext result = reactor.buildEffective();
+ final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/yang-grammar-test/revisions-extension.yang"))
+ .addSource(sourceForResource("/yang-grammar-test/submodule-header-extension.yang"))
+ .buildEffective();
assertNotNull(result);
}
final StatementStreamSource yangFile3 = sourceForResource(
"/yang-grammar-test/stmtsep-in-statements-sub.yang");
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(yangFile1, yangFile2, yangFile3);
+ final BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ .addSources(yangFile1, yangFile2, yangFile3);
// TODO: change test or create new module in order to respect new statement parser validations
try {
final SchemaContext result = reactor.buildEffective();
import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class YangParserWithContextTest {
private static final URI T1_NS = URI.create("urn:simple.demo.test1");
sourceForResource("/ietf/network-topology@2013-10-21.yang") };
@Test
- public void testTypeFromContext() throws Exception {
-
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
-
- final StatementStreamSource types = sourceForResource("/types/custom-types-test@2012-04-04.yang");
- final StatementStreamSource test1 = sourceForResource("/context-test/test1.yang");
-
- reactor.addSources(IETF);
- reactor.addSources(types, test1);
-
- final SchemaContext context = reactor.buildEffective();
+ public void testTypeFromContext() throws ReactorException {
+ final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ .addSources(IETF)
+ .addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
+ .addSource(sourceForResource("/context-test/test1.yang"))
+ .buildEffective();
final Module module = context.findModule("test1", Revision.of("2013-06-18")).get();
final LeafSchemaNode leaf = (LeafSchemaNode) module.getDataChildByName(QName.create(module.getQNameModule(),
}
@Test
- public void testUsesFromContext() throws Exception {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
-
- final StatementStreamSource test2 = sourceForResource("/context-test/test2.yang");
- reactor.addSources(BAZ, FOO, BAR, SUBFOO, test2);
- final SchemaContext context = reactor.buildEffective();
+ public void testUsesFromContext() throws ReactorException {
+ final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ .addSources(BAZ, FOO, BAR, SUBFOO, sourceForResource("/context-test/test2.yang"))
+ .buildEffective();
final Module testModule = context.findModule("test2", Revision.of("2013-06-18")).get();
final Module contextModule = context.findModules(URI.create("urn:opendaylight.baz")).iterator().next();
}
@Test
- public void testUsesRefineFromContext() throws Exception {
-
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
-
- final StatementStreamSource test2 = sourceForResource("/context-test/test2.yang");
- reactor.addSources(BAZ, FOO, BAR, SUBFOO, test2);
- final SchemaContext context = reactor.buildEffective();
+ public void testUsesRefineFromContext() throws ReactorException {
+ final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ .addSources(BAZ, FOO, BAR, SUBFOO, sourceForResource("/context-test/test2.yang"))
+ .buildEffective();
final Module module = context.findModule("test2", Revision.of("2013-06-18")).get();
final ContainerSchemaNode peer = (ContainerSchemaNode) module.getDataChildByName(QName.create(
}
@Test
- public void testIdentity() throws Exception {
-
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
-
- final StatementStreamSource types = sourceForResource("/types/custom-types-test@2012-04-04.yang");
- final StatementStreamSource test3 = sourceForResource("/context-test/test3.yang");
-
- reactor.addSources(IETF);
- reactor.addSources(types, test3);
- final SchemaContext context = reactor.buildEffective();
+ public void testIdentity() throws ReactorException {
+ final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ .addSources(IETF)
+ .addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
+ .addSource(sourceForResource("/context-test/test3.yang"))
+ .buildEffective();
final Module module = context.findModule("test3", Revision.of("2013-06-18")).get();
final Set<IdentitySchemaNode> identities = module.getIdentities();
}
@Test
- public void testUnknownNodes() throws Exception {
-
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
-
- final StatementStreamSource types = sourceForResource("/types/custom-types-test@2012-04-04.yang");
- final StatementStreamSource test3 = sourceForResource("/context-test/test3.yang");
-
- reactor.addSources(IETF);
- reactor.addSources(types, test3);
-
- final SchemaContext context = reactor.buildEffective();
+ public void testUnknownNodes() throws ReactorException {
+ final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ .addSources(IETF)
+ .addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
+ .addSource(sourceForResource("/context-test/test3.yang"))
+ .buildEffective();
final Module module = context.findModule("test3", Revision.of("2013-06-18")).get();
final ContainerSchemaNode network = (ContainerSchemaNode) module.getDataChildByName(QName.create(
}
@Test
- public void testAugment() throws Exception {
+ public void testAugment() throws ReactorException {
final StatementStreamSource resource = sourceForResource("/context-augment-test/test4.yang");
final StatementStreamSource test1 = sourceForResource("/context-augment-test/test1.yang");
final StatementStreamSource test2 = sourceForResource("/context-augment-test/test2.yang");
}
@Test
- public void testDeviation() throws Exception {
-
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
-
- final StatementStreamSource bar = sourceForResource("/model/bar.yang");
- final StatementStreamSource deviationTest = sourceForResource("/context-test/deviation-test.yang");
-
- reactor.addSources(bar, deviationTest);
- final SchemaContext context = reactor.buildEffective();
+ public void testDeviation() throws ReactorException {
+ final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ .addSource(sourceForResource("/model/bar.yang"))
+ .addSource(sourceForResource("/context-test/deviation-test.yang"))
+ .buildEffective();
final Module testModule = context.findModule("deviation-test", Revision.of("2013-02-27")).get();
final Set<Deviation> deviations = testModule.getDeviations();
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class YangTypes2StmtTest {
@Test
public void readAndParseYangFileTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(TYPEFILE1, TYPEFILE2, TYPEFILE3, TYPEFILE4);
- SchemaContext result = reactor.buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(TYPEFILE1, TYPEFILE2, TYPEFILE3, TYPEFILE4)
+ .buildEffective();
assertNotNull(result);
final LeafSchemaNode lfDecimalNode = (LeafSchemaNode) result.getDataChildByName(LF_DECIMAL);
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
public class YangTypesStmtTest {
@Test
public void readAndParseYangFileTest() throws ReactorException {
- CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(TYPEFILE1, TYPEFILE2, TYPEFILE3);
- reactor.addSources(FILE1, FILE2, FILE3, FILE4);
- SchemaContext result = reactor.buildEffective();
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ .addSources(TYPEFILE1, TYPEFILE2, TYPEFILE3, FILE1, FILE2, FILE3, FILE4)
+ .buildEffective();
assertNotNull(result);
}
}
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.YinTextSchemaSource;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YinStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YinTextToDomTransformer;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
import org.opendaylight.yangtools.yang.stmt.TestUtils;
import org.xml.sax.SAXException;
}
@Test
- public void readAndParseYinFileTestModel() throws SourceException, ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ public void readAndParseYinFileTestModel() throws ReactorException {
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
.addSources(YIN_FILE, EXT_FILE, EXT_USE_FILE)
.buildEffective();
assertNotNull(result);
// parsing yin file whose import statement references a module which does not exist
@Test(expected = SomeModifiersUnresolvedException.class)
public void readAndParseInvalidYinFileTest() throws ReactorException {
- SchemaContext result = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ SchemaContext result = DefaultReactors.defaultReactor().newBuild()
.addSource(INVALID_YIN_FILE)
.buildEffective();
assertNotNull(result);
// parsing yin file with duplicate key name in a list statement
public void readAndParseInvalidYinFileTest2() {
- BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild()
+ BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
.addSource(INVALID_YIN_FILE_2);
try {
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc6020.repo.YinStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
/**
* Utility class which provides convenience methods for producing effective schema context based on the supplied
*/
public static SchemaContext parseSources(final Set<QName> supportedFeatures,
final StatementParserMode statementParserMode, final Collection<? extends StatementStreamSource> sources) {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild(
- statementParserMode);
+ final BuildAction reactor = DefaultReactors.defaultReactor().newBuild(statementParserMode);
if (supportedFeatures != null) {
reactor.setSupportedFeatures(supportedFeatures);
}
Code Review / yangtools.git / commitdiff