From 54bae2b71afa7d58ce98154b21e2ce1882f53411 Mon Sep 17 00:00:00 2001 From: Peter Kajsa Date: Thu, 23 Mar 2017 17:12:33 +0100 Subject: [PATCH] Bug 7038 - Rework 'type decimal64' lookup Fix of hack in SourceSpecificContext, which attempts to lookup specific complex types by considering only a QName's localName and routes it via BUILTIN_TYPE_SUPPORTS to specific statement support. This solution introduces argument specific statement sub-definitions. If a StatementSupport has some argument specific sub-supports, processing of a statement is routed to appropriate sub-support based on given statement argument. Change-Id: I602c0a919107a633f594a4393299f3f6623bd1c5 Signed-off-by: Peter Kajsa --- .../spi/meta/AbstractStatementSupport.java | 14 ++++ .../parser/spi/meta/StatementSupport.java | 18 +++++ .../stmt/reactor/SourceSpecificContext.java | 65 ++++--------------- .../reactor/StatementDefinitionContext.java | 26 ++++++++ .../stmt/rfc6020/TypeStatementImpl.java | 23 +++++++ .../stmt/rfc6020/YangInferencePipeline.java | 4 +- .../rfc7950/TypeStatementRfc7950Support.java | 37 +++++++++++ .../yangtools/yang/stmt/Bug7038Test.java | 41 ++++++++++++ .../src/test/resources/bugs/bug7038/bar.yang | 8 +++ .../src/test/resources/bugs/bug7038/foo.yang | 8 +++ .../resources/bugs/bug7038/yang10/foo.yang | 17 +++++ .../resources/bugs/bug7038/yang11/foo.yang | 17 +++++ 12 files changed, 223 insertions(+), 55 deletions(-) create mode 100644 yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/TypeStatementRfc7950Support.java create mode 100644 yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug7038Test.java create mode 100644 yang/yang-parser-impl/src/test/resources/bugs/bug7038/bar.yang create mode 100644 yang/yang-parser-impl/src/test/resources/bugs/bug7038/foo.yang create mode 100644 yang/yang-parser-impl/src/test/resources/bugs/bug7038/yang10/foo.yang create mode 100644 yang/yang-parser-impl/src/test/resources/bugs/bug7038/yang11/foo.yang diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java index 4f5c6b3a41..ab535769fc 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java @@ -141,6 +141,20 @@ public abstract class AbstractStatementSupport return getPublicView().isArgumentYinElement(); } + @Override + public boolean hasArgumentSpecificSupports() { + // Most of statement supports don't have any argument specific + // supports, so return 'false'. + return false; + } + + @Override + public StatementSupport getSupportSpecificForArgument(final String argument) { + // Most of statement supports don't have any argument specific + // supports, so return null. + return null; + } + /** * Returns corresponding substatement validator of a statement support * diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StatementSupport.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StatementSupport.java index 4ccffedb2c..9eeeefc80c 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StatementSupport.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StatementSupport.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.spi.meta; import java.util.Optional; +import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; @@ -161,4 +162,21 @@ public interface StatementSupport, E extends E * @throws SourceException when an inconsistency is detected. */ void onFullDefinitionDeclared(StmtContext.Mutable stmt); + + /** + * Returns true if this support has argument specific supports. + */ + boolean hasArgumentSpecificSupports(); + + /** + * If this support has argument specific supports, the method returns + * support specific for given argument (e.g. type statement support need to + * be specialized based on its argument), otherwise returns null. + * + * @param argument + * argument of statement + * @return statement support specific for supplied argument or null + */ + @Nullable + StatementSupport getSupportSpecificForArgument(String argument); } \ No newline at end of file diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java index cfbd93377c..ee72425c42 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java @@ -11,9 +11,7 @@ import com.google.common.base.Preconditions; import com.google.common.base.Verify; import com.google.common.collect.HashMultimap; import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableTable; import com.google.common.collect.Multimap; -import com.google.common.collect.Table; import java.net.URI; import java.util.ArrayList; import java.util.Collection; @@ -27,10 +25,8 @@ import javax.annotation.Nullable; import org.opendaylight.yangtools.concepts.Mutable; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.QNameModule; -import org.opendaylight.yangtools.yang.common.YangConstants; import org.opendaylight.yangtools.yang.common.YangVersion; import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier; -import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace; @@ -58,19 +54,9 @@ import org.opendaylight.yangtools.yang.parser.spi.source.QNameToStatementDefinit import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference; import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.BitsSpecificationImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Decimal64SpecificationImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.EnumSpecificationImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.IdentityRefSpecificationImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.InstanceIdentifierSpecificationImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.LeafrefSpecificationImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ModelDefinedStatementDefinition; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.UnionSpecificationImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.UnknownStatementImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils; -import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.IdentityrefSpecificationRfc7950Support; -import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.LeafrefSpecificationRfc7950Support; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -83,21 +69,6 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh } private static final Logger LOG = LoggerFactory.getLogger(SourceSpecificContext.class); - private static final Table> BUILTIN_TYPE_SUPPORTS = - ImmutableTable.>builder() - .put(YangVersion.VERSION_1, TypeUtils.DECIMAL64, new Decimal64SpecificationImpl.Definition()) - .put(YangVersion.VERSION_1, TypeUtils.UNION, new UnionSpecificationImpl.Definition()) - .put(YangVersion.VERSION_1, TypeUtils.ENUMERATION, new EnumSpecificationImpl.Definition()) - .put(YangVersion.VERSION_1, TypeUtils.LEAF_REF, new LeafrefSpecificationImpl.Definition()) - .put(YangVersion.VERSION_1_1, TypeUtils.LEAF_REF, new LeafrefSpecificationRfc7950Support()) - .put(YangVersion.VERSION_1, TypeUtils.BITS, new BitsSpecificationImpl.Definition()) - .put(YangVersion.VERSION_1, TypeUtils.IDENTITY_REF, new IdentityRefSpecificationImpl.Definition()) - .put(YangVersion.VERSION_1_1, TypeUtils.IDENTITY_REF, new IdentityrefSpecificationRfc7950Support()) - .put(YangVersion.VERSION_1, TypeUtils.INSTANCE_IDENTIFIER, new InstanceIdentifierSpecificationImpl.Definition()) - .build(); - - private static final QName TYPE = YangStmtMapping.TYPE.getStatementName(); - private final Multimap modifiers = HashMultimap.create(); private final QNameToStatementDefinitionMap qNameToStmtDefMap = new QNameToStatementDefinitionMap(); private final PrefixToModuleMap prefixToModuleMap = new PrefixToModuleMap(); @@ -128,7 +99,7 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh } StatementContextBase createDeclaredChild(final StatementContextBase current, final int childId, - QName name, final String argument, final StatementSourceReference ref) { + final QName name, final String argument, final StatementSourceReference ref) { if (current != null) { // Fast path: we are entering a statement which was emitted in previous phase StatementContextBase existing = current.lookupSubstatement(childId); @@ -140,24 +111,11 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh } } - // FIXME: BUG-7038: Refactor/clean up this special case - if (TYPE.equals(name)) { - SourceException.throwIfNull(argument, ref, "Type statement requires an argument"); - if (TypeUtils.isYangTypeBodyStmtString(argument)) { - name = QName.create(YangConstants.RFC6020_YIN_MODULE, argument); - } else { - name = QName.create(YangConstants.RFC6020_YIN_MODULE, TYPE.getLocalName()); - } - } - StatementDefinitionContext def = currentContext.getStatementDefinition(getRootVersion(), name); if (def == null) { final StatementSupport extension = qNameToStmtDefMap.get(name); if (extension != null) { def = new StatementDefinitionContext<>(extension); - } else { - // type-body-stmts - def = resolveTypeBodyStmts(name.getLocalName(), getRootVersion()); } } else if (current != null && current.definition().getRepresentingClass().equals(UnknownStatementImpl.class)) { /* @@ -180,6 +138,16 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh SourceException.throwIf(argument != null, ref, "Statement %s does not take argument", name); } + /* + * If the current statement definition has argument specific + * sub-definitions, get argument specific sub-definition based on given + * argument (e.g. type statement need to be specialized based on its + * argument). + */ + if (def.hasArgumentSpecificSubDefinitions()) { + def = def.getSubDefinitionSpecificForArgument(argument); + } + if (current != null) { return current.createSubstatement(childId, def, ref, argument); } @@ -411,17 +379,6 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh } } - private static StatementDefinitionContext resolveTypeBodyStmts(final String typeArgument, - final YangVersion version) { - StatementSupport support = BUILTIN_TYPE_SUPPORTS.get(version, typeArgument); - - if (support == null) { - support = BUILTIN_TYPE_SUPPORTS.get(YangVersion.VERSION_1, typeArgument); - } - - return support == null ? null : new StatementDefinitionContext<>(support); - } - private PrefixToModule preLinkagePrefixes() { final PrefixToModuleMap preLinkagePrefixes = new PrefixToModuleMap(true); final Map prefixToNamespaceMap = getAllFromLocalStorage(ImpPrefixToNamespace.class); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementDefinitionContext.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementDefinitionContext.java index c1a1d2581a..2db65cf6cb 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementDefinitionContext.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementDefinitionContext.java @@ -10,7 +10,10 @@ package org.opendaylight.yangtools.yang.parser.stmt.reactor; import com.google.common.base.MoreObjects; import com.google.common.base.MoreObjects.ToStringHelper; import com.google.common.base.Preconditions; +import java.util.HashMap; +import java.util.Map; import java.util.Optional; +import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -25,9 +28,11 @@ import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReferenc public class StatementDefinitionContext, E extends EffectiveStatement> { private final StatementSupport support; + private final Map> argumentSpecificSubDefinitions; public StatementDefinitionContext(final StatementSupport support) { this.support = Preconditions.checkNotNull(support); + this.argumentSpecificSubDefinitions = support.hasArgumentSpecificSupports() ? new HashMap<>() : null; } public StatementFactory getFactory() { @@ -96,4 +101,25 @@ public class StatementDefinitionContext, E ext protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) { return toStringHelper.add("statement", getStatementName()); } + + @Nonnull + public StatementDefinitionContext getSubDefinitionSpecificForArgument(final String argument) { + if (!hasArgumentSpecificSubDefinitions()) { + return this; + } + + StatementDefinitionContext potential = argumentSpecificSubDefinitions.get(argument); + if (potential == null) { + final StatementSupport argumentSpecificSupport = support.getSupportSpecificForArgument(argument); + potential = argumentSpecificSupport != null ? new StatementDefinitionContext<>(argumentSpecificSupport) + : this; + argumentSpecificSubDefinitions.put(argument, potential); + } + + return potential; + } + + public boolean hasArgumentSpecificSubDefinitions() { + return support.hasArgumentSpecificSupports(); + } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java index 97326b64cd..1525a5d119 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java @@ -8,7 +8,9 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020; import com.google.common.base.Verify; +import com.google.common.collect.ImmutableMap; import java.util.Collection; +import java.util.Map; import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; @@ -40,6 +42,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder; import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction; import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite; import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase; +import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable; import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; @@ -83,6 +86,16 @@ public class TypeStatementImpl extends AbstractDeclaredStatement extends AbstractStatementSupport> { + private static final Map> ARGUMENT_SPECIFIC_SUPPORTS = ImmutableMap + .> builder() + .put(TypeUtils.DECIMAL64, new Decimal64SpecificationImpl.Definition()) + .put(TypeUtils.UNION, new UnionSpecificationImpl.Definition()) + .put(TypeUtils.ENUMERATION, new EnumSpecificationImpl.Definition()) + .put(TypeUtils.LEAF_REF, new LeafrefSpecificationImpl.Definition()) + .put(TypeUtils.BITS, new BitsSpecificationImpl.Definition()) + .put(TypeUtils.IDENTITY_REF, new IdentityRefSpecificationImpl.Definition()) + .put(TypeUtils.INSTANCE_IDENTIFIER, new InstanceIdentifierSpecificationImpl.Definition()).build(); + public Definition() { super(YangStmtMapping.TYPE); } @@ -229,6 +242,16 @@ public class TypeStatementImpl extends AbstractDeclaredStatement protected SubstatementValidator getSubstatementValidator() { return SUBSTATEMENT_VALIDATOR; } + + @Override + public boolean hasArgumentSpecificSupports() { + return !ARGUMENT_SPECIFIC_SUPPORTS.isEmpty(); + } + + @Override + public StatementSupport getSupportSpecificForArgument(final String argument) { + return ARGUMENT_SPECIFIC_SUPPORTS.get(argument); + } } @Nonnull diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/YangInferencePipeline.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/YangInferencePipeline.java index e7c5828a3e..b43e4bc8bf 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/YangInferencePipeline.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/YangInferencePipeline.java @@ -84,6 +84,7 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.PatternStatementRfc79 import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.RefineStatementRfc7950Support; import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.RpcStatementRfc7950Support; import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.SubmoduleStatementRfc7950Support; +import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.TypeStatementRfc7950Support; public final class YangInferencePipeline { public static final Set SUPPORTED_VERSIONS = Sets.immutableEnumSet(VERSION_1, VERSION_1_1); @@ -161,7 +162,8 @@ public final class YangInferencePipeline { .addSupport(global(IdentityNamespace.class)) .addSupport(new DefaultStatementImpl.Definition()) .addSupport(new StatusStatementImpl.Definition()) - .addSupport(new TypeStatementImpl.Definition()) + .addVersionSpecificSupport(VERSION_1, new TypeStatementImpl.Definition()) + .addVersionSpecificSupport(VERSION_1_1, new TypeStatementRfc7950Support()) .addSupport(new UnitsStatementImpl.Definition()) .addSupport(new RequireInstanceStatementImpl.Definition()) .addVersionSpecificSupport(VERSION_1, new BitStatementImpl.Definition()) diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/TypeStatementRfc7950Support.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/TypeStatementRfc7950Support.java new file mode 100644 index 0000000000..25127b79f8 --- /dev/null +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/TypeStatementRfc7950Support.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2017 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.stmt.rfc7950; + +import com.google.common.annotations.Beta; +import com.google.common.collect.ImmutableMap; +import java.util.Map; +import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport; +import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeStatementImpl; +import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils; + +/** + * Class providing necessary support for processing YANG 1.1 Type statement. + */ +@Beta +public final class TypeStatementRfc7950Support extends TypeStatementImpl.Definition { + private static final Map> ARGUMENT_SPECIFIC_SUPPORTS = ImmutableMap + .> builder() + .put(TypeUtils.LEAF_REF, new LeafrefSpecificationRfc7950Support()) + .put(TypeUtils.IDENTITY_REF, new IdentityrefSpecificationRfc7950Support()).build(); + + @Override + public boolean hasArgumentSpecificSupports() { + return !ARGUMENT_SPECIFIC_SUPPORTS.isEmpty() || super.hasArgumentSpecificSupports(); + } + + @Override + public StatementSupport getSupportSpecificForArgument(final String argument) { + final StatementSupport potential = ARGUMENT_SPECIFIC_SUPPORTS.get(argument); + return potential != null ? potential : super.getSupportSpecificForArgument(argument); + } +} diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug7038Test.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug7038Test.java new file mode 100644 index 0000000000..1143db41ae --- /dev/null +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug7038Test.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2017 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.yangtools.yang.stmt; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException; + +public class Bug7038Test { + @Test + public void unknownNodeTest() throws Exception { + final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug7038"); + assertNotNull(context); + assertEquals(1, context.getUnknownSchemaNodes().size()); + } + + @Test + public void testYang11() throws Exception { + final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug7038/yang11"); + assertNotNull(context); + } + + @Test + public void testYang10() throws Exception { + try { + StmtTestUtils.parseYangSources("/bugs/bug7038/yang10"); + } catch (final SomeModifiersUnresolvedException e) { + assertTrue(e.getCause().getMessage().startsWith("REQUIRE_INSTANCE is not valid for TYPE")); + } + } +} diff --git a/yang/yang-parser-impl/src/test/resources/bugs/bug7038/bar.yang b/yang/yang-parser-impl/src/test/resources/bugs/bug7038/bar.yang new file mode 100644 index 0000000000..fa6f4841b8 --- /dev/null +++ b/yang/yang-parser-impl/src/test/resources/bugs/bug7038/bar.yang @@ -0,0 +1,8 @@ +module bar { + namespace bar; + prefix bar; + + import foo { prefix decimal64; revision-date 1970-01-01; } + + decimal64:decimal64 decimal64; +} diff --git a/yang/yang-parser-impl/src/test/resources/bugs/bug7038/foo.yang b/yang/yang-parser-impl/src/test/resources/bugs/bug7038/foo.yang new file mode 100644 index 0000000000..7ffabf5283 --- /dev/null +++ b/yang/yang-parser-impl/src/test/resources/bugs/bug7038/foo.yang @@ -0,0 +1,8 @@ +module foo { + namespace foo; + prefix foo; + + extension decimal64 { + argument arg; + } +} diff --git a/yang/yang-parser-impl/src/test/resources/bugs/bug7038/yang10/foo.yang b/yang/yang-parser-impl/src/test/resources/bugs/bug7038/yang10/foo.yang new file mode 100644 index 0000000000..c40e633723 --- /dev/null +++ b/yang/yang-parser-impl/src/test/resources/bugs/bug7038/yang10/foo.yang @@ -0,0 +1,17 @@ +module foo { + namespace foo; + prefix foo; + yang-version 1; + + container root { + leaf my-leafref { + type leafref { + path "../target"; + require-instance false; + } + } + leaf target { + type string; + } + } +} diff --git a/yang/yang-parser-impl/src/test/resources/bugs/bug7038/yang11/foo.yang b/yang/yang-parser-impl/src/test/resources/bugs/bug7038/yang11/foo.yang new file mode 100644 index 0000000000..ee77e86687 --- /dev/null +++ b/yang/yang-parser-impl/src/test/resources/bugs/bug7038/yang11/foo.yang @@ -0,0 +1,17 @@ +module foo { + namespace foo; + prefix foo; + yang-version 1.1; + + container root { + leaf my-leafref { + type leafref { + path "../target"; + require-instance false; + } + } + leaf target { + type string; + } + } +} -- 2.36.6