Fix UsesNode.getRefines() return

We are really interested in exposing the paths to refined nodes, letting
users to deal with locating them. This allows us to simplify
support for refine -- moving the EffectiveStatement implementation to
yang-model-ri and RefineStatementSupport to rfc7950.stmt.meta.

JIRA: YANGTOOLS-1518
Change-Id: Iad387335038bd5686e67e32873e78925ea1646c5
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/model/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/UsesNode.java b/model/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/UsesNode.java
index 761656bf528ded1a90e6b8e508b6d99a5b39452e..52ac85105a00dfe416860fdba7452bb36cfdfd90 100644 (file)
--- a/model/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/UsesNode.java
+++ b/model/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/UsesNode.java
@@ -7,10 +7,12 @@
  */
 package org.opendaylight.yangtools.yang.model.api;
 
+import com.google.common.collect.ImmutableSet;
 import java.util.Collection;
-import java.util.Map;
+import java.util.Set;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
+import org.opendaylight.yangtools.yang.model.api.stmt.RefineEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
 import org.opendaylight.yangtools.yang.model.api.stmt.UsesEffectiveStatement;
 
@@ -36,8 +38,11 @@ public interface UsesNode extends WhenConditionAware, WithStatus, CopyableNode,
     /**
      * Some of the properties of each node in the grouping can be refined with the "refine" statement.
      *
-     * @return Map, where key is schema node identifier of refined node and value is refined node.
+     * @return {@link Descendant} paths of {@code refine}d children.
      */
-    // FIXME: 7.0.0: expose only refined paths and let users deal with locating them
-    @NonNull Map<Descendant, SchemaNode> getRefines();
+    default @NonNull Set<Descendant> getRefines() {
+        return asEffectiveStatement().streamEffectiveSubstatements(RefineEffectiveStatement.class)
+            .map(RefineEffectiveStatement::argument)
+            .collect(ImmutableSet.toImmutableSet());
+    }
 }

diff --git a/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/EffectiveStatements.java b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/EffectiveStatements.java
index e9ca7fc01d90cbe645516d760213c5b64540e42a..5f60969c0db84665a5709c71f42708bc7ef9ffe6 100644 (file)
--- a/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/EffectiveStatements.java
+++ b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/EffectiveStatements.java
@@ -123,6 +123,8 @@ import org.opendaylight.yangtools.yang.model.api.stmt.RangeEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RefineEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateEffectiveStatement;
@@ -217,6 +219,7 @@ import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.EmptyYinElementEff
 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.ExtensionEffectiveStatementImpl;
 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.ImportEffectiveStatementImpl;
 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.NotificationEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RefineEffectiveStatementImpl;
 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularAnydataEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularAnyxmlEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff.RegularArgumentEffectiveStatement;
@@ -563,8 +566,7 @@ public final class EffectiveStatements {
 
     public static LeafEffectiveStatement copyLeaf(final LeafEffectiveStatement original, final QName argument,
             final int flags) {
-        if (original instanceof AbstractLeafEffectiveStatement) {
-            final var orig = (AbstractLeafEffectiveStatement) original;
+        if (original instanceof AbstractLeafEffectiveStatement orig) {
             return argument.equals(orig.getDeclared().argument()) ? new EmptyLeafEffectiveStatement(orig, flags)
                 : new RegularLeafEffectiveStatement(orig, argument, flags);
         } else if (original instanceof UndeclaredLeafEffectiveStatement) {
@@ -781,6 +783,12 @@ public final class EffectiveStatements {
             : new RegularReferenceEffectiveStatement(declared, substatements);
     }
 
+    public static RefineEffectiveStatement createRefine(final RefineStatement declared,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+        // Empty refine is exceedingly unlikely: let's be lazy and reuse the implementation
+        return new RefineEffectiveStatementImpl(declared, substatements);
+    }
+
     public static RevisionEffectiveStatement createRevision(final RevisionStatement declared,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         return substatements.isEmpty() ? new EmptyRevisionEffectiveStatement(declared)

diff --git a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/refine/RefineEffectiveStatementImpl.java b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/RefineEffectiveStatementImpl.java
similarity index 66%
rename from parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/refine/RefineEffectiveStatementImpl.java
rename to model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/RefineEffectiveStatementImpl.java
index 44a67e53e4fbd34623051982c129beee472c04df..0e4eca4a693a653f4696d384890f7c821f7ddea0 100644 (file)
--- a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/refine/RefineEffectiveStatementImpl.java
+++ b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/RefineEffectiveStatementImpl.java
@@ -5,13 +5,9 @@
  * 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.rfc7950.stmt.refine;
-
-import static java.util.Objects.requireNonNull;
+package org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff;
 
 import com.google.common.collect.ImmutableList;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.RefineEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
@@ -21,16 +17,8 @@ import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.D
 
 public final class RefineEffectiveStatementImpl extends WithSubstatements<Descendant, RefineStatement>
         implements RefineEffectiveStatement, DocumentedNodeMixin<Descendant, RefineStatement> {
-    private final @NonNull SchemaNode refineTargetNode;
-
-    RefineEffectiveStatementImpl(final RefineStatement declared,
-            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaNode refineTargetNode) {
+    public RefineEffectiveStatementImpl(final RefineStatement declared,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared, substatements);
-        this.refineTargetNode = requireNonNull(refineTargetNode);
-    }
-
-    // FIXME: 8.0.0: discover this through namespace population
-    public SchemaNode getRefineTargetNode() {
-        return refineTargetNode;
     }
 }

diff --git a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/reactor/RFC7950Reactors.java b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/reactor/RFC7950Reactors.java
index 6b30b0cf40b1f59cf0319758c8a04dd59a2cbb3a..88668de884a4bddf3f6a4ac2c8ee04a4ff7d7896 100644 (file)
--- a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/reactor/RFC7950Reactors.java
+++ b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/reactor/RFC7950Reactors.java
@@ -72,6 +72,7 @@ import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta.PrefixStatementS
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta.PresenceStatementSupport;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta.RangeStatementSupport;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta.ReferenceStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta.RefineStatementSupport;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta.RequireInstanceStatementSupport;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta.RevisionDateStatementSupport;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta.RevisionStatementSupport;
@@ -91,8 +92,6 @@ import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification.Notifica
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification.NotificationStatementRFC7950Support;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.path.PathStatementSupport;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern.PatternStatementSupport;
-import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine.RefineStatementSupport;
-import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine.RefineTargetNamespace;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule.SubmoduleStatementSupport;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.BaseTypeNamespace;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.TypeStatementRFC6020Support;
@@ -365,7 +364,6 @@ public final class RFC7950Reactors {
             .addSupport(AugmentImplicitHandlingNamespace.BEHAVIOUR)
             .addVersionSpecificSupport(VERSION_1, new AugmentStatementRFC6020Support(config))
             .addVersionSpecificSupport(VERSION_1_1, new AugmentStatementRFC7950Support(config))
-            .addSupport(RefineTargetNamespace.BEHAVIOUR)
             .addVersionSpecificSupport(VERSION_1, RefineStatementSupport.rfc6020Instance(config))
             .addVersionSpecificSupport(VERSION_1_1, RefineStatementSupport.rfc7950Instance(config))
             .addSupport(new FeatureStatementSupport(config))

diff --git a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/refine/RefineStatementSupport.java b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/meta/RefineStatementSupport.java
similarity index 90%
rename from parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/refine/RefineStatementSupport.java
rename to parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/meta/RefineStatementSupport.java
index d019a1047ca5f3aaf9a2634433ea60729903651c..778a1f7691dd1ecd346691bd01887fc47d4e3bc6 100644 (file)
--- a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/refine/RefineStatementSupport.java
+++ b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/meta/RefineStatementSupport.java
@@ -5,15 +5,11 @@
  * 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.rfc7950.stmt.refine;
-
-import static com.google.common.base.Verify.verifyNotNull;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.meta;
 
 import com.google.common.annotations.Beta;
 import com.google.common.collect.ImmutableList;
 import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.common.Empty;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@@ -23,6 +19,7 @@ import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
 import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatementDecorators;
 import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
+import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
 import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
 import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
@@ -115,9 +112,6 @@ public abstract sealed class RefineStatementSupport
     @Override
     protected final RefineEffectiveStatement createEffective(final Current<Descendant, RefineStatement> stmt,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
-        // Empty refine is exceedingly unlikely: let's be lazy and reuse the implementation
-        return new RefineEffectiveStatementImpl(stmt.declared(), substatements,
-            (SchemaNode) verifyNotNull(stmt.namespaceItem(RefineTargetNamespace.INSTANCE, Empty.value()))
-                .buildEffective());
+        return EffectiveStatements.createRefine(stmt.declared(), substatements);
     }
 }

diff --git a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/refine/RefineTargetNamespace.java b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/refine/RefineTargetNamespace.java
deleted file mode 100644 (file)
index 43719f2..0000000
--- a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/refine/RefineTargetNamespace.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine;
-
-import com.google.common.annotations.Beta;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.common.Empty;
-import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-
-@Beta
-public final class RefineTargetNamespace {
-    public static final @NonNull ParserNamespace<Empty, StmtContext<?, ?, ?>> INSTANCE =
-        new ParserNamespace<>("refineTarget");
-    public static final @NonNull NamespaceBehaviour<?, ?> BEHAVIOUR = NamespaceBehaviour.statementLocal(INSTANCE);
-
-    private RefineTargetNamespace() {
-        // Hidden on purpose
-    }
-}

diff --git a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/EmptyLocalUsesEffectiveStatement.java b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/EmptyLocalUsesEffectiveStatement.java
index 018a784f1d9f390e641a2a51cfe4ed109da88992..fe5ccf68c43f78ec771197e82601fbbc4161a2fe 100644 (file)
--- a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/EmptyLocalUsesEffectiveStatement.java
+++ b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/EmptyLocalUsesEffectiveStatement.java
@@ -9,16 +9,12 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.uses;
 
 import static java.util.Objects.requireNonNull;
 
-import com.google.common.collect.ImmutableMap;
 import java.util.Collection;
-import java.util.Map;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
 import org.opendaylight.yangtools.yang.model.api.stmt.UsesEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
 import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument;
@@ -69,9 +65,4 @@ class EmptyLocalUsesEffectiveStatement extends DefaultArgument<QName, UsesStatem
     public final Collection<? extends AugmentationSchemaNode> getAugmentations() {
         return filterEffectiveStatements(AugmentationSchemaNode.class);
     }
-
-    @Override
-    public Map<Descendant, SchemaNode> getRefines() {
-        return ImmutableMap.of();
-    }
 }

diff --git a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/FullCopiedUsesEffectiveStatement.java b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/FullCopiedUsesEffectiveStatement.java
index 00d64f78c9eb1c3988f43a94cfc5c0956fa9d073..9585f09161552c36fd95c0a14bd638c91bd3a9b1 100644 (file)
--- a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/FullCopiedUsesEffectiveStatement.java
+++ b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/FullCopiedUsesEffectiveStatement.java
@@ -8,41 +8,20 @@
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.uses;
 
 import com.google.common.collect.ImmutableList;
-import java.util.Map;
-import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
 import org.opendaylight.yangtools.yang.model.api.stmt.UsesEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
 
 /**
  * A full-blown instance of {@link UsesEffectiveStatement}. Used when the argument does not match the declared instance
  * and we also have a refine substatement.
- *
  */
 final class FullCopiedUsesEffectiveStatement extends SimpleCopiedUsesEffectiveStatement {
-    private volatile Map<Descendant, SchemaNode> refines;
-
     FullCopiedUsesEffectiveStatement(final UsesStatement declared, final QName argument,
             final GroupingDefinition sourceGrouping, final int flags,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared, argument, sourceGrouping, flags, substatements);
     }
-
-    @Override
-    public Map<Descendant, SchemaNode> getRefines() {
-        final Map<Descendant, SchemaNode> local;
-        return (local = refines) != null ? local : loadRefines();
-    }
-
-    private synchronized @NonNull Map<Descendant, SchemaNode> loadRefines() {
-        Map<Descendant, SchemaNode> local = refines;
-        if (local == null) {
-            refines = local = UsesStatementSupport.indexRefines(effectiveSubstatements());
-        }
-        return local;
-    }
 }

diff --git a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/RegularLocalUsesEffectiveStatement.java b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/RegularLocalUsesEffectiveStatement.java
index 3cfded9fb317b88a63333770247aeda471955c52..5271731c073e05c2667914fdcf0fa5535cbe2b86 100644 (file)
--- a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/RegularLocalUsesEffectiveStatement.java
+++ b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/RegularLocalUsesEffectiveStatement.java
@@ -8,12 +8,8 @@
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.uses;
 
 import com.google.common.collect.ImmutableList;
-import java.util.Map;
-import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
 import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
 
 /**
@@ -23,8 +19,6 @@ import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
 final class RegularLocalUsesEffectiveStatement extends EmptyLocalUsesEffectiveStatement {
     private final Object substatements;
 
-    private volatile Map<Descendant, SchemaNode> refines;
-
     RegularLocalUsesEffectiveStatement(final UsesStatement declared, final GroupingDefinition sourceGrouping,
             final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared, sourceGrouping, flags);
@@ -35,18 +29,4 @@ final class RegularLocalUsesEffectiveStatement extends EmptyLocalUsesEffectiveSt
     public ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
         return unmaskList(substatements);
     }
-
-    @Override
-    public Map<Descendant, SchemaNode> getRefines() {
-        final Map<Descendant, SchemaNode> local;
-        return (local = refines) != null ? local : loadRefines();
-    }
-
-    private synchronized @NonNull Map<Descendant, SchemaNode> loadRefines() {
-        Map<Descendant, SchemaNode> local = refines;
-        if (local == null) {
-            refines = local = UsesStatementSupport.indexRefines(effectiveSubstatements());
-        }
-        return local;
-    }
 }

diff --git a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/SimpleCopiedUsesEffectiveStatement.java b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/SimpleCopiedUsesEffectiveStatement.java
index 019f1c0bec5f3424bdeb653a98d1a249d4391650..42a82eb0cf09787ca823c53632a5d0cce14710bc 100644 (file)
--- a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/SimpleCopiedUsesEffectiveStatement.java
+++ b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/SimpleCopiedUsesEffectiveStatement.java
@@ -10,17 +10,13 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.uses;
 import static java.util.Objects.requireNonNull;
 
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
 import java.util.Collection;
-import java.util.Map;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.UsesNode;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
 import org.opendaylight.yangtools.yang.model.api.stmt.UsesEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
 import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultWithArgument;
@@ -76,9 +72,4 @@ class SimpleCopiedUsesEffectiveStatement extends DefaultWithArgument.WithSubstat
     public final UsesEffectiveStatement asEffectiveStatement() {
         return this;
     }
-
-    @Override
-    public Map<Descendant, SchemaNode> getRefines() {
-        return ImmutableMap.of();
-    }
 }

diff --git a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java
index e2c2628ae56d01f7875bfd2da5f3fb4869522d85..49291fc87bcd2e0064d6700beddc3be7649f3848 100644 (file)
--- a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java
+++ b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java
@@ -12,16 +12,12 @@ import static com.google.common.base.Verify.verifyNotNull;
 
 import com.google.common.base.VerifyException;
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.LinkedHashMap;
-import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.common.Empty;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@@ -38,8 +34,6 @@ import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
 import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
 import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.YangValidationBundles;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
-import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine.RefineEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine.RefineTargetNamespace;
 import org.opendaylight.yangtools.yang.parser.spi.ParserNamespaces;
 import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
 import org.opendaylight.yangtools.yang.parser.spi.meta.BoundStmtCtx;
@@ -161,17 +155,6 @@ public final class UsesStatementSupport
         return new FullCopiedUsesEffectiveStatement(declared, argument, sourceGrouping, flags, substatements);
     }
 
-    static @NonNull ImmutableMap<Descendant, SchemaNode> indexRefines(
-            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
-        final var refines = new LinkedHashMap<Descendant, SchemaNode>();
-        for (var effectiveStatement : substatements) {
-            if (effectiveStatement instanceof RefineEffectiveStatementImpl refineStmt) {
-                refines.put(refineStmt.argument(), refineStmt.getRefineTargetNode());
-            }
-        }
-        return ImmutableMap.copyOf(refines);
-    }
-
     /**
      * Copy statements from a grouping to a target node.
      *
@@ -297,10 +280,8 @@ public final class UsesStatementSupport
         }
 
         // Target is a prerequisite for the 'refine', hence if the target is not supported, the refine is not supported
-        // as well. Otherwise add a pointer to the target into refine's local namespace.
-        if (refineTargetCtx.isSupportedToBuildEffective() && refineTargetCtx.isSupportedByFeatures()) {
-            refineStmtCtx.addToNs(RefineTargetNamespace.INSTANCE, Empty.value(), refineTargetCtx);
-        } else {
+        // as well.
+        if (!refineTargetCtx.isSupportedToBuildEffective() || !refineTargetCtx.isSupportedByFeatures()) {
             refineStmtCtx.setUnsupported();
         }
     }

diff --git a/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingAndUsesStmtTest.java b/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingAndUsesStmtTest.java
index c1ec4458734e2dfef4d121fc2c4f491c3eafe9de..ec5b358f3a00f1eb1bfeff0fbac2cf61f203ab4b 100644 (file)
--- a/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingAndUsesStmtTest.java
+++ b/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingAndUsesStmtTest.java
@@ -11,7 +11,6 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import java.util.List;
-import java.util.Map;
 import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
@@ -21,7 +20,6 @@ import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.UsesNode;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
 import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
@@ -97,14 +95,11 @@ class GroupingAndUsesStmtTest extends AbstractYangTest {
         usesNode = container.getUses().iterator().next();
         assertEquals("target", usesNode.getSourceGrouping().getQName().getLocalName());
 
-        final Map<Descendant, SchemaNode> refines = usesNode.getRefines();
-        assertEquals(4, refines.size());
-
         assertEquals(List.of(
                 Descendant.of(QName.create(peer, "address")),
                 Descendant.of(QName.create(peer, "port")),
                 Descendant.of(QName.create(peer, "addresses")),
                 Descendant.of(QName.create(peer, "addresses"), QName.create(peer, "id"))),
-            List.copyOf(refines.keySet()));
+            List.copyOf(usesNode.getRefines()));
     }
 }

diff --git a/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingTest.java b/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingTest.java
index 8731ffa76d080a2fc4340204643373897e4c42be..f56b4d38f83d11e82043bd04458f46b426f51c1a 100644 (file)
--- a/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingTest.java
+++ b/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingTest.java
@@ -7,16 +7,16 @@
  */
 package org.opendaylight.yangtools.yang.stmt;
 
+import static org.junit.Assert.assertNull;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.google.common.collect.Iterables;
-import java.util.Map;
+import java.util.List;
 import java.util.Optional;
 import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.QName;
@@ -24,22 +24,14 @@ import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.common.Revision;
 import org.opendaylight.yangtools.yang.common.XMLNamespace;
 import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.MustDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
 import org.opendaylight.yangtools.yang.model.api.stmt.RefineEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
 import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
@@ -47,47 +39,32 @@ import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
 class GroupingTest extends AbstractModelTest {
     @Test
     void testRefine() {
-        final ContainerSchemaNode peer = (ContainerSchemaNode) FOO.getDataChildByName(fooQName("peer"));
-        final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(fooQName("destination"));
+        final var peer = assertInstanceOf(ContainerSchemaNode.class, FOO.dataChildByName(fooQName("peer")));
+        final var destination = assertInstanceOf(ContainerSchemaNode.class,
+            peer.dataChildByName(fooQName("destination")));
 
         final var usesNodes = destination.getUses();
         assertEquals(1, usesNodes.size());
-        final UsesNode usesNode = usesNodes.iterator().next();
-        final Map<Descendant, SchemaNode> refines = usesNode.getRefines();
+        final var usesNode = usesNodes.iterator().next();
+        final var refines = usesNode.getRefines();
         assertEquals(4, refines.size());
 
-        LeafSchemaNode refineLeaf = null;
-        ContainerSchemaNode refineContainer = null;
-        ListSchemaNode refineList = null;
-        LeafSchemaNode refineInnerLeaf = null;
-        for (final Map.Entry<Descendant, SchemaNode> entry : refines.entrySet()) {
-            final SchemaNode value = entry.getValue();
-            if ("address".equals(value.getQName().getLocalName())) {
-                refineLeaf = (LeafSchemaNode) destination.getDataChildByName(value.getQName());
-            } else if ("port".equals(value.getQName().getLocalName())) {
-                refineContainer = (ContainerSchemaNode) destination.getDataChildByName(value.getQName());
-            } else if ("addresses".equals(value.getQName().getLocalName())) {
-                refineList = (ListSchemaNode) destination.getDataChildByName(value.getQName());
-            }
-        }
-
-        assertNotNull(refineList);
-        for (final Map.Entry<Descendant, SchemaNode> entry : refines.entrySet()) {
-            final SchemaNode value = entry.getValue();
-            if ("id".equals(value.getQName().getLocalName())) {
-                refineInnerLeaf = (LeafSchemaNode) refineList.getDataChildByName(value.getQName());
-            }
-        }
+        assertEquals(List.of(
+            Descendant.of(fooQName("address")),
+            Descendant.of(fooQName("port")),
+            Descendant.of(fooQName("addresses")),
+            Descendant.of(fooQName("addresses"), fooQName("id"))),
+            List.copyOf(usesNode.getRefines()));
 
         // leaf address
-        assertNotNull(refineLeaf);
+        final var refineLeaf = assertInstanceOf(LeafSchemaNode.class, destination.dataChildByName(fooQName("address")));
         assertEquals(Optional.of("IP address of target node"), refineLeaf.getDescription());
         assertEquals(Optional.of("address reference added by refine"), refineLeaf.getReference());
         assertEquals(Optional.of(Boolean.FALSE), refineLeaf.effectiveConfig());
         assertFalse(refineLeaf.isMandatory());
         final var leafMustConstraints = refineLeaf.getMustConstraints();
         assertEquals(1, leafMustConstraints.size());
-        final MustDefinition leafMust = leafMustConstraints.iterator().next();
+        final var leafMust = leafMustConstraints.iterator().next();
         assertEquals("ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)", leafMust.getXpath().toString());
         assertEquals(0, refineLeaf.getUnknownSchemaNodes().size());
         assertEquals(1, usesNode.asEffectiveStatement()
@@ -95,7 +72,9 @@ class GroupingTest extends AbstractModelTest {
             .declaredSubstatements(UnrecognizedStatement.class).size());
 
         // container port
-        assertNotNull(refineContainer);
+        final var refineContainer = assertInstanceOf(ContainerSchemaNode.class,
+            destination.dataChildByName(fooQName("port")));
+
         final var mustConstraints = refineContainer.getMustConstraints();
         assertTrue(mustConstraints.isEmpty());
         assertEquals(Optional.of("description of port defined by refine"), refineContainer.getDescription());
@@ -103,17 +82,19 @@ class GroupingTest extends AbstractModelTest {
         assertEquals(Optional.of(Boolean.FALSE), refineContainer.effectiveConfig());
         assertTrue(refineContainer.isPresenceContainer());
 
-        // list addresses
+//      // list addresses
+        final var refineList = assertInstanceOf(ListSchemaNode.class,
+            destination.dataChildByName(fooQName("addresses")));
         assertEquals(Optional.of("description of addresses defined by refine"), refineList.getDescription());
         assertEquals(Optional.of("addresses reference added by refine"), refineList.getReference());
         assertEquals(Optional.of(Boolean.FALSE), refineList.effectiveConfig());
 
-        final ElementCountConstraint constraint = refineList.getElementCountConstraint().orElseThrow();
-        assertEquals((Object) 2, constraint.getMinElements());
+        final var constraint = refineList.getElementCountConstraint().orElseThrow();
+        assertEquals(2, constraint.getMinElements());
         assertNull(constraint.getMaxElements());
 
         // leaf id
-        assertNotNull(refineInnerLeaf);
+        final var refineInnerLeaf = assertInstanceOf(LeafSchemaNode.class, refineList.dataChildByName(fooQName("id")));
         assertEquals(Optional.of("id of address"), refineInnerLeaf.getDescription());
     }
 
@@ -121,7 +102,7 @@ class GroupingTest extends AbstractModelTest {
     void testGrouping() {
         final var groupings = BAZ.getGroupings();
         assertEquals(1, groupings.size());
-        final GroupingDefinition grouping = groupings.iterator().next();
+        final var grouping = groupings.iterator().next();
         final var children = grouping.getChildNodes();
         assertEquals(5, children.size());
     }
@@ -131,38 +112,38 @@ class GroupingTest extends AbstractModelTest {
         // suffix _u = added by uses
         // suffix _g = defined in grouping
 
-
         // get grouping
         final var groupings = BAZ.getGroupings();
         assertEquals(1, groupings.size());
-        final GroupingDefinition grouping = groupings.iterator().next();
+        final var grouping = groupings.iterator().next();
 
         // get node containing uses
-        final ContainerSchemaNode peer = (ContainerSchemaNode) FOO.getDataChildByName(fooQName("peer"));
-        final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(fooQName("destination"));
+        final var peer = assertInstanceOf(ContainerSchemaNode.class, FOO.dataChildByName(fooQName("peer")));
+        final var destination = assertInstanceOf(ContainerSchemaNode.class,
+            peer.dataChildByName(fooQName("destination")));
 
         // check uses
         final var uses = destination.getUses();
         assertEquals(1, uses.size());
 
         // check uses process
-        final AnyxmlSchemaNode data_u = (AnyxmlSchemaNode) destination.getDataChildByName(fooQName("data"));
+        final var data_u = assertInstanceOf(AnyxmlSchemaNode.class, destination.dataChildByName(fooQName("data")));
         assertTrue(data_u.isAddedByUses());
 
-        final AnyxmlSchemaNode data_g = (AnyxmlSchemaNode) grouping.getDataChildByName(bazQName("data"));
+        final var data_g = assertInstanceOf(AnyxmlSchemaNode.class, grouping.dataChildByName(bazQName("data")));
         assertFalse(data_g.isAddedByUses());
         assertNotEquals(data_u, data_g);
 
-        final ChoiceSchemaNode how_u = (ChoiceSchemaNode) destination.getDataChildByName(fooQName("how"));
+        final var how_u = assertInstanceOf(ChoiceSchemaNode.class, destination.dataChildByName(fooQName("how")));
         assertIsAddedByUses(how_u, true);
         assertEquals(2, how_u.getCases().size());
 
-        final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(bazQName("how"));
+        final var how_g = assertInstanceOf(ChoiceSchemaNode.class, grouping.dataChildByName(bazQName("how")));
         assertIsAddedByUses(how_g, false);
         assertEquals(2, how_g.getCases().size());
         assertNotEquals(how_u, how_g);
 
-        final LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName(fooQName("address"));
+        final var address_u = assertInstanceOf(LeafSchemaNode.class, destination.dataChildByName(fooQName("address")));
         assertEquals(Optional.of("1.2.3.4"), address_u.getType().getDefaultValue());
         assertEquals(Optional.of("IP address of target node"), address_u.getDescription());
         assertEquals(Optional.of("address reference added by refine"), address_u.getReference());
@@ -170,7 +151,7 @@ class GroupingTest extends AbstractModelTest {
         assertTrue(address_u.isAddedByUses());
         assertFalse(address_u.isMandatory());
 
-        final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(bazQName("address"));
+        final var address_g = assertInstanceOf(LeafSchemaNode.class, grouping.dataChildByName(bazQName("address")));
         assertFalse(address_g.isAddedByUses());
         assertEquals(Optional.empty(), address_g.getType().getDefaultValue());
         assertEquals(Optional.of("Target IP address"), address_g.getDescription());
@@ -179,17 +160,18 @@ class GroupingTest extends AbstractModelTest {
         assertTrue(address_g.isMandatory());
         assertNotEquals(address_u, address_g);
 
-        final ContainerSchemaNode port_u = (ContainerSchemaNode) destination.getDataChildByName(fooQName("port"));
+        final var port_u = assertInstanceOf(ContainerSchemaNode.class, destination.dataChildByName(fooQName("port")));
         assertIsAddedByUses(port_u, true);
 
-        final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(bazQName("port"));
+        final var port_g = assertInstanceOf(ContainerSchemaNode.class, grouping.dataChildByName(bazQName("port")));
         assertIsAddedByUses(port_g, false);
         assertNotEquals(port_u, port_g);
 
-        final ListSchemaNode addresses_u = (ListSchemaNode) destination.getDataChildByName(fooQName("addresses"));
+        final var addresses_u = assertInstanceOf(ListSchemaNode.class,
+            destination.dataChildByName(fooQName("addresses")));
         assertIsAddedByUses(addresses_u, true);
 
-        final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(bazQName("addresses"));
+        final var addresses_g = assertInstanceOf(ListSchemaNode.class, grouping.dataChildByName(bazQName("addresses")));
         assertIsAddedByUses(addresses_g, false);
         assertNotEquals(addresses_u, addresses_g);
 
@@ -200,7 +182,7 @@ class GroupingTest extends AbstractModelTest {
         // grouping defined in 'grouping' node
         final var groupings_g = grouping.getGroupings();
         assertEquals(1, groupings_g.size());
-        final GroupingDefinition grouping_g = groupings_g.iterator().next();
+        final var grouping_g = groupings_g.iterator().next();
         assertIsAddedByUses(grouping_g, false);
 
         assertEquals(0, destination.getUnknownSchemaNodes().size());
@@ -216,44 +198,44 @@ class GroupingTest extends AbstractModelTest {
         // get grouping
         final var groupings = BAZ.getGroupings();
         assertEquals(1, groupings.size());
-        final GroupingDefinition grouping = groupings.iterator().next();
+        final var grouping = groupings.iterator().next();
 
         // check uses
         final var uses = FOO.getUses();
         assertEquals(1, uses.size());
 
         // check uses process
-        final AnyxmlSchemaNode data_u = (AnyxmlSchemaNode) FOO.getDataChildByName(fooQName("data"));
+        final var data_u = assertInstanceOf(AnyxmlSchemaNode.class, FOO.dataChildByName(fooQName("data")));
         assertTrue(data_u.isAddedByUses());
 
-        final AnyxmlSchemaNode data_g = (AnyxmlSchemaNode) grouping.getDataChildByName(bazQName("data"));
+        final var data_g = assertInstanceOf(AnyxmlSchemaNode.class, grouping.dataChildByName(bazQName("data")));
         assertFalse(data_g.isAddedByUses());
         assertNotEquals(data_u, data_g);
 
-        final ChoiceSchemaNode how_u = (ChoiceSchemaNode) FOO.getDataChildByName(fooQName("how"));
+        final var how_u = assertInstanceOf(ChoiceSchemaNode.class, FOO.dataChildByName(fooQName("how")));
         assertIsAddedByUses(how_u, true);
         assertFalse(how_u.isAugmenting());
         final var cases_u = how_u.getCases();
         assertEquals(2, cases_u.size());
-        final CaseSchemaNode interval = how_u.findCaseNodes("interval").iterator().next();
+        final var interval = how_u.findCaseNodes("interval").iterator().next();
         assertFalse(interval.isAugmenting());
-        final LeafSchemaNode name = (LeafSchemaNode) interval.getDataChildByName(fooQName("name"));
+        final var name = assertInstanceOf(LeafSchemaNode.class, interval.dataChildByName(fooQName("name")));
         assertTrue(name.isAugmenting());
-        final LeafSchemaNode intervalLeaf = (LeafSchemaNode) interval.getDataChildByName(fooQName("interval"));
+        final var intervalLeaf = assertInstanceOf(LeafSchemaNode.class, interval.dataChildByName(fooQName("interval")));
         assertFalse(intervalLeaf.isAugmenting());
 
-        final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(bazQName("how"));
+        final var how_g = assertInstanceOf(ChoiceSchemaNode.class, grouping.dataChildByName(bazQName("how")));
         assertIsAddedByUses(how_g, false);
         assertNotEquals(how_u, how_g);
 
-        final LeafSchemaNode address_u = (LeafSchemaNode) FOO.getDataChildByName(fooQName("address"));
+        final var address_u = assertInstanceOf(LeafSchemaNode.class, FOO.dataChildByName(fooQName("address")));
         assertEquals(Optional.empty(), address_u.getType().getDefaultValue());
         assertEquals(Optional.of("Target IP address"), address_u.getDescription());
         assertFalse(address_u.getReference().isPresent());
         assertEquals(Optional.empty(), address_u.effectiveConfig());
         assertTrue(address_u.isAddedByUses());
 
-        final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(bazQName("address"));
+        final var address_g = assertInstanceOf(LeafSchemaNode.class, grouping.dataChildByName(bazQName("address")));
         assertFalse(address_g.isAddedByUses());
         assertEquals(Optional.empty(), address_g.getType().getDefaultValue());
         assertEquals(Optional.of("Target IP address"), address_g.getDescription());
@@ -261,17 +243,17 @@ class GroupingTest extends AbstractModelTest {
         assertEquals(Optional.empty(), address_g.effectiveConfig());
         assertNotEquals(address_u, address_g);
 
-        final ContainerSchemaNode port_u = (ContainerSchemaNode) FOO.getDataChildByName(fooQName("port"));
+        final var port_u = assertInstanceOf(ContainerSchemaNode.class, FOO.dataChildByName(fooQName("port")));
         assertIsAddedByUses(port_u, true);
 
-        final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(bazQName("port"));
+        final var port_g = assertInstanceOf(ContainerSchemaNode.class, grouping.dataChildByName(bazQName("port")));
         assertIsAddedByUses(port_g, false);
         assertNotEquals(port_u, port_g);
 
-        final ListSchemaNode addresses_u = (ListSchemaNode) FOO.getDataChildByName(fooQName("addresses"));
+        final var addresses_u = assertInstanceOf(ListSchemaNode.class, FOO.dataChildByName(fooQName("addresses")));
         assertIsAddedByUses(addresses_u, true);
 
-        final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(bazQName("addresses"));
+        final var addresses_g = assertInstanceOf(ListSchemaNode.class, grouping.dataChildByName(bazQName("addresses")));
         assertIsAddedByUses(addresses_g, false);
         assertNotEquals(addresses_u, addresses_g);
 
@@ -282,31 +264,31 @@ class GroupingTest extends AbstractModelTest {
         // grouping defined in 'grouping' node
         final var groupings_g = grouping.getGroupings();
         assertEquals(1, groupings_g.size());
-        final GroupingDefinition grouping_g = groupings_g.iterator().next();
+        final var grouping_g = groupings_g.iterator().next();
         assertIsAddedByUses(grouping_g, false);
 
         assertEquals(0, grouping.getUnknownSchemaNodes().size());
         assertEquals(1, grouping.asEffectiveStatement().getDeclared().declaredSubstatements(UnrecognizedStatement.class)
             .size());
 
-        final UsesNode un = uses.iterator().next();
+        final var un = uses.iterator().next();
         final var usesAugments = un.getAugmentations();
         assertEquals(1, usesAugments.size());
-        final AugmentationSchemaNode augment = usesAugments.iterator().next();
+        final var augment = usesAugments.iterator().next();
         assertEquals(Optional.of("inner augment"), augment.getDescription());
         final var children = augment.getChildNodes();
         assertEquals(1, children.size());
-        final LeafSchemaNode leaf = assertInstanceOf(LeafSchemaNode.class, children.iterator().next());
+        final var leaf = assertInstanceOf(LeafSchemaNode.class, children.iterator().next());
         assertEquals("name", leaf.getQName().getLocalName());
     }
 
     @Test
     void testCascadeUses() throws Exception {
-        final EffectiveModelContext loadModules = TestUtils.parseYangSource("/grouping-test/cascade-uses.yang");
+        final var loadModules = TestUtils.parseYangSource("/grouping-test/cascade-uses.yang");
         assertEquals(1, loadModules.getModules().size());
 
-        final Module testModule =  Iterables.getOnlyElement(loadModules.findModules("cascade-uses"));
-        final QNameModule namespace = testModule.getQNameModule();
+        final var testModule =  Iterables.getOnlyElement(loadModules.findModules("cascade-uses"));
+        final var namespace = testModule.getQNameModule();
         final var groupings = testModule.getGroupings();
 
         GroupingDefinition gu = null;
@@ -315,7 +297,7 @@ class GroupingTest extends AbstractModelTest {
         GroupingDefinition gy = null;
         GroupingDefinition gz = null;
         GroupingDefinition gzz = null;
-        for (final GroupingDefinition gd : groupings) {
+        for (var gd : groupings) {
             final String name = gd.getQName().getLocalName();
             switch (name) {
                 case "grouping-U":
@@ -347,18 +329,18 @@ class GroupingTest extends AbstractModelTest {
         assertNotNull(gz);
         assertNotNull(gzz);
 
-        final QNameModule expectedModule = QNameModule.create(XMLNamespace.of("urn:grouping:cascade-uses"),
+        final var expectedModule = QNameModule.create(XMLNamespace.of("urn:grouping:cascade-uses"),
             Revision.of("2013-07-18"));
 
         // grouping-U
         var childNodes = gu.getChildNodes();
         assertEquals(7, childNodes.size());
 
-        final LeafSchemaNode leafGroupingU = (LeafSchemaNode) gu.getDataChildByName(
-            QName.create(namespace, "leaf-grouping-U"));
+        final var leafGroupingU = assertInstanceOf(LeafSchemaNode.class, gu.dataChildByName(
+            QName.create(namespace, "leaf-grouping-U")));
         assertFalse(leafGroupingU.isAddedByUses());
 
-        for (final DataSchemaNode childNode : childNodes) {
+        for (var childNode : childNodes) {
             if (!childNode.getQName().equals(leafGroupingU.getQName())) {
                 assertIsAddedByUses(childNode, true);
             }
@@ -369,11 +351,11 @@ class GroupingTest extends AbstractModelTest {
         assertEquals(4, childNodes.size());
         LeafSchemaNode leafGroupingV = null;
         ContainerSchemaNode containerGroupingV = null;
-        for (final DataSchemaNode childNode : childNodes) {
+        for (var childNode : childNodes) {
             if ("leaf-grouping-V".equals(childNode.getQName().getLocalName())) {
-                leafGroupingV = (LeafSchemaNode) childNode;
+                leafGroupingV = assertInstanceOf(LeafSchemaNode.class, childNode);
             } else if ("container-grouping-V".equals(childNode.getQName().getLocalName())) {
-                containerGroupingV = (ContainerSchemaNode) childNode;
+                containerGroupingV = assertInstanceOf(ContainerSchemaNode.class, childNode);
             } else {
                 assertIsAddedByUses(childNode, true);
             }
@@ -387,17 +369,17 @@ class GroupingTest extends AbstractModelTest {
         assertEquals(QName.create(expectedModule, "container-grouping-V"), containerGroupingV.getQName());
         childNodes = containerGroupingV.getChildNodes();
         assertEquals(2, childNodes.size());
-        for (final DataSchemaNode childNode : childNodes) {
+        for (var childNode : childNodes) {
             assertIsAddedByUses(childNode, true);
         }
 
         // grouping-V/container-grouping-V/leaf-grouping-X
-        final LeafSchemaNode leafXinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(
-            QName.create(namespace, "leaf-grouping-X"));
+        final var leafXinContainerV = assertInstanceOf(LeafSchemaNode.class, containerGroupingV.dataChildByName(
+            QName.create(namespace, "leaf-grouping-X")));
         assertEquals(QName.create(expectedModule, "leaf-grouping-X"), leafXinContainerV.getQName());
         // grouping-V/container-grouping-V/leaf-grouping-Y
-        final LeafSchemaNode leafYinContainerV = (LeafSchemaNode) containerGroupingV.getDataChildByName(
-            QName.create(namespace, "leaf-grouping-Y"));
+        final var leafYinContainerV = assertInstanceOf(LeafSchemaNode.class, containerGroupingV.dataChildByName(
+            QName.create(namespace, "leaf-grouping-Y")));
         assertEquals(QName.create(expectedModule, "leaf-grouping-Y"), leafYinContainerV.getQName());
 
         // grouping-X
@@ -405,14 +387,14 @@ class GroupingTest extends AbstractModelTest {
         assertEquals(2, childNodes.size());
 
         // grouping-X/leaf-grouping-X
-        final LeafSchemaNode leafXinGX = (LeafSchemaNode) gx.getDataChildByName(
-            QName.create(namespace, "leaf-grouping-X"));
+        final var leafXinGX = assertInstanceOf(LeafSchemaNode.class, gx.dataChildByName(
+            QName.create(namespace, "leaf-grouping-X")));
         assertFalse(leafXinGX.isAddedByUses());
         assertEquals(QName.create(expectedModule, "leaf-grouping-X"), leafXinGX.getQName());
 
         // grouping-X/leaf-grouping-Y
-        final LeafSchemaNode leafYinGX = (LeafSchemaNode) gx.getDataChildByName(
-            QName.create(namespace, "leaf-grouping-Y"));
+        final var leafYinGX = assertInstanceOf(LeafSchemaNode.class, gx.dataChildByName(
+            QName.create(namespace, "leaf-grouping-Y")));
         assertTrue(leafYinGX.isAddedByUses());
         assertEquals(QName.create(expectedModule, "leaf-grouping-Y"), leafYinGX.getQName());
 
@@ -421,8 +403,8 @@ class GroupingTest extends AbstractModelTest {
         assertEquals(1, childNodes.size());
 
         // grouping-Y/leaf-grouping-Y
-        final LeafSchemaNode leafYinGY = (LeafSchemaNode) gy.getDataChildByName(
-            QName.create(namespace, "leaf-grouping-Y"));
+        final var leafYinGY = assertInstanceOf(LeafSchemaNode.class, gy.dataChildByName(
+            QName.create(namespace, "leaf-grouping-Y")));
         assertFalse(leafYinGY.isAddedByUses());
         assertEquals(QName.create(expectedModule, "leaf-grouping-Y"), leafYinGY.getQName());
 
@@ -431,8 +413,8 @@ class GroupingTest extends AbstractModelTest {
         assertEquals(1, childNodes.size());
 
         // grouping-Z/leaf-grouping-Z
-        final LeafSchemaNode leafZinGZ = (LeafSchemaNode) gz.getDataChildByName(
-            QName.create(namespace, "leaf-grouping-Z"));
+        final var leafZinGZ = assertInstanceOf(LeafSchemaNode.class, gz.dataChildByName(
+            QName.create(namespace, "leaf-grouping-Z")));
         assertFalse(leafZinGZ.isAddedByUses());
         assertEquals(QName.create(expectedModule, "leaf-grouping-Z"), leafZinGZ.getQName());
 
@@ -441,26 +423,27 @@ class GroupingTest extends AbstractModelTest {
         assertEquals(1, childNodes.size());
 
         // grouping-ZZ/leaf-grouping-ZZ
-        final LeafSchemaNode leafZZinGZZ = (LeafSchemaNode) gzz.getDataChildByName(
-            QName.create(namespace, "leaf-grouping-ZZ"));
+        final var leafZZinGZZ = assertInstanceOf(LeafSchemaNode.class, gzz.dataChildByName(
+            QName.create(namespace, "leaf-grouping-ZZ")));
         assertFalse(leafZZinGZZ.isAddedByUses());
         assertEquals(QName.create(expectedModule, "leaf-grouping-ZZ"), leafZZinGZZ.getQName());
     }
 
     @Test
     void testAddedByUsesLeafTypeQName() throws Exception {
-        final EffectiveModelContext loadModules = assertEffectiveModelDir("/added-by-uses-leaf-test");
+        final var loadModules = assertEffectiveModelDir("/added-by-uses-leaf-test");
         assertEquals(2, loadModules.getModules().size());
 
-        final Module foo = Iterables.getOnlyElement(loadModules.findModules("foo"));
-        final Module imp = Iterables.getOnlyElement(loadModules.findModules("import-module"));
+        final var foo = Iterables.getOnlyElement(loadModules.findModules("foo"));
+        final var imp = Iterables.getOnlyElement(loadModules.findModules("import-module"));
 
-        final LeafSchemaNode leaf = (LeafSchemaNode)
-            ((ContainerSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "my-container")))
-                .getDataChildByName(QName.create(foo.getQNameModule(), "my-leaf"));
+        final var leaf = assertInstanceOf(LeafSchemaNode.class,
+            assertInstanceOf(ContainerSchemaNode.class, foo.dataChildByName(
+                QName.create(foo.getQNameModule(), "my-container")))
+            .dataChildByName(QName.create(foo.getQNameModule(), "my-leaf")));
 
         TypeDefinition<?> impType = null;
-        for (final TypeDefinition<?> typeDefinition : imp.getTypeDefinitions()) {
+        for (var typeDefinition : imp.getTypeDefinitions()) {
             if (typeDefinition.getQName().getLocalName().equals("imp-type")) {
                 impType = typeDefinition;
                 break;
@@ -473,7 +456,7 @@ class GroupingTest extends AbstractModelTest {
 
     private static void assertIsAddedByUses(final GroupingDefinition node, final boolean expected) {
         assertEquals(expected, node.isAddedByUses());
-        for (DataSchemaNode child : node.getChildNodes()) {
+        for (var child : node.getChildNodes()) {
             assertIsAddedByUses(child, expected);
         }
     }
@@ -487,13 +470,12 @@ class GroupingTest extends AbstractModelTest {
      */
     private static void assertIsAddedByUses(final DataSchemaNode node, final boolean expected) {
         assertEquals(expected, node.isAddedByUses());
-        if (node instanceof DataNodeContainer) {
-            for (DataSchemaNode child : ((DataNodeContainer) node)
-                    .getChildNodes()) {
+        if (node instanceof DataNodeContainer container) {
+            for (var child : container.getChildNodes()) {
                 assertIsAddedByUses(child, expected);
             }
-        } else if (node instanceof ChoiceSchemaNode) {
-            for (CaseSchemaNode caseNode : ((ChoiceSchemaNode) node).getCases()) {
+        } else if (node instanceof ChoiceSchemaNode choice) {
+            for (var caseNode : choice.getCases()) {
                 assertIsAddedByUses(caseNode, expected);
             }
         }

diff --git a/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserWithContextTest.java b/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserWithContextTest.java
index dc420f3a1a39bf2c7e0b101bc33966855a1524b0..aadb340b12ac40db91ab1421c459ca0b345a5c52 100644 (file)
--- a/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserWithContextTest.java
+++ b/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserWithContextTest.java
@@ -17,7 +17,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
 
 import com.google.common.collect.Iterables;
-import com.google.common.collect.Range;
+import java.util.List;
 import java.util.Optional;
 import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.QName;
@@ -28,11 +28,12 @@ import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.DeviateKind;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.UsesNode;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
 import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
 import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
@@ -87,8 +88,8 @@ class YangParserWithContextTest {
             TestUtils.findTypedef(module.getTypeDefinitions(), "dscp-ext"));
         final var ranges = dscpExt.getRangeConstraint().orElseThrow().getAllowedRanges().asRanges();
         assertEquals(1, ranges.size());
-        final Range<?> range = ranges.iterator().next();
-        assertEquals(Uint8.valueOf(0), range.lowerEndpoint());
+        final var range = ranges.iterator().next();
+        assertEquals(Uint8.ZERO, range.lowerEndpoint());
         assertEquals(Uint8.valueOf(63), range.upperEndpoint());
     }
 
@@ -107,9 +108,9 @@ class YangParserWithContextTest {
 
         // get node containing uses
         final var peer = assertInstanceOf(ContainerSchemaNode.class,
-            testModule.getDataChildByName(QName.create(testModule.getQNameModule(), "peer")));
+            testModule.dataChildByName(QName.create(testModule.getQNameModule(), "peer")));
         final var destination = assertInstanceOf(ContainerSchemaNode.class,
-            peer.getDataChildByName(QName.create(testModule.getQNameModule(), "destination")));
+            peer.dataChildByName(QName.create(testModule.getQNameModule(), "destination")));
 
         // check uses
         final var uses = destination.getUses();
@@ -117,49 +118,49 @@ class YangParserWithContextTest {
 
         // check uses process
         final var data_u = assertInstanceOf(AnyxmlSchemaNode.class,
-            destination.getDataChildByName(QName.create(testModule.getQNameModule(), "data")));
+            destination.dataChildByName(QName.create(testModule.getQNameModule(), "data")));
         assertTrue(data_u.isAddedByUses());
 
         final var data_g = assertInstanceOf(AnyxmlSchemaNode.class,
-            grouping.getDataChildByName(QName.create(contextModule.getQNameModule(), "data")));
+            grouping.dataChildByName(QName.create(contextModule.getQNameModule(), "data")));
         assertFalse(data_g.isAddedByUses());
         assertNotEquals(data_u, data_g);
 
         final var how_u = assertInstanceOf(ChoiceSchemaNode.class,
-            destination.getDataChildByName(QName.create(testModule.getQNameModule(), "how")));
+            destination.dataChildByName(QName.create(testModule.getQNameModule(), "how")));
         assertTrue(how_u.isAddedByUses());
 
         final var how_g = assertInstanceOf(ChoiceSchemaNode.class,
-            grouping.getDataChildByName(QName.create(contextModule.getQNameModule(), "how")));
+            grouping.dataChildByName(QName.create(contextModule.getQNameModule(), "how")));
         assertFalse(how_g.isAddedByUses());
         assertNotEquals(how_u, how_g);
 
         final var address_u = assertInstanceOf(LeafSchemaNode.class,
-            destination.getDataChildByName(QName.create(testModule.getQNameModule(), "address")));
+            destination.dataChildByName(QName.create(testModule.getQNameModule(), "address")));
         assertTrue(address_u.isAddedByUses());
 
         final var address_g = assertInstanceOf(LeafSchemaNode.class,
-            grouping.getDataChildByName(QName.create(contextModule.getQNameModule(), "address")));
+            grouping.dataChildByName(QName.create(contextModule.getQNameModule(), "address")));
         assertFalse(address_g.isAddedByUses());
         assertNotEquals(address_u, address_g);
 
         final var port_u = assertInstanceOf(ContainerSchemaNode.class,
-            destination.getDataChildByName(QName.create(testModule.getQNameModule(), "port")));
+            destination.dataChildByName(QName.create(testModule.getQNameModule(), "port")));
         assertTrue(port_u.isAddedByUses());
 
         final var port_g = assertInstanceOf(ContainerSchemaNode.class,
-            grouping.getDataChildByName(QName.create(contextModule.getQNameModule(), "port")));
+            grouping.dataChildByName(QName.create(contextModule.getQNameModule(), "port")));
         assertNotNull(port_g);
         assertFalse(port_g.isAddedByUses());
         assertNotEquals(port_u, port_g);
 
-        final ListSchemaNode addresses_u = assertInstanceOf(ListSchemaNode.class,
-            destination.getDataChildByName(QName.create(testModule.getQNameModule(), "addresses")));
+        final var addresses_u = assertInstanceOf(ListSchemaNode.class,
+            destination.dataChildByName(QName.create(testModule.getQNameModule(), "addresses")));
         assertNotNull(addresses_u);
         assertTrue(addresses_u.isAddedByUses());
 
-        final ListSchemaNode addresses_g = assertInstanceOf(ListSchemaNode.class,
-            grouping.getDataChildByName(QName.create(contextModule.getQNameModule(), "addresses")));
+        final var addresses_g = assertInstanceOf(ListSchemaNode.class,
+            grouping.dataChildByName(QName.create(contextModule.getQNameModule(), "addresses")));
         assertNotNull(addresses_g);
         assertFalse(addresses_g.isAddedByUses());
         assertNotEquals(addresses_u, addresses_g);
@@ -183,9 +184,9 @@ class YangParserWithContextTest {
 
         final var module = context.findModule("test2", Revision.of("2013-06-18")).orElseThrow();
         final var peer = assertInstanceOf(ContainerSchemaNode.class,
-            module.getDataChildByName(QName.create(module.getQNameModule(), "peer")));
+            module.dataChildByName(QName.create(module.getQNameModule(), "peer")));
         final var destination = assertInstanceOf(ContainerSchemaNode.class,
-            peer.getDataChildByName(QName.create(module.getQNameModule(), "destination")));
+            peer.dataChildByName(QName.create(module.getQNameModule(), "destination")));
         final var usesNodes = destination.getUses();
         assertEquals(1, usesNodes.size());
         final UsesNode usesNode = usesNodes.iterator().next();
@@ -196,25 +197,15 @@ class YangParserWithContextTest {
 
         // test refine
         final var refines = usesNode.getRefines();
-        assertEquals(3, refines.size());
-
-        LeafSchemaNode refineLeaf = null;
-        ContainerSchemaNode refineContainer = null;
-        ListSchemaNode refineList = null;
-        for (var entry : refines.entrySet()) {
-            final SchemaNode value = entry.getValue();
-            if (value instanceof LeafSchemaNode leaf) {
-                refineLeaf = leaf;
-            } else if (value instanceof ContainerSchemaNode container) {
-                refineContainer = container;
-            } else if (value instanceof ListSchemaNode list) {
-                refineList = list;
-            }
-        }
+        assertEquals(List.of(
+            Descendant.of(QName.create(T2_NS, REV, "address")),
+            Descendant.of(QName.create(T2_NS, REV, "port")),
+            Descendant.of(QName.create(T2_NS, REV, "addresses"))),
+            List.copyOf(refines));
 
         // leaf address
-        assertNotNull(refineLeaf);
-        assertEquals("address", refineLeaf.getQName().getLocalName());
+        final var refineLeaf = assertInstanceOf(LeafSchemaNode.class,
+            destination.dataChildByName(QName.create(T2_NS, REV, "address")));
         assertEquals(Optional.of("description of address defined by refine"), refineLeaf.getDescription());
         assertEquals(Optional.of("address reference added by refine"), refineLeaf.getReference());
         assertEquals(Optional.of(Boolean.FALSE), refineLeaf.effectiveConfig());
@@ -225,7 +216,8 @@ class YangParserWithContextTest {
         assertEquals("ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)", leafMust.getXpath().toString());
 
         // container port
-        assertNotNull(refineContainer);
+        final var refineContainer = assertInstanceOf(ContainerSchemaNode.class,
+            destination.dataChildByName(QName.create(T2_NS, REV, "port")));
         final var mustConstraints = refineContainer.getMustConstraints();
         assertTrue(mustConstraints.isEmpty());
         assertEquals(Optional.of("description of port defined by refine"), refineContainer.getDescription());
@@ -234,13 +226,14 @@ class YangParserWithContextTest {
         assertTrue(refineContainer.isPresenceContainer());
 
         // list addresses
-        assertNotNull(refineList);
+        final var refineList = assertInstanceOf(ListSchemaNode.class,
+            destination.dataChildByName(QName.create(T2_NS, REV, "addresses")));
         assertEquals(Optional.of("description of addresses defined by refine"), refineList.getDescription());
         assertEquals(Optional.of("addresses reference added by refine"), refineList.getReference());
         assertEquals(Optional.of(Boolean.FALSE), refineList.effectiveConfig());
         final var constraint = refineList.getElementCountConstraint().orElseThrow();
-        assertEquals((Object) 2, constraint.getMinElements());
-        assertEquals((Object) 12, constraint.getMaxElements());
+        assertEquals(2, constraint.getMinElements());
+        assertEquals(12, constraint.getMaxElements());
     }
 
     @Test
@@ -278,7 +271,7 @@ class YangParserWithContextTest {
 
         final var module = context.findModule("test3", Revision.of("2013-06-18")).orElseThrow();
         final var network = assertInstanceOf(ContainerSchemaNode.class,
-            module.getDataChildByName(QName.create(module.getQNameModule(), "network")))
+            module.dataChildByName(QName.create(module.getQNameModule(), "network")))
             .asEffectiveStatement().getDeclared();
         final var unknownNodes = network.declaredSubstatements(UnrecognizedStatement.class);
         assertEquals(1, unknownNodes.size());
@@ -298,24 +291,25 @@ class YangParserWithContextTest {
             "/context-augment-test/test3.yang", "/context-augment-test/test4.yang")
             .findModules("test4").iterator().next();
         final var interfaces = assertInstanceOf(ContainerSchemaNode.class,
-            t4.getDataChildByName(QName.create(t4.getQNameModule(), "interfaces")));
+            t4.dataChildByName(QName.create(t4.getQNameModule(), "interfaces")));
         final var ifEntry = assertInstanceOf(ListSchemaNode.class,
-            interfaces.getDataChildByName(QName.create(t4.getQNameModule(), "ifEntry")));
+            interfaces.dataChildByName(QName.create(t4.getQNameModule(), "ifEntry")));
 
         // test augmentation process
         final var augmentHolder = assertInstanceOf(ContainerSchemaNode.class,
-            ifEntry.getDataChildByName(QName.create(T3_NS, REV, "augment-holder")));
-        final var ds0 = augmentHolder.getDataChildByName(QName.create(T2_NS, REV, "ds0ChannelNumber"));
-        final var interfaceId = augmentHolder.getDataChildByName(QName.create(T2_NS, REV, "interface-id"));
-        assertNotNull(interfaceId);
-        final var higherLayerIf = augmentHolder.getDataChildByName(QName.create(T2_NS, REV, "higher-layer-if"));
+            ifEntry.dataChildByName(QName.create(T3_NS, REV, "augment-holder")));
+        assertInstanceOf(LeafSchemaNode.class,
+            augmentHolder.dataChildByName(QName.create(T2_NS, REV, "ds0ChannelNumber")));
+        assertInstanceOf(LeafSchemaNode.class, augmentHolder.dataChildByName(QName.create(T2_NS, REV, "interface-id")));
+        assertInstanceOf(LeafListSchemaNode.class,
+            augmentHolder.dataChildByName(QName.create(T2_NS, REV, "higher-layer-if")));
         final var schemas = assertInstanceOf(ContainerSchemaNode.class,
-            augmentHolder.getDataChildByName(QName.create(T2_NS, REV, "schemas")));
-        assertNotNull(schemas.getDataChildByName(QName.create(T1_NS, REV, "id")));
+            augmentHolder.dataChildByName(QName.create(T2_NS, REV, "schemas")));
+        assertInstanceOf(LeafSchemaNode.class, schemas.dataChildByName(QName.create(T1_NS, REV, "id")));
 
         // test augment target after augmentation: check if it is same instance
         final var ifEntryAfterAugment = assertInstanceOf(ListSchemaNode.class,
-            interfaces.getDataChildByName(QName.create(t4.getQNameModule(), "ifEntry")));
+            interfaces.dataChildByName(QName.create(t4.getQNameModule(), "ifEntry")));
         assertSame(ifEntry, ifEntryAfterAugment);
     }
 
@@ -333,11 +327,13 @@ class YangParserWithContextTest {
 
         assertEquals(Optional.of("system/user ref"), dev.getReference());
 
-        final XMLNamespace expectedNS = XMLNamespace.of("urn:opendaylight.bar");
-        final Revision expectedRev = Revision.of("2013-07-03");
+        final var expectedNS = XMLNamespace.of("urn:opendaylight.bar");
+        final var expectedRev = Revision.of("2013-07-03");
 
-        assertEquals(Absolute.of(
-                QName.create(expectedNS, expectedRev, "interfaces"), QName.create(expectedNS, expectedRev, "ifEntry")),
+        assertEquals(
+            Absolute.of(
+                QName.create(expectedNS, expectedRev, "interfaces"),
+                QName.create(expectedNS, expectedRev, "ifEntry")),
             dev.getTargetPath());
         assertEquals(DeviateKind.ADD, dev.getDeviates().iterator().next().getDeviateType());
     }