This is the next step to parser split-up: make sure the unit test
suite refers to the minimum parser it needs to perform its function.
Change-Id: I8ddb143706debfe9f2ac2fc665ec982c1c4e3039
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
45 files changed:
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
@Test
public void testElementCountConstraints() throws ParseException, ReactorException, URISyntaxException, IOException,
YangSyntaxErrorException {
@Test
public void testElementCountConstraints() throws ParseException, ReactorException, URISyntaxException, IOException,
YangSyntaxErrorException {
- final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSource(YangStatementStreamSource.create(
YangTextSchemaSource.forResource("/constraint-definitions-test/foo.yang")))
.buildEffective();
.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.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.rfc7950.reactor.RFC7950Reactors;
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.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void descriptionAndReferenceTest11() throws ReactorException {
@Test
public void descriptionAndReferenceTest11() throws ReactorException {
- DefaultReactors.defaultReactor().newBuild()
+ RFC7950Reactors.defaultReactor().newBuild()
.addSources(ROOT_MODULE, CHILD_MODULE, CHILD_MODULE_1, IMPORTED_MODULE)
.build().getRootStatements().forEach(declaredStmt -> {
if (declaredStmt instanceof ModuleStatement) {
.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.junit.Ignore;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
+import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
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.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void validAugAbsTest() throws ReactorException {
@Test
public void validAugAbsTest() throws ReactorException {
- final EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ final EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(IMPORTED, VALID_ARGS)
.build();
assertNotNull(result);
.addSources(IMPORTED, VALID_ARGS)
.build();
assertNotNull(result);
@Test
public void invalidAugRel1Test() {
@Test
public void invalidAugRel1Test() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(INVALID_REL1);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSources(INVALID_REL1);
@Test
public void invalidAugRel2Test() {
@Test
public void invalidAugRel2Test() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(INVALID_REL2);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSources(INVALID_REL2);
@Test
public void invalidAugAbs() {
@Test
public void invalidAugAbs() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(INVALID_ABS);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSources(INVALID_ABS);
@Test
public void invalidAugAbsPrefixedNoImp() {
@Test
public void invalidAugAbsPrefixedNoImp() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(INVALID_ABS_PREFIXED_NO_IMP);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSources(INVALID_ABS_PREFIXED_NO_IMP);
@Test(expected = IllegalArgumentException.class)
@Ignore
public void invalidAugEmptyTest() throws ReactorException {
@Test(expected = IllegalArgumentException.class)
@Ignore
public void invalidAugEmptyTest() throws ReactorException {
- DefaultReactors.defaultReactor().newBuild().addSources(INVALID_EMPTY).build();
+ RFC7950Reactors.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 {
fail("reactor.process should fail due to empty path");
}
@Test(expected = IllegalArgumentException.class)
@Ignore
public void invalidAugXPathTest() throws ReactorException {
- DefaultReactors.defaultReactor().newBuild().addSources(INVALID_XPATH).build();
+ RFC7950Reactors.defaultReactor().newBuild().addSources(INVALID_XPATH).build();
fail("reactor.process should fail due to invalid XPath");
}
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.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.rfc7950.reactor.RFC7950Reactors;
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.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void multipleAugmentsAndMultipleModulesTest() throws ReactorException {
@Test
public void multipleAugmentsAndMultipleModulesTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(MULTIPLE_AUGMENT_ROOT, MULTIPLE_AUGMENT_IMPORTED, MULTIPLE_AUGMENT_SUBMODULE)
.buildEffective();
assertNotNull(result);
.addSources(MULTIPLE_AUGMENT_ROOT, MULTIPLE_AUGMENT_IMPORTED, MULTIPLE_AUGMENT_SUBMODULE)
.buildEffective();
assertNotNull(result);
@Test
public void multipleAugmentTest() throws ReactorException {
@Test
public void multipleAugmentTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(MULTIPLE_AUGMENT)
.buildEffective();
assertNotNull(result);
.addSource(MULTIPLE_AUGMENT)
.buildEffective();
assertNotNull(result);
@Test(expected = SomeModifiersUnresolvedException.class)
public void multipleAugmentIncorrectPathTest() throws ReactorException {
@Test(expected = SomeModifiersUnresolvedException.class)
public void multipleAugmentIncorrectPathTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(MULTIPLE_AUGMENT_INCORRECT)
.buildEffective();
assertNull(result);
.addSource(MULTIPLE_AUGMENT_INCORRECT)
.buildEffective();
assertNull(result);
@Test(expected = SomeModifiersUnresolvedException.class)
public void multipleAugmentIncorrectPathAndGrpTest() throws ReactorException {
@Test(expected = SomeModifiersUnresolvedException.class)
public void multipleAugmentIncorrectPathAndGrpTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(MULTIPLE_AUGMENT_INCORRECT2)
.buildEffective();
assertNull(result);
.addSource(MULTIPLE_AUGMENT_INCORRECT2)
.buildEffective();
assertNull(result);
@Test
public void readAndParseYangFileTest() throws ReactorException {
@Test
public void readAndParseYangFileTest() throws ReactorException {
- final SchemaContext root = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext root = RFC7950Reactors.defaultReactor().newBuild()
.addSources(AUGMENTED, ROOT)
.buildEffective();
assertNotNull(root);
.addSources(AUGMENTED, ROOT)
.buildEffective();
assertNotNull(root);
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import org.junit.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.rfc7950.reactor.RFC7950Reactors;
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.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void readAndParseYangFileTest() throws SourceException, ReactorException {
@Test
public void readAndParseYangFileTest() throws SourceException, ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(AUGMENTED, ROOT)
.build();
assertNotNull(result);
.addSources(AUGMENTED, ROOT)
.build();
assertNotNull(result);
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
import org.opendaylight.yangtools.yang.parser.odlext.stmt.AnyxmlSchemaLocationEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.odlext.stmt.AnyxmlSchemaLocationEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
public class Bug3874ExtensionTest {
@Test
public void test() throws Exception {
public class Bug3874ExtensionTest {
@Test
public void test() throws Exception {
- SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug3874");
+ SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ .addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource("/bugs/bug3874/foo.yang")))
+ .addSource(YangStatementStreamSource.create(
+ YangTextSchemaSource.forResource("/bugs/bug3874/yang-ext.yang")))
+ .buildEffective();
QNameModule foo = QNameModule.create(URI.create("foo"));
QName myContainer2QName = QName.create(foo, "my-container-2");
QNameModule foo = QNameModule.create(URI.create("foo"));
QName myContainer2QName = QName.create(foo, "my-container-2");
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void effectiveAugmentFirstTest() throws ReactorException {
@Test
public void effectiveAugmentFirstTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(TARGET, AUGMENT_FIRST)
.buildEffective();
assertNotNull(result);
.addSources(TARGET, AUGMENT_FIRST)
.buildEffective();
assertNotNull(result);
@Test
public void effectiveAugmentSecondTest() throws ReactorException {
@Test
public void effectiveAugmentSecondTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(TARGET, AUGMENT_SECOND)
.buildEffective();
assertNotNull(result);
.addSources(TARGET, AUGMENT_SECOND)
.buildEffective();
assertNotNull(result);
@Test
public void effectiveAugmentBothTest() throws ReactorException {
@Test
public void effectiveAugmentBothTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(TARGET, AUGMENT_FIRST, AUGMENT_SECOND)
.buildEffective();
assertNotNull(result);
.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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
public class Bug7480Test {
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
public class Bug7480Test {
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
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 SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSource(StmtTestUtils.sourceForResource(
"/bugs/bug7480/main-source-lib-source-conflict-test/parent-module.yang"))
.addLibSources(
.addSource(StmtTestUtils.sourceForResource(
"/bugs/bug7480/main-source-lib-source-conflict-test/parent-module.yang"))
.addLibSources(
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
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 SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSource(StmtTestUtils.sourceForResource(
"/bugs/bug7480/main-source-lib-source-conflict-test/child-module.yang"))
.addLibSources(
.addSource(StmtTestUtils.sourceForResource(
"/bugs/bug7480/main-source-lib-source-conflict-test/child-module.yang"))
.addLibSources(
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.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.rfc7950.reactor.RFC7950Reactors;
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.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
final Map<QNameModule, Set<QNameModule>> modulesWithSupportedDeviations = ImmutableMap.of(
foo, ImmutableSet.of(bar, baz), bar, ImmutableSet.of(baz));
final Map<QNameModule, Set<QNameModule>> modulesWithSupportedDeviations = ImmutableMap.of(
foo, ImmutableSet.of(bar, baz), bar, ImmutableSet.of(baz));
- final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE)
.setModulesWithSupportedDeviations(modulesWithSupportedDeviations)
.buildEffective();
.addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE)
.setModulesWithSupportedDeviations(modulesWithSupportedDeviations)
.buildEffective();
@Test
public void testDeviationsSupportedInAllModules() throws Exception {
@Test
public void testDeviationsSupportedInAllModules() throws Exception {
- final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE)
.buildEffective();
assertNotNull(schemaContext);
.addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE)
.buildEffective();
assertNotNull(schemaContext);
@Test
public void testDeviationsSupportedInNoModule() throws Exception {
@Test
public void testDeviationsSupportedInNoModule() throws Exception {
- final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE)
.setModulesWithSupportedDeviations(ImmutableMap.of())
.buildEffective();
.addSources(FOO_MODULE, BAR_MODULE, BAZ_MODULE, FOOBAR_MODULE)
.setModulesWithSupportedDeviations(ImmutableMap.of())
.buildEffective();
@Test
public void shouldFailOnAttemptToDeviateTheSameModule() {
@Test
public void shouldFailOnAttemptToDeviateTheSameModule() {
- final BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(FOO_INVALID_MODULE);
+ final BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSources(FOO_INVALID_MODULE);
try {
reactor.buildEffective();
try {
reactor.buildEffective();
@Test
public void shouldFailOnAttemptToDeviateTheSameModule2() {
@Test
public void shouldFailOnAttemptToDeviateTheSameModule2() {
- final BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ final BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild()
.addSources(BAR_INVALID_MODULE, BAZ_INVALID_MODULE);
try {
.addSources(BAR_INVALID_MODULE, BAZ_INVALID_MODULE);
try {
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void choiceAndCaseTest() throws ReactorException {
@Test
public void choiceAndCaseTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(CHOICE_MODULE, IMPORTED_MODULE1, IMPORTED_MODULE2, INCLUDED_MODULE)
.buildEffective();
assertNotNull(result);
.addSources(CHOICE_MODULE, IMPORTED_MODULE1, IMPORTED_MODULE2, INCLUDED_MODULE)
.buildEffective();
assertNotNull(result);
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.text.ParseException;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.List;
import java.util.Optional;
import java.util.Set;
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
private static final StatementStreamSource BAR_IMP_MODULE = sourceForResource("/deviation-stmt-test/bar-imp.yang");
@Test
private static final StatementStreamSource BAR_IMP_MODULE = sourceForResource("/deviation-stmt-test/bar-imp.yang");
@Test
- public void testDeviationAndDeviate() throws ReactorException, ParseException {
- final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ public void testDeviationAndDeviate() throws ReactorException {
+ final SchemaContext schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSources(FOO_MODULE, FOO_IMP_MODULE, BAR_MODULE, BAR_IMP_MODULE)
.buildEffective();
assertNotNull(schemaContext);
.addSources(FOO_MODULE, FOO_IMP_MODULE, BAR_MODULE, BAR_IMP_MODULE)
.buildEffective();
assertNotNull(schemaContext);
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void effectiveBuildTest() throws ReactorException {
@Test
public void effectiveBuildTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild().addSources(SIMPLE_MODULE)
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild().addSources(SIMPLE_MODULE)
.buildEffective();
assertNotNull(result);
.buildEffective();
assertNotNull(result);
@Test
public void extensionsTest() throws ReactorException {
@Test
public void extensionsTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild().addSource(YANG_EXT).buildEffective();
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild().addSource(YANG_EXT).buildEffective();
assertNotNull(result);
Set<GroupingDefinition> groupings = result.getGroupings();
assertNotNull(result);
Set<GroupingDefinition> groupings = result.getGroupings();
@Test
public void mockTest() throws ReactorException, FileNotFoundException, URISyntaxException {
@Test
public void mockTest() throws ReactorException, FileNotFoundException, URISyntaxException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild().addSource(YANG_EXT).buildEffective();
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild().addSource(YANG_EXT).buildEffective();
assertNotNull(result);
}
}
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.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.rfc7950.reactor.RFC7950Reactors;
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.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
@Test(expected = SomeModifiersUnresolvedException.class)
public void cyclicefineTest() throws SourceException, ReactorException, URISyntaxException {
@Test(expected = SomeModifiersUnresolvedException.class)
public void cyclicefineTest() throws SourceException, ReactorException, URISyntaxException {
- CrossSourceStatementReactor.BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ CrossSourceStatementReactor.BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild()
.addSources(CYCLIC_IDENTITY_TEST);
try {
reactor.buildEffective();
.addSources(CYCLIC_IDENTITY_TEST);
try {
reactor.buildEffective();
@Test
public void identityTest() throws SourceException, ReactorException,
URISyntaxException {
@Test
public void identityTest() throws SourceException, ReactorException,
URISyntaxException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(IDENTITY_TEST)
.buildEffective();
.addSources(IDENTITY_TEST)
.buildEffective();
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.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.rfc7950.reactor.RFC7950Reactors;
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.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void effectiveBuildTest() throws SourceException, ReactorException {
@Test
public void effectiveBuildTest() throws SourceException, ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(ROOT_MODULE, IMPORTED_MODULE, SUBMODULE)
.buildEffective();
.addSources(ROOT_MODULE, IMPORTED_MODULE, SUBMODULE)
.buildEffective();
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void modulesAndSubmodulesSimpleReferencesTest() throws ReactorException {
@Test
public void modulesAndSubmodulesSimpleReferencesTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(ROOT_MODULE, IMPORTED_MODULE, SUBMODULE_1, SUBMODULE_2, SUBMODULE_TO_SUBMODULE_1)
.buildEffective();
.addSources(ROOT_MODULE, IMPORTED_MODULE, SUBMODULE_1, SUBMODULE_2, SUBMODULE_TO_SUBMODULE_1)
.buildEffective();
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveSchemaContext;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.EffectiveSchemaContext;
@Test
public void testEffectiveSchemaContext() throws ReactorException, ParseException, URISyntaxException, IOException,
YangSyntaxErrorException {
@Test
public void testEffectiveSchemaContext() throws ReactorException, ParseException, URISyntaxException, IOException,
YangSyntaxErrorException {
- final EffectiveSchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ final EffectiveSchemaContext schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource(
"/effective-schema-context-test/foo.yang")))
.addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource(
.addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource(
"/effective-schema-context-test/foo.yang")))
.addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource(
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.BitsSpecificationEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.Decimal64SpecificationEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.EnumSpecificationEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.BitsSpecificationEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.Decimal64SpecificationEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.EnumSpecificationEffectiveStatement;
@BeforeClass
public static void setup() throws ReactorException {
@BeforeClass
public static void setup() throws ReactorException {
- effectiveSchemaContext = DefaultReactors.defaultReactor().newBuild()
+ effectiveSchemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/type-tests/types.yang"))
.buildEffective();
types = effectiveSchemaContext.findModules("types").iterator().next();
.addSource(sourceForResource("/type-tests/types.yang"))
.buildEffective();
types = effectiveSchemaContext.findModules("types").iterator().next();
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class EffectiveUsesRefineAndConstraintsTest {
@Test
public void refineTest() throws ReactorException {
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class EffectiveUsesRefineAndConstraintsTest {
@Test
public void refineTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/stmt-test/uses/refine-test.yang"))
.buildEffective();
assertNotNull(result);
.addSource(sourceForResource("/stmt-test/uses/refine-test.yang"))
.buildEffective();
assertNotNull(result);
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class ExtensionStmtTest {
@Test
public void testExtensionDefinition() throws ReactorException {
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class ExtensionStmtTest {
@Test
public void testExtensionDefinition() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/model/bar.yang"))
.buildEffective();
assertNotNull(result);
.addSource(sourceForResource("/model/bar.yang"))
.buildEffective();
assertNotNull(result);
@Test
public void testExtensionUsage() throws ReactorException {
@Test
public void testExtensionUsage() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/semantic-statement-parser/ext-typedef.yang"))
.addSource(sourceForResource("/semantic-statement-parser/ext-use.yang"))
.buildEffective();
.addSource(sourceForResource("/semantic-statement-parser/ext-typedef.yang"))
.addSource(sourceForResource("/semantic-statement-parser/ext-use.yang"))
.buildEffective();
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void groupingTest() throws ReactorException {
@Test
public void groupingTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(MODULE, GROUPING_MODULE)
.buildEffective();
assertNotNull(result);
.addSources(MODULE, GROUPING_MODULE)
.buildEffective();
assertNotNull(result);
@Test
public void usesAndRefinesTest() throws ReactorException {
@Test
public void usesAndRefinesTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(MODULE, SUBMODULE, GROUPING_MODULE, USES_MODULE)
.buildEffective();
assertNotNull(result);
.addSources(MODULE, SUBMODULE, GROUPING_MODULE, USES_MODULE)
.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.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.rfc7950.reactor.RFC7950Reactors;
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.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test(expected = SomeModifiersUnresolvedException.class)
public void selfReferencingIdentityTest() throws ReactorException {
@Test(expected = SomeModifiersUnresolvedException.class)
public void selfReferencingIdentityTest() throws ReactorException {
- DefaultReactors.defaultReactor().newBuild().addSource(ILLEGAL_IDENTITY_MODULE).buildEffective();
+ RFC7950Reactors.defaultReactor().newBuild().addSource(ILLEGAL_IDENTITY_MODULE).buildEffective();
}
@Test(expected = SomeModifiersUnresolvedException.class)
public void selfReferencingIdentityWithPrefixTest() throws ReactorException {
}
@Test(expected = SomeModifiersUnresolvedException.class)
public void selfReferencingIdentityWithPrefixTest() throws ReactorException {
- DefaultReactors.defaultReactor().newBuild().addSource(ILLEGAL_IDENTITY_MODULE2).buildEffective();
+ RFC7950Reactors.defaultReactor().newBuild().addSource(ILLEGAL_IDENTITY_MODULE2).buildEffective();
}
@Test
public void importedIdentityTest() throws ReactorException {
}
@Test
public void importedIdentityTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(LEGAL_IDENTITY_MODULE, LEGAL_IDENTITY_MODULE2)
.buildEffective();
assertNotNull(result);
.addSources(LEGAL_IDENTITY_MODULE, LEGAL_IDENTITY_MODULE2)
.buildEffective();
assertNotNull(result);
@Test(expected = SomeModifiersUnresolvedException.class)
public void selfReferencingIdentityThroughChaining() throws ReactorException {
@Test(expected = SomeModifiersUnresolvedException.class)
public void selfReferencingIdentityThroughChaining() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(ILLEGAL_IDENTITY_MODULE3)
.buildEffective();
assertNotNull(result);
.addSource(ILLEGAL_IDENTITY_MODULE3)
.buildEffective();
assertNotNull(result);
@Test
public void chainedIdentityTest() throws ReactorException {
@Test
public void chainedIdentityTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(LEGAL_IDENTITY_MODULE3)
.buildEffective();
assertNotNull(result);
.addSource(LEGAL_IDENTITY_MODULE3)
.buildEffective();
assertNotNull(result);
@Test
public void duplicateIdentityTest() throws ReactorException {
@Test
public void duplicateIdentityTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(DUPLICATE_IDENTITY_MODULE)
.buildEffective();
assertNotNull(result);
.addSource(DUPLICATE_IDENTITY_MODULE)
.buildEffective();
assertNotNull(result);
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
QName.create("foo-namespace", "test-feature-3"),
QName.create("bar-namespace", "imp-feature"));
QName.create("foo-namespace", "test-feature-3"),
QName.create("bar-namespace", "imp-feature"));
- final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSources(FOO_MODULE, BAR_MODULE)
.setSupportedFeatures(supportedFeatures)
.buildEffective();
.addSources(FOO_MODULE, BAR_MODULE)
.setSupportedFeatures(supportedFeatures)
.buildEffective();
@Test
public void testAllFeaturesSupported() throws ReactorException {
@Test
public void testAllFeaturesSupported() throws ReactorException {
- final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSources(FOO_MODULE, BAR_MODULE)
.buildEffective();
assertNotNull(schemaContext);
.addSources(FOO_MODULE, BAR_MODULE)
.buildEffective();
assertNotNull(schemaContext);
@Test
public void testNoFeaturesSupported() throws ReactorException {
@Test
public void testNoFeaturesSupported() throws ReactorException {
- final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSources(FOO_MODULE, BAR_MODULE)
.setSupportedFeatures(ImmutableSet.of())
.buildEffective();
.addSources(FOO_MODULE, BAR_MODULE)
.setSupportedFeatures(ImmutableSet.of())
.buildEffective();
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
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.rfc7950.reactor.RFC7950Reactors;
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.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
@Test
public void inImportOrderTest() throws ReactorException {
@Test
public void inImportOrderTest() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(ROOT_WITHOUT_IMPORT, IMPORT_ROOT, IMPORT_DERIVED)
.build();
assertNotNull(result);
.addSources(ROOT_WITHOUT_IMPORT, IMPORT_ROOT, IMPORT_DERIVED)
.build();
assertNotNull(result);
@Test
public void inInverseOfImportOrderTest() throws ReactorException {
@Test
public void inInverseOfImportOrderTest() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(IMPORT_DERIVED, IMPORT_ROOT, ROOT_WITHOUT_IMPORT)
.build();
assertNotNull(result);
.addSources(IMPORT_DERIVED, IMPORT_ROOT, ROOT_WITHOUT_IMPORT)
.build();
assertNotNull(result);
@Test
public void missingImportedSourceTest() {
@Test
public void missingImportedSourceTest() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild()
.addSources(IMPORT_DERIVED, ROOT_WITHOUT_IMPORT);
try {
reactor.build();
.addSources(IMPORT_DERIVED, ROOT_WITHOUT_IMPORT);
try {
reactor.build();
@Test
public void circularImportsTest() {
@Test
public void circularImportsTest() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
- .addSources(CYCLE_YIN, CYCLE_YANG);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSources(CYCLE_YIN, CYCLE_YANG);
try {
reactor.build();
fail("reactor.process should fail due to circular import");
try {
reactor.build();
fail("reactor.process should fail due to circular import");
@Test
public void selfImportTest() {
@Test
public void selfImportTest() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild()
.addSources(IMPORT_SELF, IMPORT_ROOT, ROOT_WITHOUT_IMPORT);
try {
reactor.build();
.addSources(IMPORT_SELF, IMPORT_ROOT, ROOT_WITHOUT_IMPORT);
try {
reactor.build();
@Test
public void bug2649Test() throws ReactorException {
@Test
public void bug2649Test() throws ReactorException {
- SchemaContext buildEffective = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext buildEffective = RFC7950Reactors.defaultReactor().newBuild()
.addSources(FOO, IMPORT)
.buildEffective();
assertNotNull(buildEffective);
.addSources(FOO, IMPORT)
.buildEffective();
assertNotNull(buildEffective);
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import org.junit.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.rfc7950.reactor.RFC7950Reactors;
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.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void equalRevisionDatesTest() throws ReactorException {
@Test
public void equalRevisionDatesTest() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(ROOT_WITH_EQUAL_DATE, IMPORTED_WITH_EQUAL_DATE)
.build();
assertNotNull(result);
.addSources(ROOT_WITH_EQUAL_DATE, IMPORTED_WITH_EQUAL_DATE)
.build();
assertNotNull(result);
@Test(expected = SomeModifiersUnresolvedException.class)
public void unequalRevisionDatesTest() throws ReactorException {
@Test(expected = SomeModifiersUnresolvedException.class)
public void unequalRevisionDatesTest() throws ReactorException {
- DefaultReactors.defaultReactor().newBuild()
+ RFC7950Reactors.defaultReactor().newBuild()
.addSources(ROOT_WITH_UNEQUAL_DATE, IMPORTED_WITH_UNEQUAL_DATE)
.build();
}
@Test(expected = SomeModifiersUnresolvedException.class)
public void revisionDatesInRootOnlyTest() throws ReactorException {
.addSources(ROOT_WITH_UNEQUAL_DATE, IMPORTED_WITH_UNEQUAL_DATE)
.build();
}
@Test(expected = SomeModifiersUnresolvedException.class)
public void revisionDatesInRootOnlyTest() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(ROOT_WITH_DATE, IMPORTED_WITHOUT_DATE)
.build();
assertNotNull(result);
.addSources(ROOT_WITH_DATE, IMPORTED_WITHOUT_DATE)
.build();
assertNotNull(result);
@Test
public void revisionDatesInImportedOnlyTest() throws ReactorException {
@Test
public void revisionDatesInImportedOnlyTest() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(ROOT_WITHOUT_DATE, IMPORTED_WITH_DATE)
.build();
assertNotNull(result);
.addSources(ROOT_WITHOUT_DATE, IMPORTED_WITH_DATE)
.build();
assertNotNull(result);
@Test
public void noRevisionInRootAndImportedTest() throws ReactorException {
@Test
public void noRevisionInRootAndImportedTest() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(ROOT_WITH_NO_DATE, IMPORTED_WITH_NO_DATE)
.build();
assertNotNull(result);
.addSources(ROOT_WITH_NO_DATE, IMPORTED_WITH_NO_DATE)
.build();
assertNotNull(result);
import java.util.logging.Logger;
import org.junit.Test;
import java.util.logging.Logger;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
+import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
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.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
@Test
public void includeTest() throws SourceException, ReactorException {
@Test
public void includeTest() throws SourceException, ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(ROOT, SUBMODULE1, SUBMODULE2)
.build();
assertNotNull(result);
.addSources(ROOT, SUBMODULE1, SUBMODULE2)
.build();
assertNotNull(result);
@Test
public void missingIncludedSourceTest() throws SourceException {
@Test
public void missingIncludedSourceTest() throws SourceException {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSource(ERROR_MODULE);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSource(ERROR_MODULE);
try {
reactor.build();
fail("reactor.process should fail due to missing included source");
try {
reactor.build();
fail("reactor.process should fail due to missing included source");
@Test
public void missingIncludedSourceTest2() throws SourceException {
@Test
public void missingIncludedSourceTest2() throws SourceException {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSource(ERROR_SUBMODULE);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSource(ERROR_SUBMODULE);
try {
reactor.build();
fail("reactor.process should fail due to missing included source");
try {
reactor.build();
fail("reactor.process should fail due to missing included source");
@Test
public void missingIncludedSourceTest3() throws SourceException, ReactorException {
@Test
public void missingIncludedSourceTest3() throws SourceException, ReactorException {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSource(MISSING_PARENT_MODULE);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSource(MISSING_PARENT_MODULE);
try {
reactor.build();
fail("reactor.process should fail due to missing belongsTo source");
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 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.rfc7950.reactor.RFC7950Reactors;
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.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
@Test
public void revsEqualTest() throws ReactorException {
@Test
public void revsEqualTest() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(EQUAL_REV, EQUAL_ROOT)
.build();
assertNotNull(result);
.addSources(EQUAL_REV, EQUAL_ROOT)
.build();
assertNotNull(result);
@Test
public void revsUnequalTest() throws ReactorException {
@Test
public void revsUnequalTest() throws ReactorException {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(UNEQUAL_REV, UNEQUAL_ROOT);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSources(UNEQUAL_REV, UNEQUAL_ROOT);
try {
reactor.build();
fail("reactor.process should fail due to unequal revisions in include and submodule");
try {
reactor.build();
fail("reactor.process should fail due to unequal revisions in include and submodule");
@Test
public void revIncludeOnly() throws ReactorException {
@Test
public void revIncludeOnly() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(SUBMOD_ONLY_REV, SUBMOD_ONLY_ROOT)
.build();
assertNotNull(result);
.addSources(SUBMOD_ONLY_REV, SUBMOD_ONLY_ROOT)
.build();
assertNotNull(result);
@Test
public void revInModuleOnly() throws ReactorException {
@Test
public void revInModuleOnly() throws ReactorException {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSources(MOD_ONLY_REV, MOD_ONLY_ROOT);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSources(MOD_ONLY_REV, MOD_ONLY_ROOT);
try {
reactor.build();
fail("reactor.process should fail due to missing revision in included submodule");
try {
reactor.build();
fail("reactor.process should fail due to missing revision in included submodule");
@Test
public void revNowhereTest() throws ReactorException {
@Test
public void revNowhereTest() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(NOWHERE_REV, NOWHERE_ROOT)
.build();
assertNotNull(result);
.addSources(NOWHERE_REV, NOWHERE_ROOT)
.build();
assertNotNull(result);
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class IncludedStmtsTest {
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class IncludedStmtsTest {
@BeforeClass
public static void setup() throws ReactorException {
@BeforeClass
public static void setup() throws ReactorException {
- result = DefaultReactors.defaultReactor().newBuild()
+ result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/included-statements-test/root-module.yang"))
.addSource(sourceForResource("/included-statements-test/child-module.yang"))
.buildEffective();
.addSource(sourceForResource("/included-statements-test/root-module.yang"))
.addSource(sourceForResource("/included-statements-test/child-module.yang"))
.buildEffective();
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import org.junit.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.rfc7950.reactor.RFC7950Reactors;
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.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void keySimpleTest() throws ReactorException {
@Test
public void keySimpleTest() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(KEY_SIMPLE_AND_COMP)
.build();
assertNotNull(result);
.addSource(KEY_SIMPLE_AND_COMP)
.build();
assertNotNull(result);
@Test
public void keyCompositeInvalid() {
@Test
public void keyCompositeInvalid() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild().addSource(KEY_COMP_DUPLICATE);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSource(KEY_COMP_DUPLICATE);
try {
reactor.build();
fail("reactor.process should fail due to duplicate name in key");
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.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
+import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
@Test
public void correctListKeysTest() throws ReactorException {
@Test
public void correctListKeysTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/list-keys-test/correct-list-keys-test.yang"))
.buildEffective();
assertNotNull(result);
.addSource(sourceForResource("/list-keys-test/correct-list-keys-test.yang"))
.buildEffective();
assertNotNull(result);
@Test
public void incorrectListKeysTest1() {
@Test
public void incorrectListKeysTest1() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test.yang"));
try {
reactor.buildEffective();
.addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test.yang"));
try {
reactor.buildEffective();
@Test
public void incorrectListKeysTest2() {
@Test
public void incorrectListKeysTest2() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test2.yang"));
try {
reactor.buildEffective();
.addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test2.yang"));
try {
reactor.buildEffective();
@Test
public void incorrectListKeysTest3() {
@Test
public void incorrectListKeysTest3() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test3.yang"));
try {
reactor.buildEffective();
.addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test3.yang"));
try {
reactor.buildEffective();
@Test
public void incorrectListKeysTest4() {
@Test
public void incorrectListKeysTest4() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test4.yang"));
try {
reactor.buildEffective();
.addSource(sourceForResource("/list-keys-test/incorrect-list-keys-test4.yang"));
try {
reactor.buildEffective();
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class ListTest {
@Test
public void listAndLeavesTest() throws ReactorException {
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class ListTest {
@Test
public void listAndLeavesTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/list-test/list-test.yang"))
.buildEffective();
assertNotNull(result);
.addSource(sourceForResource("/list-test/list-test.yang"))
.buildEffective();
assertNotNull(result);
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void readAndParseYangFileTest() throws ReactorException {
@Test
public void readAndParseYangFileTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild().addSource(REVFILE).buildEffective();
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild().addSource(REVFILE).buildEffective();
assertNotNull(result);
final Module moduleByName = result.getModules().iterator().next();
assertEquals("2015-06-07", moduleByName.getQNameModule().getRevision().get().toString());
assertNotNull(result);
final Module moduleByName = result.getModules().iterator().next();
assertEquals("2015-06-07", moduleByName.getQNameModule().getRevision().get().toString());
@Test
public void twoRevisionsTest() throws ReactorException {
@Test
public void twoRevisionsTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(TED_20130712, TED_20131021, IETF_TYPES)
.buildEffective();
assertNotNull(result);
.addSources(TED_20130712, TED_20131021, IETF_TYPES)
.buildEffective();
assertNotNull(result);
@Test
public void twoRevisionsTest2() throws ReactorException {
@Test
public void twoRevisionsTest2() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(NETWORK_TOPOLOGY_20130712, NETWORK_TOPOLOGY_20131021, IETF_TYPES)
.buildEffective();
assertNotNull(result);
.addSources(NETWORK_TOPOLOGY_20130712, NETWORK_TOPOLOGY_20131021, IETF_TYPES)
.buildEffective();
assertNotNull(result);
@Test
public void moreRevisionsListKeyTest() throws ReactorException {
@Test
public void moreRevisionsListKeyTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.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();
.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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class MustAndWhenStmtTest {
@Test
public void mustStmtTest() throws ReactorException {
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class MustAndWhenStmtTest {
@Test
public void mustStmtTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/must-when-stmt-test/must-test.yang"))
.buildEffective();
assertNotNull(result);
.addSource(sourceForResource("/must-when-stmt-test/must-test.yang"))
.buildEffective();
assertNotNull(result);
@Test
public void whenStmtTest() throws ReactorException {
@Test
public void whenStmtTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/must-when-stmt-test/when-test.yang"))
.buildEffective();
assertNotNull(result);
.addSource(sourceForResource("/must-when-stmt-test/when-test.yang"))
.buildEffective();
assertNotNull(result);
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class NotificationStmtTest {
@Test
public void notificationTest() throws ReactorException {
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class NotificationStmtTest {
@Test
public void notificationTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(sourceForResource("/model/baz.yang"), sourceForResource("/model/bar.yang"))
.buildEffective();
assertNotNull(result);
.addSources(sourceForResource("/model/baz.yang"), sourceForResource("/model/bar.yang"))
.buildEffective();
assertNotNull(result);
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class RpcStmtTest {
@Test
public void rpcTest() throws ReactorException {
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class RpcStmtTest {
@Test
public void rpcTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/model/baz.yang"))
.addSource(sourceForResource("/model/bar.yang"))
.addSource(sourceForResource("/rpc-stmt-test/foo.yang"))
.addSource(sourceForResource("/model/baz.yang"))
.addSource(sourceForResource("/model/bar.yang"))
.addSource(sourceForResource("/rpc-stmt-test/foo.yang"))
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinTextToDomTransformer;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinTextToDomTransformer;
public static SchemaContext parseYangSources(final StatementParserMode statementParserMode,
final Set<QName> supportedFeatures, final Collection<? extends StatementStreamSource> sources)
throws ReactorException {
public static SchemaContext parseYangSources(final StatementParserMode statementParserMode,
final Set<QName> supportedFeatures, final Collection<? extends StatementStreamSource> sources)
throws ReactorException {
- final BuildAction reactor = DefaultReactors.defaultReactor().newBuild(statementParserMode)
+ final BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild(statementParserMode)
.addSources(sources);
if (supportedFeatures != null) {
reactor.setSupportedFeatures(supportedFeatures);
.addSources(sources);
if (supportedFeatures != null) {
reactor.setSupportedFeatures(supportedFeatures);
private static SchemaContext parseYangSources(final StatementStreamSource[] yangSources,
final StatementStreamSource[] libSources, final Set<QName> supportedFeatures) throws ReactorException {
private static SchemaContext parseYangSources(final StatementStreamSource[] yangSources,
final StatementStreamSource[] libSources, final Set<QName> supportedFeatures) throws ReactorException {
- final BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ final BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild()
.addSources(yangSources).addLibSources(libSources);
if (supportedFeatures != null) {
reactor.setSupportedFeatures(supportedFeatures);
.addSources(yangSources).addLibSources(libSources);
if (supportedFeatures != null) {
reactor.setSupportedFeatures(supportedFeatures);
public static SchemaContext parseYinSources(final StatementParserMode statementParserMode,
final StatementStreamSource... sources) throws ReactorException {
public static SchemaContext parseYinSources(final StatementParserMode statementParserMode,
final StatementStreamSource... sources) throws ReactorException {
- return DefaultReactors.defaultReactor().newBuild(statementParserMode).addSources(sources).buildEffective();
+ return RFC7950Reactors.defaultReactor().newBuild(statementParserMode).addSources(sources).buildEffective();
}
public static Module findImportedModule(final SchemaContext context, final Module rootModule,
}
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinTextToDomTransformer;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinTextToDomTransformer;
public static SchemaContext loadModules(final URI resourceDirectory)
throws ReactorException, IOException, YangSyntaxErrorException {
public static SchemaContext loadModules(final URI resourceDirectory)
throws ReactorException, IOException, YangSyntaxErrorException {
- final BuildAction reactor = DefaultReactors.defaultReactor().newBuild();
+ final BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild();
File[] files = new File(resourceDirectory).listFiles();
for (File file : files) {
File[] files = new File(resourceDirectory).listFiles();
for (File file : files) {
public static SchemaContext loadModuleResources(final Class<?> refClass, final String... resourceNames)
throws IOException, ReactorException, YangSyntaxErrorException {
public static SchemaContext loadModuleResources(final Class<?> refClass, final String... resourceNames)
throws IOException, ReactorException, YangSyntaxErrorException {
- final BuildAction reactor = DefaultReactors.defaultReactor().newBuild();
+ final BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild();
for (String resourceName : resourceNames) {
reactor.addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource(refClass,
for (String resourceName : resourceNames) {
reactor.addSource(YangStatementStreamSource.create(YangTextSchemaSource.forResource(refClass,
public static SchemaContext loadYinModules(final URI resourceDirectory) throws ReactorException, SAXException,
IOException {
public static SchemaContext loadYinModules(final URI resourceDirectory) throws ReactorException, SAXException,
IOException {
- final BuildAction reactor = DefaultReactors.defaultReactor().newBuild();
+ final BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild();
for (File file : new File(resourceDirectory).listFiles()) {
reactor.addSource(YinStatementStreamSource.create(YinTextToDomTransformer.transformSource(
for (File file : new File(resourceDirectory).listFiles()) {
reactor.addSource(YinStatementStreamSource.create(YinTextToDomTransformer.transformSource(
public static Module loadYinModule(final YinTextSchemaSource source) throws ReactorException, SAXException,
IOException {
public static Module loadYinModule(final YinTextSchemaSource source) throws ReactorException, SAXException,
IOException {
- final SchemaContext ctx = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext ctx = RFC7950Reactors.defaultReactor().newBuild()
.addSource(YinStatementStreamSource.create(YinTextToDomTransformer.transformSource(source)))
.buildEffective();
return ctx.getModules().iterator().next();
.addSource(YinStatementStreamSource.create(YinTextToDomTransformer.transformSource(source)))
.buildEffective();
return ctx.getModules().iterator().next();
}
public static SchemaContext parseYangSources(final StatementStreamSource... sources) throws ReactorException {
}
public static SchemaContext parseYangSources(final StatementStreamSource... sources) throws ReactorException {
- return DefaultReactors.defaultReactor().newBuild().addSources(sources).buildEffective();
+ return RFC7950Reactors.defaultReactor().newBuild().addSources(sources).buildEffective();
}
public static SchemaContext parseYangSources(final File... files)
}
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class TypedefSubStmtsTest {
@Test
public void typedefSubStmtsTest() throws ReactorException {
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class TypedefSubStmtsTest {
@Test
public void typedefSubStmtsTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/typedef-substmts-test/typedef-substmts-test.yang"))
.buildEffective();
assertNotNull(result);
.addSource(sourceForResource("/typedef-substmts-test/typedef-substmts-test.yang"))
.buildEffective();
assertNotNull(result);
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.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.rfc7950.reactor.RFC7950Reactors;
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.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
@Test
public void testUnionWithExt() throws ReactorException {
@Test
public void testUnionWithExt() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.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"))
.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"))
@Test
public void testUnionWithBits() throws ReactorException {
@Test
public void testUnionWithBits() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/types/union-with-bits/union-bits-model.yang"))
.buildEffective();
assertNotNull(result);
.addSource(sourceForResource("/types/union-with-bits/union-bits-model.yang"))
.buildEffective();
assertNotNull(result);
@Test
public void testUnionInList() {
@Test
public void testUnionInList() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/types/union-in-list/unioninlisttest.yang"));
try {
.addSource(sourceForResource("/types/union-in-list/unioninlisttest.yang"));
try {
@Test
public void testYangData() throws Exception {
@Test
public void testYangData() throws Exception {
- final SchemaContext schemaContext = StmtTestUtils.parseYangSources(FOO_MODULE, IETF_RESTCONF_MODULE);
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSources(FOO_MODULE, IETF_RESTCONF_MODULE)
+ .buildEffective();
assertNotNull(schemaContext);
final Set<ExtensionDefinition> extensions = schemaContext.getExtensions();
assertNotNull(schemaContext);
final Set<ExtensionDefinition> extensions = schemaContext.getExtensions();
@Test
public void testConfigStatementBeingIgnoredInYangDataBody() throws Exception {
@Test
public void testConfigStatementBeingIgnoredInYangDataBody() throws Exception {
- final SchemaContext schemaContext = StmtTestUtils.parseYangSources(BAZ_MODULE, IETF_RESTCONF_MODULE);
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSources(BAZ_MODULE, IETF_RESTCONF_MODULE)
+ .buildEffective();
assertNotNull(schemaContext);
final Module baz = schemaContext.findModule("baz", REVISION).get();
assertNotNull(schemaContext);
final Module baz = schemaContext.findModule("baz", REVISION).get();
public void testYangDataBeingIgnored() throws Exception {
// yang-data statement is ignored if it does not appear as a top-level statement
// i.e., it will not appear in the final SchemaContext
public void testYangDataBeingIgnored() throws Exception {
// yang-data statement is ignored if it does not appear as a top-level statement
// i.e., it will not appear in the final SchemaContext
- final SchemaContext schemaContext = StmtTestUtils.parseYangSources(BAR_MODULE, IETF_RESTCONF_MODULE);
+ final SchemaContext schemaContext = DefaultReactors.defaultReactor().newBuild()
+ .addSources(BAR_MODULE, IETF_RESTCONF_MODULE)
+ .buildEffective();
assertNotNull(schemaContext);
final Module bar = schemaContext.findModule("bar", REVISION).get();
assertNotNull(schemaContext);
final Module bar = schemaContext.findModule("bar", REVISION).get();
@Test
public void testYangDataWithMissingTopLevelContainer() {
try {
@Test
public void testYangDataWithMissingTopLevelContainer() {
try {
- StmtTestUtils.parseYangSources(FOO_INVALID_1_MODULE, IETF_RESTCONF_MODULE);
+ DefaultReactors.defaultReactor().newBuild().addSources(FOO_INVALID_1_MODULE, IETF_RESTCONF_MODULE)
+ .buildEffective();
fail("Exception should have been thrown because of missing top-level container in yang-data statement.");
} catch (final ReactorException ex) {
final Throwable cause = ex.getCause();
fail("Exception should have been thrown because of missing top-level container in yang-data statement.");
} catch (final ReactorException ex) {
final Throwable cause = ex.getCause();
@Test
public void testYangDataWithTwoTopLevelContainers() {
try {
@Test
public void testYangDataWithTwoTopLevelContainers() {
try {
- StmtTestUtils.parseYangSources(FOO_INVALID_2_MODULE, IETF_RESTCONF_MODULE);
+ DefaultReactors.defaultReactor().newBuild().addSources(FOO_INVALID_2_MODULE, IETF_RESTCONF_MODULE)
+ .buildEffective();
fail("Exception should have been thrown because of two top-level containers in yang-data statement.");
} catch (final ReactorException ex) {
final Throwable cause = ex.getCause();
fail("Exception should have been thrown because of two top-level containers in yang-data statement.");
} catch (final ReactorException ex) {
final Throwable cause = ex.getCause();
@Test
public void testYangDataWithInvalidToplevelNode() {
try {
@Test
public void testYangDataWithInvalidToplevelNode() {
try {
- StmtTestUtils.parseYangSources(FOO_INVALID_3_MODULE, IETF_RESTCONF_MODULE);
+ DefaultReactors.defaultReactor().newBuild().addSources(FOO_INVALID_3_MODULE, IETF_RESTCONF_MODULE)
+ .buildEffective();
fail("Exception should have been thrown because of invalid top-level node in yang-data statement.");
} catch (final ReactorException ex) {
final Throwable cause = ex.getCause();
fail("Exception should have been thrown because of invalid top-level node in yang-data statement.");
} catch (final ReactorException ex) {
final Throwable cause = ex.getCause();
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
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.rfc7950.reactor.RFC7950Reactors;
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.EffectiveModelContext;
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.EffectiveModelContext;
@Test
public void readAndParseYangFileTestModel() throws ReactorException {
@Test
public void readAndParseYangFileTestModel() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(BAZ, FOO, BAR, SUBFOO)
.build();
assertNotNull(result);
.addSources(BAZ, FOO, BAR, SUBFOO)
.build();
assertNotNull(result);
@Test
public void readAndParseYangFileTestModel2() throws ReactorException {
@Test
public void readAndParseYangFileTestModel2() throws ReactorException {
- EffectiveModelContext result = DefaultReactors.defaultReactor().newBuild()
+ EffectiveModelContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(BAZ2, FOO2, BAR2, SUBFOO2)
.build();
assertNotNull(result);
.addSources(BAZ2, FOO2, BAR2, SUBFOO2)
.build();
assertNotNull(result);
@Test
public void readAndParseYangFileTest() throws ReactorException {
@Test
public void readAndParseYangFileTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(YANGFILE, SIMPLENODES, IMPORTEDYANGFILE, FOOBAR, EXTFILE, EXTUSE)
.buildEffective();
assertNotNull(result);
.addSources(YANGFILE, SIMPLENODES, IMPORTEDYANGFILE, FOOBAR, EXTFILE, EXTUSE)
.buildEffective();
assertNotNull(result);
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.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.rfc7950.reactor.RFC7950Reactors;
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.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
@Test
public void unknownStatementBetweenRevisionsTest() throws ReactorException {
@Test
public void unknownStatementBetweenRevisionsTest() throws ReactorException {
- final SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/yang-grammar-test/revisions-extension.yang"))
.addSource(sourceForResource("/yang-grammar-test/submodule-header-extension.yang"))
.buildEffective();
.addSource(sourceForResource("/yang-grammar-test/revisions-extension.yang"))
.addSource(sourceForResource("/yang-grammar-test/submodule-header-extension.yang"))
.buildEffective();
final StatementStreamSource yangFile3 = sourceForResource(
"/yang-grammar-test/stmtsep-in-statements-sub.yang");
final StatementStreamSource yangFile3 = sourceForResource(
"/yang-grammar-test/stmtsep-in-statements-sub.yang");
- final BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
+ final BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild()
.addSources(yangFile1, yangFile2, yangFile3);
// TODO: change test or create new module in order to respect new statement parser validations
try {
.addSources(yangFile1, yangFile2, yangFile3);
// TODO: change test or create new module in order to respect new statement parser validations
try {
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void testTypeFromContext() throws ReactorException {
@Test
public void testTypeFromContext() throws ReactorException {
- final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
.addSources(IETF)
.addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
.addSource(sourceForResource("/context-test/test1.yang"))
.addSources(IETF)
.addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
.addSource(sourceForResource("/context-test/test1.yang"))
@Test
public void testUsesFromContext() throws ReactorException {
@Test
public void testUsesFromContext() throws ReactorException {
- final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
.addSources(BAZ, FOO, BAR, SUBFOO, sourceForResource("/context-test/test2.yang"))
.buildEffective();
.addSources(BAZ, FOO, BAR, SUBFOO, sourceForResource("/context-test/test2.yang"))
.buildEffective();
@Test
public void testUsesRefineFromContext() throws ReactorException {
@Test
public void testUsesRefineFromContext() throws ReactorException {
- final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
.addSources(BAZ, FOO, BAR, SUBFOO, sourceForResource("/context-test/test2.yang"))
.buildEffective();
.addSources(BAZ, FOO, BAR, SUBFOO, sourceForResource("/context-test/test2.yang"))
.buildEffective();
@Test
public void testIdentity() throws ReactorException {
@Test
public void testIdentity() throws ReactorException {
- final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
.addSources(IETF)
.addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
.addSource(sourceForResource("/context-test/test3.yang"))
.addSources(IETF)
.addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
.addSource(sourceForResource("/context-test/test3.yang"))
@Test
public void testUnknownNodes() throws ReactorException {
@Test
public void testUnknownNodes() throws ReactorException {
- final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
.addSources(IETF)
.addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
.addSource(sourceForResource("/context-test/test3.yang"))
.addSources(IETF)
.addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
.addSource(sourceForResource("/context-test/test3.yang"))
@Test
public void testDeviation() throws ReactorException {
@Test
public void testDeviation() throws ReactorException {
- final SchemaContext context = DefaultReactors.defaultReactor().newBuild()
+ final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/model/bar.yang"))
.addSource(sourceForResource("/context-test/deviation-test.yang"))
.buildEffective();
.addSource(sourceForResource("/model/bar.yang"))
.addSource(sourceForResource("/context-test/deviation-test.yang"))
.buildEffective();
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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void readAndParseYangFileTest() throws ReactorException {
@Test
public void readAndParseYangFileTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(TYPEFILE1, TYPEFILE2, TYPEFILE3, TYPEFILE4)
.buildEffective();
assertNotNull(result);
.addSources(TYPEFILE1, TYPEFILE2, TYPEFILE3, TYPEFILE4)
.buildEffective();
assertNotNull(result);
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
@Test
public void readAndParseYangFileTest() throws ReactorException {
@Test
public void readAndParseYangFileTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(TYPEFILE1, TYPEFILE2, TYPEFILE3, FILE1, FILE2, FILE3, FILE4)
.buildEffective();
assertNotNull(result);
.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.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.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinTextToDomTransformer;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YinTextToDomTransformer;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
@Test
public void readAndParseYinFileTestModel() throws ReactorException {
@Test
public void readAndParseYinFileTestModel() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSources(YIN_FILE, EXT_FILE, EXT_USE_FILE)
.buildEffective();
assertNotNull(result);
.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 {
// parsing yin file whose import statement references a module which does not exist
@Test(expected = SomeModifiersUnresolvedException.class)
public void readAndParseInvalidYinFileTest() throws ReactorException {
- SchemaContext result = DefaultReactors.defaultReactor().newBuild()
+ SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
.addSource(INVALID_YIN_FILE)
.buildEffective();
assertNotNull(result);
.addSource(INVALID_YIN_FILE)
.buildEffective();
assertNotNull(result);
// parsing yin file with duplicate key name in a list statement
public void readAndParseInvalidYinFileTest2() {
// parsing yin file with duplicate key name in a list statement
public void readAndParseInvalidYinFileTest2() {
- BuildAction reactor = DefaultReactors.defaultReactor().newBuild()
- .addSource(INVALID_YIN_FILE_2);
+ BuildAction reactor = RFC7950Reactors.defaultReactor().newBuild().addSource(INVALID_YIN_FILE_2);
try {
reactor.buildEffective();
try {
reactor.buildEffective();