diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/LocationInfo.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/LocationInfo.java
index 0e1f4c1..9997264 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/LocationInfo.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/LocationInfo.java
@@ -59,7 +59,7 @@
     String getFileName();
 
     /**
-     * Sets YANG file name
+     * Sets YANG file name.
      *
      * @param name YANG file name
      */
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangContainer.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangContainer.java
index 608e27d..66f0190 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangContainer.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangContainer.java
@@ -432,7 +432,8 @@
             for (YangLeaf leaf : leaves) {
                 if (leaf.isConfig()) {
                     throw new DataModelException("If a container has \"config\" set to \"false\", no node underneath " +
-                                                         "it can have \"config\" set to \"true\"." + getName() + " in " +
+                                                         "it can have \"config\" set to \"true\"." +
+                                                         getName() + " in " +
                                                          getLineNumber() + " at " +
                                                          getCharPosition() +
                                                          " in " + getFileName() + "\"");
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangLeafList.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangLeafList.java
index 93a0683..cba5d06 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangLeafList.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangLeafList.java
@@ -534,7 +534,7 @@
     }
 
     /**
-     * Retrieve the name of leaf list
+     * Retrieve the name of leaf list.
      *
      * @return leaf list name
      */
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangList.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangList.java
index ab01879..7b7032b 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangList.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangList.java
@@ -650,7 +650,8 @@
             for (YangLeafList leafList : leafLists) {
                 if (leafList.isConfig()) {
                     throw new DataModelException("If a list has \"config\" set to \"false\", no node underneath " +
-                                                         "it can have \"config\" set to \"true\"." + getName() + " in " +
+                                                         "it can have \"config\" set to \"true\"." +
+                                                         getName() + " in " +
                                                          getLineNumber() + " at " +
                                                          getCharPosition() +
                                                          " in " + getFileName() + "\"");
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangNodeType.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangNodeType.java
index 994f197..6e7a787 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangNodeType.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangNodeType.java
@@ -115,7 +115,7 @@
     IDENTITYREF_NODE,
 
     /**
-     * Deviation node
+     * Deviation node.
      */
     DEVIATION_NODE
 }
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/javadatamodel/JavaFileInfo.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/javadatamodel/JavaFileInfo.java
index 284378b..5ce4732 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/javadatamodel/JavaFileInfo.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/javadatamodel/JavaFileInfo.java
@@ -38,7 +38,7 @@
     protected String pkg;
 
     /**
-     * Java attribute name;
+     * Java attribute name.
      */
     protected String javaAttributeName;
 
diff --git a/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangLinkerUtils.java b/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangLinkerUtils.java
index 7783328..c2a3aaa 100644
--- a/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangLinkerUtils.java
+++ b/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangLinkerUtils.java
@@ -112,7 +112,8 @@
     }
 
     /**
-     * Detects collision between target nodes leaf/leaf-list or child node with augmented leaf/leaf-list or child node.
+     * Detects collision between target nodes leaf/leaf-list or child node with
+     * augmented leaf/leaf-list or child node.
      *
      * @param targetNode target node
      * @param augment    augment node
@@ -357,8 +358,8 @@
     }
 
     /**
-     * Detects collision between target nodes and its all leaf/leaf-list or child node with augmented leaf/leaf-list or
-     * child node.
+     * Detects collision between target nodes and its all leaf/leaf-list or child
+     * node with augmented leaf/leaf-list or child node.
      *
      * @param targetNode target node
      * @param augment    augment node
@@ -442,8 +443,8 @@
             return nodeIdentifier;
         } else {
             throw new LinkerException("YANG file error : " +
-                                              getYangConstructType(yangConstruct) + " name " + nodeIdentifierString +
-                                              " is not valid.");
+                                              getYangConstructType(yangConstruct) + " name " +
+                                              nodeIdentifierString + " is not valid.");
         }
     }
 
@@ -637,7 +638,8 @@
                     // Add resolution information to the list
                     YangResolutionInfoImpl resolutionInfo =
                             new YangResolutionInfoImpl<YangIdentityRef>(identityRef, (YangNode) leavesHolder,
-                                                                        identityRef.getLineNumber(), identityRef.getCharPosition());
+                                                                        identityRef.getLineNumber(),
+                                                                        identityRef.getCharPosition());
                     try {
                         addResolutionInfo(resolutionInfo);
                     } catch (DataModelException e) {
@@ -670,7 +672,8 @@
                     // Add resolution information to the list
                     YangResolutionInfoImpl resolutionInfo =
                             new YangResolutionInfoImpl<YangIdentityRef>(identityRef, (YangNode) leavesHolder,
-                                                                        identityRef.getLineNumber(), identityRef.getCharPosition());
+                                                                        identityRef.getLineNumber(),
+                                                                        identityRef.getCharPosition());
                     try {
                         addResolutionInfo(resolutionInfo);
                     } catch (DataModelException e) {
diff --git a/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangResolutionInfoImpl.java b/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangResolutionInfoImpl.java
index a4590ca..fb71e43 100644
--- a/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangResolutionInfoImpl.java
+++ b/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangResolutionInfoImpl.java
@@ -253,9 +253,7 @@
                     if (resolvable.getResolvableStatus() == UNRESOLVED) {
                         // If current entity is still not resolved, then
                         // linking/resolution has failed.
-                        DataModelException ex =
-                                new DataModelException
-                                        (getErrorInfoForLinker(resolvable));
+                        DataModelException ex = new DataModelException(getErrorInfoForLinker(resolvable));
                         ex.setLine(getLineNumber());
                         ex.setCharPosition(getCharPosition());
                         throw ex;
@@ -778,8 +776,7 @@
             throws DataModelException {
         T entity = getCurEntityToResolveFromStack();
         if (entity instanceof YangType) {
-            return node.getName().contentEquals(((YangType<?>) entity)
-                                                        .getDataTypeName());
+            return node.getName().contentEquals(((YangType<?>) entity).getDataTypeName());
         }
         if (entity instanceof YangUses) {
             return node.getName().contentEquals(((YangUses) entity).getName());
@@ -788,15 +785,14 @@
             return isFeatureDefinedInNode(node);
         }
         if (entity instanceof YangBase) {
-            return node.getName().contentEquals(((
-                    YangBase) entity).getBaseIdentifier().getName());
+            return node.getName().contentEquals(((YangBase) entity).getBaseIdentifier().getName());
         }
         if (entity instanceof YangIdentityRef) {
             return node.getName().contentEquals(((YangIdentityRef) entity).getName());
         }
-        throw new DataModelException(getErrorMsg(
-                INVALID_RESOLVED_ENTITY, node.getName(), node.getLineNumber(),
-                node.getCharPosition(), node.getFileName()));
+        throw new DataModelException(getErrorMsg(INVALID_RESOLVED_ENTITY, node.getName(),
+                                                 node.getLineNumber(), node.getCharPosition(),
+                                                 node.getFileName()));
     }
 
     private boolean isFeatureDefinedInNode(YangNode node) {
@@ -828,8 +824,7 @@
             throws DataModelException {
         T entity = getCurEntityToResolveFromStack();
         if (entity instanceof YangType) {
-            YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) ((
-                    YangType<?>) entity).getDataTypeExtendedInfo();
+            YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) ((YangType<?>) entity).getDataTypeExtendedInfo();
             derivedInfo.setReferredTypeDef((YangTypeDef) refNode);
         } else if (entity instanceof YangUses) {
             ((YangUses) entity).setRefGroup((YangGrouping) refNode);
diff --git a/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangXpathLinker.java b/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangXpathLinker.java
index 1579bf1..3cb3a85 100644
--- a/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangXpathLinker.java
+++ b/compiler/base/linker/src/main/java/org/onosproject/yang/compiler/linker/impl/YangXpathLinker.java
@@ -187,9 +187,8 @@
      * @return target node
      */
     private YangNode getTargetNodeWhenPathSizeIsOne(List<YangAtomicPath> paths) {
-        if (paths.get(0).getNodeIdentifier().getPrefix() != null
-                && !paths.get(0).getNodeIdentifier().getPrefix().equals
-                (getRootsPrefix(rootNode))) {
+        if (paths.get(0).getNodeIdentifier().getPrefix() != null &&
+                !paths.get(0).getNodeIdentifier().getPrefix().equals(getRootsPrefix(rootNode))) {
             return getImportedNode(rootNode, paths.get(0).getNodeIdentifier());
         }
         return rootNode;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/antlrgencode/GeneratedYangListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/antlrgencode/GeneratedYangListener.java
index ff319df..070cd23 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/antlrgencode/GeneratedYangListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/antlrgencode/GeneratedYangListener.java
@@ -20,142 +20,7 @@
 
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.AnyxmlStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.AppDataStructureContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.AppDataStructureStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.AppExtendedStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ArgumentBodyContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ArgumentStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.AugmentContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.AugmentStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.BaseStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.BelongstoStatementBodyContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.BelongstoStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.BitBodyStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.BitStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.BitsSpecificationContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.BodyStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.CaseStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ChoiceStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.CommonStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.CompilerAnnotationBodyStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.CompilerAnnotationStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ConfigContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ConfigStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ContactStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ContainerStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DataDefStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DataStructureKeyStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DateArgumentStringContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.Decimal64SpecificationContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DefaultStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DescriptionStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DeviateAddStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DeviateDeleteStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DeviateNotSupportedStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DeviateReplaceStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DeviationContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DeviationStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.EnumSpecificationContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.EnumStatementBodyContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.EnumStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ErrorAppTagStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ErrorMessageStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ExtendedNameContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ExtensionBodyContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ExtensionStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.FeatureBodyContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.FeatureStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.FractionContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.FractionDigitStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.GroupingStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.IdentifierContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.IdentityBodyContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.IdentityStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.IdentityrefSpecificationContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.IfFeatureStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ImportStatementBodyContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ImportStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.IncludeStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.InputStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.InstanceIdentifierSpecificationContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.KeyContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.KeyStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.LeafListStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.LeafStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.LeafrefSpecificationContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.LengthContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.LengthStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.LinkageStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ListStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.MandatoryContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.MandatoryStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.MaxElementsStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.MaxValueContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.MetaStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.MinElementsStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.MinValueContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ModuleBodyContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ModuleHeaderStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ModuleStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.MustStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.NamespaceStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.NotificationStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.NumericalRestrictionsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.OrderedByContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.OrderedByStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.OrganizationStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.OutputStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PathContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PathStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PatternStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PositionContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PositionStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PrefixStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PresenceStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RangeContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RangeStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ReferenceStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RefineAnyxmlStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RefineCaseStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RefineChoiceStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RefineContainerStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RefineContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RefineLeafListStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RefineLeafStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RefineListStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RefineStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RequireInstanceContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RequireInstanceStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RevisionDateStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RevisionStatementBodyContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RevisionStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RevisionStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RpcStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ShortCaseStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.StatusContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.StatusStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.StringContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.StringRestrictionsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.SubModuleStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.SubmoduleBodyContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.SubmoduleHeaderStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.TypeBodyStatementsContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.TypeStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.TypedefStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.UnionSpecificationContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.UniqueContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.UniqueStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.UnitsStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.UsesStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ValueContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ValueStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.VersionContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.WhenStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.YangConstructContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.YangVersionStatementContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.YangfileContext;
-import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.YinElementStatementContext;
+import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.*;
 
 /**
  * Represents ANTLR interfaces to be implemented by listener to traverse the parse tree.
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/TreeWalkListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/TreeWalkListener.java
index babe61e..e6be5d4 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/TreeWalkListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/TreeWalkListener.java
@@ -1125,7 +1125,8 @@
 
     @Override
     public void enterOrderedByStatement(OrderedByStatementContext ctx) {
-        ListenerUtil.handleUnsupportedYangConstruct(YangConstructType.ORDERED_BY_DATA, ctx, UtilConstants.CURRENTLY_UNSUPPORTED, getFileName());
+        ListenerUtil.handleUnsupportedYangConstruct(YangConstructType.ORDERED_BY_DATA, ctx,
+                                                    UtilConstants.CURRENTLY_UNSUPPORTED, getFileName());
     }
 
     @Override
@@ -1312,7 +1313,8 @@
     @Override
     public void enterAnyxmlStatement(AnyxmlStatementContext ctx) {
         increaseUnsupportedYangConstructDepth();
-        ListenerUtil.handleUnsupportedYangConstruct(YangConstructType.ANYXML_DATA, ctx, UtilConstants.UNSUPPORTED_YANG_CONSTRUCT, getFileName());
+        ListenerUtil.handleUnsupportedYangConstruct(YangConstructType.ANYXML_DATA, ctx,
+                                                    UtilConstants.UNSUPPORTED_YANG_CONSTRUCT, getFileName());
     }
 
     @Override
@@ -1333,7 +1335,8 @@
     @Override
     public void enterRefineStatement(RefineStatementContext ctx) {
         increaseUnsupportedYangConstructDepth();
-        ListenerUtil.handleUnsupportedYangConstruct(YangConstructType.REFINE_DATA, ctx, UtilConstants.UNSUPPORTED_YANG_CONSTRUCT, getFileName());
+        ListenerUtil.handleUnsupportedYangConstruct(YangConstructType.REFINE_DATA, ctx,
+                                                    UtilConstants.UNSUPPORTED_YANG_CONSTRUCT, getFileName());
     }
 
     @Override
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AppDataStructureListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AppDataStructureListener.java
index 931122f..26c5ebd 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AppDataStructureListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AppDataStructureListener.java
@@ -22,10 +22,6 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation;
 
 import static org.onosproject.yang.compiler.datamodel.YangDataStructure.getDataStructureType;
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.APP_DATA_STRUCTURE;
@@ -33,9 +29,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidPrefix;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AppExtendedNameListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AppExtendedNameListener.java
index 24fc9c1..b04fc0e 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AppExtendedNameListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AppExtendedNameListener.java
@@ -22,10 +22,6 @@
 import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.APP_EXTENDED_NAME_DATA;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ArgumentListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ArgumentListener.java
index 7da7699..bc3525b 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ArgumentListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ArgumentListener.java
@@ -20,10 +20,6 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.ARGUMENT_DATA;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ArgumentStatementContext;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AugmentListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AugmentListener.java
index 77f5ca3..c3658ca 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AugmentListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/AugmentListener.java
@@ -28,34 +28,20 @@
 import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.AugmentStatementContext;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.utils.UtilConstants;
 
 import java.util.List;
 
 import static org.onosproject.yang.compiler.datamodel.utils.DataModelUtils.addResolutionInfo;
 import static org.onosproject.yang.compiler.datamodel.utils.GeneratedLanguage.JAVA_GENERATION;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.AUGMENT_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.CASE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DATA_DEF_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DESCRIPTION_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.REFERENCE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.STATUS_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.WHEN_DATA;
+import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector.detectCollidingChildUtil;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getPrefixRemovedName;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidAbsoluteSchemaNodeId;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.removeQuotesAndHandleConcat;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityEitherOne;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityMaxOne;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.*;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.*;
 import static org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory.getYangAugmentNode;
 import static org.onosproject.yang.compiler.utils.UtilConstants.EMPTY_STRING;
 
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BaseListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BaseListener.java
index ac4975f..9579f61 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BaseListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BaseListener.java
@@ -21,12 +21,10 @@
 import org.onosproject.yang.compiler.datamodel.YangNode;
 import org.onosproject.yang.compiler.datamodel.YangNodeIdentifier;
 import org.onosproject.yang.compiler.datamodel.exceptions.DataModelException;
-import org.onosproject.yang.compiler.datamodel.utils.DataModelUtils;
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.linker.impl.YangResolutionInfoImpl;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.DataModelUtils.addResolutionInfo;
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.BASE_DATA;
@@ -35,9 +33,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidNodeIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
@@ -118,7 +114,8 @@
             addResolutionInfo(resolutionInfo);
         } catch (DataModelException e) {
             throw new ParserException(constructExtendedListenerErrorMessage(UNHANDLED_PARSED_DATA,
-                                                                            BASE_DATA, ctx.string().getText(), EXIT, e.getMessage()));
+                                                                            BASE_DATA, ctx.string().getText(),
+                                                                            EXIT, e.getMessage()));
         }
     }
 }
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BelongsToListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BelongsToListener.java
index 277f2e5..ac37aa7 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BelongsToListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BelongsToListener.java
@@ -21,18 +21,13 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.BELONGS_TO_DATA;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.BelongstoStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BitListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BitListener.java
index c1c0046..61c9374 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BitListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BitListener.java
@@ -68,11 +68,6 @@
 import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation;
 
 import java.util.Map;
 
@@ -81,10 +76,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_CONTENT;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BitsListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BitsListener.java
index c037aae..4553ea5 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BitsListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/BitsListener.java
@@ -116,7 +116,8 @@
                 // TODO typedef, union, deviate.
                 default:
                     throw new ParserException(constructListenerErrorMessage(INVALID_HOLDER, TYPE_DATA,
-                                                                            ((YangType<?>) typeData).getDataTypeName(), ENTRY));
+                                                                            ((YangType<?>) typeData).getDataTypeName(),
+                                                                            ENTRY));
             }
             listener.getParsedDataStack().push(typeData);
             listener.getParsedDataStack().push(bitsNode);
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/CaseListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/CaseListener.java
index 1ae7cbb..5802bf6 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/CaseListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/CaseListener.java
@@ -25,27 +25,15 @@
 import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation;
 
 import static org.onosproject.yang.compiler.datamodel.utils.GeneratedLanguage.JAVA_GENERATION;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.CASE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DESCRIPTION_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.REFERENCE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.STATUS_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.WHEN_DATA;
+import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector.detectCollidingChildUtil;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityMaxOne;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ChoiceListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ChoiceListener.java
index cc078bf..1b0761d 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ChoiceListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ChoiceListener.java
@@ -32,35 +32,18 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.GeneratedLanguage.JAVA_GENERATION;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.CHOICE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.CONFIG_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DEFAULT_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DESCRIPTION_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.MANDATORY_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.REFERENCE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.STATUS_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.WHEN_DATA;
+import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.*;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ChoiceStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector.detectCollidingChildUtil;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_CONTENT;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.getParentNodeConfig;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityMaxOne;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.*;
 import static org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory.getYangChoiceNode;
 
 /*
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/CompilerAnnotationListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/CompilerAnnotationListener.java
index 22a68f7..d081801 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/CompilerAnnotationListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/CompilerAnnotationListener.java
@@ -22,13 +22,10 @@
 import org.onosproject.yang.compiler.datamodel.YangNode;
 import org.onosproject.yang.compiler.datamodel.YangSubModule;
 import org.onosproject.yang.compiler.datamodel.exceptions.DataModelException;
-import org.onosproject.yang.compiler.datamodel.utils.DataModelUtils;
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.linker.impl.YangResolutionInfoImpl;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import java.util.List;
 
@@ -39,13 +36,8 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidAbsoluteSchemaNodeId;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidPrefix;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.removeQuotesAndHandleConcat;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
 /*
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DataStructureKeyListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DataStructureKeyListener.java
index eed8185..f2e75fb 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DataStructureKeyListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DataStructureKeyListener.java
@@ -20,8 +20,6 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.KEY_DATA;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.DataStructureKeyStatementContext;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64Listener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64Listener.java
index 5ebd7f1..0ff1cf1 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64Listener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64Listener.java
@@ -72,7 +72,6 @@
 import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.Decimal64SpecificationContext;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DECIMAL64_DATA;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateAddListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateAddListener.java
index 1e78332..f535a73 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateAddListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateAddListener.java
@@ -28,9 +28,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
 
@@ -118,9 +116,8 @@
         if (listener.getParsedDataStack().peek() instanceof YangDeviateAdd) {
             listener.getParsedDataStack().pop();
         } else {
-            throw new ParserException(constructListenerErrorMessage
-                                              (MISSING_CURRENT_HOLDER, DEVIATE_ADD,
-                                               null, EXIT));
+            throw new ParserException(constructListenerErrorMessage(MISSING_CURRENT_HOLDER, DEVIATE_ADD,
+                                                                    null, EXIT));
         }
     }
 }
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateDeleteListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateDeleteListener.java
index 2c84791..a36abd7 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateDeleteListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateDeleteListener.java
@@ -28,9 +28,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
 /*
@@ -113,9 +111,8 @@
         if (listener.getParsedDataStack().peek() instanceof YangDeviateDelete) {
             listener.getParsedDataStack().pop();
         } else {
-            throw new ParserException(constructListenerErrorMessage
-                                              (MISSING_CURRENT_HOLDER, DEVIATE_DELETE,
-                                               null, EXIT));
+            throw new ParserException(constructListenerErrorMessage(MISSING_CURRENT_HOLDER, DEVIATE_DELETE,
+                                                                    null, EXIT));
         }
     }
 }
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateReplaceListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateReplaceListener.java
index 962aa60..d9f4e3a 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateReplaceListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviateReplaceListener.java
@@ -27,9 +27,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
 /*
@@ -92,11 +90,8 @@
             curNode.addDeviateReplace(deviationReplace);
             listener.getParsedDataStack().push(deviationReplace);
         } else {
-            throw new ParserException(constructListenerErrorMessage
-                                              (INVALID_HOLDER,
-                                               DEVIATE_REPLACE,
-                                               null,
-                                               ENTRY));
+            throw new ParserException(constructListenerErrorMessage(INVALID_HOLDER, DEVIATE_REPLACE,
+                                                                    null, ENTRY));
         }
     }
 
@@ -117,9 +112,8 @@
         if (listener.getParsedDataStack().peek() instanceof YangDeviateReplace) {
             listener.getParsedDataStack().pop();
         } else {
-            throw new ParserException(constructListenerErrorMessage
-                                              (MISSING_CURRENT_HOLDER, DEVIATE_REPLACE,
-                                               null, EXIT));
+            throw new ParserException(constructListenerErrorMessage(MISSING_CURRENT_HOLDER, DEVIATE_REPLACE,
+                                                                    null, EXIT));
         }
     }
 }
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviationListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviationListener.java
index 97f9be2..5cfb2a4 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviationListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/DeviationListener.java
@@ -171,9 +171,8 @@
         if (listener.getParsedDataStack().peek() instanceof YangDeviation) {
             listener.getParsedDataStack().pop();
         } else {
-            throw new ParserException(constructListenerErrorMessage
-                                              (MISSING_CURRENT_HOLDER, DEVIATION_DATA,
-                                               ctx.deviation().getText(), EXIT));
+            throw new ParserException(constructListenerErrorMessage(MISSING_CURRENT_HOLDER, DEVIATION_DATA,
+                                                                    ctx.deviation().getText(), EXIT));
         }
     }
 
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumListener.java
index 46f2e86..bfd4a88 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumListener.java
@@ -66,7 +66,6 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.ENUM_DATA;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.EnumStatementContext;
@@ -74,10 +73,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.DUPLICATE_ENTRY;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yang.compiler.utils.UtilConstants.EMPTY_STRING;
 import static org.onosproject.yang.compiler.utils.UtilConstants.QUOTES;
@@ -152,9 +148,11 @@
 
                         for (YangEnum curEnum : yangEnumeration.getEnumSet()) {
                             if (curEnum.getValue() == Integer.MAX_VALUE) {
-                                ParserException parserException = new ParserException("YANG file error : "
-                                                                                              + "An enum value MUST be specified for enum substatements following the one"
-                                                                                              + "with the current highest value");
+                                ParserException parserException =
+                                        new ParserException("YANG file error : An enum value MUST be " +
+                                                                    "specified for enum substatements " +
+                                                                    "following the one with the current " +
+                                                                    "highest value");
                                 parserException.setLine(ctx.getStart().getLine());
                                 parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
                                 throw parserException;
@@ -171,8 +169,10 @@
                     try {
                         yangEnumeration.addEnumInfo((YangEnum) tmpEnumNode);
                     } catch (DataModelException e) {
-                        ParserException parserException = new ParserException(constructExtendedListenerErrorMessage(
-                                DUPLICATE_ENTRY, ENUM_DATA, ctx.string().getText(), EXIT, e.getMessage()));
+                        ParserException parserException =
+                                new ParserException(constructExtendedListenerErrorMessage(DUPLICATE_ENTRY, ENUM_DATA,
+                                                                                          ctx.string().getText(), EXIT,
+                                                                                          e.getMessage()));
                         parserException.setLine(ctx.getStart().getLine());
                         parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
                         throw parserException;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumerationListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumerationListener.java
index c73ea68..8412af2 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumerationListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumerationListener.java
@@ -61,10 +61,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory.getYangEnumerationNode;
 
@@ -157,7 +154,8 @@
                 // TODO deviate.
                 default:
                     throw new ParserException(constructListenerErrorMessage(INVALID_HOLDER, TYPE_DATA,
-                                                                            ((YangType<?>) typeData).getDataTypeName(), ENTRY));
+                                                                            ((YangType<?>) typeData).getDataTypeName(),
+                                                                            ENTRY));
             }
             listener.getParsedDataStack().push(typeData);
             listener.getParsedDataStack().push(enumerationNode);
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ErrorAppTagListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ErrorAppTagListener.java
index 6c2c05f..9e2c9ca 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ErrorAppTagListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ErrorAppTagListener.java
@@ -21,9 +21,6 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.ERROR_APP_TAG_DATA;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ErrorAppTagStatementContext;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ExtensionListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ExtensionListener.java
index d4d1749..77bcc8e 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ExtensionListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ExtensionListener.java
@@ -22,16 +22,13 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.EXTENSION_DATA;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ExtensionStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/FeatureListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/FeatureListener.java
index 5b14c25..539ff2a 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/FeatureListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/FeatureListener.java
@@ -41,17 +41,13 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.FEATURE_DATA;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.FeatureStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/GroupingListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/GroupingListener.java
index d47d577..a9078d5 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/GroupingListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/GroupingListener.java
@@ -30,25 +30,16 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.GeneratedLanguage.JAVA_GENERATION;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DESCRIPTION_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.GROUPING_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.REFERENCE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.STATUS_DATA;
+import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.*;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.GroupingStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector.detectCollidingChildUtil;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityMaxOne;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IdentityListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IdentityListener.java
index e47b2d6..3079a23 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IdentityListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IdentityListener.java
@@ -31,10 +31,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory.getYangIdentityNode;
@@ -91,8 +88,9 @@
             try {
                 curNode.addChild(identity);
             } catch (DataModelException e) {
-                throw new ParserException(constructExtendedListenerErrorMessage(UNHANDLED_PARSED_DATA,
-                                                                                IDENTITY_DATA, ctx.identifier().getText(), ENTRY, e.getMessage()));
+                throw new ParserException(constructExtendedListenerErrorMessage(UNHANDLED_PARSED_DATA, IDENTITY_DATA,
+                                                                                ctx.identifier().getText(), ENTRY,
+                                                                                e.getMessage()));
             }
             // Push identity node to the stack.
             listener.getParsedDataStack().push(identity);
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IdentityRefListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IdentityRefListener.java
index adcdee1..088486d 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IdentityRefListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IdentityRefListener.java
@@ -21,7 +21,6 @@
 import org.onosproject.yang.compiler.datamodel.YangType;
 import org.onosproject.yang.compiler.datamodel.exceptions.DataModelException;
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
-import org.onosproject.yang.compiler.datamodel.utils.ResolvableStatus;
 import org.onosproject.yang.compiler.linker.impl.YangResolutionInfoImpl;
 import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.IdentityrefSpecificationContext;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
@@ -35,10 +34,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidNodeIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yang.compiler.utils.UtilConstants.EMPTY_STRING;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IfFeatureListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IfFeatureListener.java
index 9a56209..3aba624 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IfFeatureListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IfFeatureListener.java
@@ -50,9 +50,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidNodeIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
@@ -123,8 +121,8 @@
         int errorLine = ctx.getStart().getLine();
         int errorPosition = ctx.getStart().getCharPositionInLine();
         YangResolutionInfoImpl resolutionInfo = new YangResolutionInfoImpl<YangIfFeature>(ifFeature,
-                                                                                          (YangNode) parentNode, errorLine,
-                                                                                          errorPosition);
+                                                                                          (YangNode) parentNode,
+                                                                                          errorLine, errorPosition);
         addToResolutionList(resolutionInfo, ctx);
     }
 
@@ -141,7 +139,8 @@
             addResolutionInfo(resolutionInfo);
         } catch (DataModelException e) {
             throw new ParserException(constructExtendedListenerErrorMessage(UNHANDLED_PARSED_DATA,
-                                                                            IF_FEATURE_DATA, ctx.string().getText(), EXIT, e.getMessage()));
+                                                                            IF_FEATURE_DATA, ctx.string().getText(),
+                                                                            EXIT, e.getMessage()));
         }
     }
 }
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IncludeListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IncludeListener.java
index 773a789..c528598 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IncludeListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/IncludeListener.java
@@ -22,17 +22,13 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.INCLUDE_DATA;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.IncludeStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/KeyListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/KeyListener.java
index 5b67812..fdac78c 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/KeyListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/KeyListener.java
@@ -21,19 +21,13 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.KEY_DATA;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.KeyStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.removeQuotesAndHandleConcat;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LeafListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LeafListener.java
index 6331361..68faad6 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LeafListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LeafListener.java
@@ -27,35 +27,18 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation;
-import org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory;
 
 import static org.onosproject.yang.compiler.datamodel.utils.GeneratedLanguage.JAVA_GENERATION;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.CONFIG_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DESCRIPTION_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.LEAF_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.MANDATORY_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.REFERENCE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.STATUS_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.TYPE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.UNITS_DATA;
+import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.*;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.LeafStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector.detectCollidingChildUtil;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_CONTENT;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.getParentNodeConfig;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityEqualsOne;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityMaxOne;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.*;
 import static org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory.getYangLeaf;
 
 /*
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LeafrefListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LeafrefListener.java
index 4935a8e..f9b1c45 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LeafrefListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LeafrefListener.java
@@ -22,7 +22,6 @@
 import org.onosproject.yang.compiler.datamodel.YangNode;
 import org.onosproject.yang.compiler.datamodel.YangType;
 import org.onosproject.yang.compiler.datamodel.exceptions.DataModelException;
-import org.onosproject.yang.compiler.datamodel.utils.DataModelUtils;
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.linker.impl.YangResolutionInfoImpl;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
@@ -36,10 +35,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
 /*
@@ -137,8 +133,9 @@
                 leafRef.setParentNode((YangNode) parentNodeOfLeaf);
                 if (listener.getGroupingDepth() == 0) {
                     // Add resolution information to the list.
-                    YangResolutionInfoImpl resolutionInfo = new YangResolutionInfoImpl<YangLeafRef>(leafRef,
-                                                                                                    (YangNode) parentNodeOfLeaf, errorLine, errorPosition);
+                    YangResolutionInfoImpl resolutionInfo =
+                            new YangResolutionInfoImpl<YangLeafRef>(leafRef, (YangNode) parentNodeOfLeaf,
+                                                                    errorLine, errorPosition);
                     addToResolutionList(resolutionInfo);
                 } else {
                     leafRef.setInGrouping(true);
@@ -163,8 +160,9 @@
 
                 if (listener.getGroupingDepth() == 0) {
                     // Add resolution information to the list.
-                    YangResolutionInfoImpl resolutionInfoImpl = new YangResolutionInfoImpl<YangLeafRef>(leafRef,
-                                                                                                        (YangNode) parentNodeOfLeafList, errorLine, errorPosition);
+                    YangResolutionInfoImpl resolutionInfoImpl =
+                            new YangResolutionInfoImpl<YangLeafRef>(leafRef, (YangNode) parentNodeOfLeafList,
+                                                                    errorLine, errorPosition);
                     addToResolutionList(resolutionInfoImpl);
                 } else {
                     leafRef.setInGrouping(true);
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListener.java
index f682a30..7c8f868 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListener.java
@@ -25,23 +25,15 @@
 import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation;
 
 import static org.onosproject.yang.compiler.datamodel.utils.RestrictionResolver.processLengthRestriction;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.LENGTH_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.TYPE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.getYangConstructType;
-import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.BINARY;
+import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.*;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.*;
 import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.DERIVED;
-import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.STRING;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 
 /*
@@ -136,8 +128,8 @@
         YangRangeRestriction lengthRestriction = null;
         try {
             lengthRestriction = processLengthRestriction(null, ctx.getStart().getLine(),
-                                                         ctx.getStart().getCharPositionInLine(), false, ctx.length
-                            ().getText(), listener.getFileName());
+                                                         ctx.getStart().getCharPositionInLine(), false,
+                                                         ctx.length().getText(), listener.getFileName());
         } catch (DataModelException e) {
             ParserException parserException = new ParserException(e.getMessage());
             parserException.setCharPosition(e.getCharPositionInLine());
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ListListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ListListener.java
index 0048c16..686cf25 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ListListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ListListener.java
@@ -31,34 +31,19 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory;
 
 import static org.onosproject.yang.compiler.datamodel.utils.GeneratedLanguage.JAVA_GENERATION;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.CONFIG_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DATA_DEF_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DESCRIPTION_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.KEY_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.LIST_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.MAX_ELEMENT_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.MIN_ELEMENT_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.REFERENCE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.STATUS_DATA;
+import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.*;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.ListStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector.detectCollidingChildUtil;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.validateUniqueInList;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.getParentNodeConfig;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityMaxOne;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityNonZero;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.*;
 import static org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory.getYangListNode;
 
 /*
@@ -153,7 +138,8 @@
                 curNode.addChild(yangList);
             } catch (DataModelException e) {
                 throw new ParserException(constructExtendedListenerErrorMessage(UNHANDLED_PARSED_DATA,
-                                                                                LIST_DATA, ctx.identifier().getText(), ENTRY, e.getMessage()));
+                                                                                LIST_DATA, ctx.identifier().getText(),
+                                                                                ENTRY, e.getMessage()));
             }
             listener.getParsedDataStack().push(yangList);
         } else {
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/NotificationListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/NotificationListener.java
index 94bcee4..b7efe61 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/NotificationListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/NotificationListener.java
@@ -121,7 +121,9 @@
                 curNode.addChild(notification);
             } catch (DataModelException e) {
                 throw new ParserException(constructExtendedListenerErrorMessage(UNHANDLED_PARSED_DATA,
-                                                                                NOTIFICATION_DATA, ctx.identifier().getText(), ENTRY, e.getMessage()));
+                                                                                NOTIFICATION_DATA,
+                                                                                ctx.identifier().getText(),
+                                                                                ENTRY, e.getMessage()));
             }
             listener.getParsedDataStack().push(notification);
         } else {
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/OutputListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/OutputListener.java
index ae240b4..822ae93 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/OutputListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/OutputListener.java
@@ -23,7 +23,6 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.utils.UtilConstants;
 
 import static org.onosproject.yang.compiler.datamodel.utils.GeneratedLanguage.JAVA_GENERATION;
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.OUTPUT_DATA;
@@ -32,10 +31,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory.getYangOutputNode;
 import static org.onosproject.yang.compiler.utils.UtilConstants.OUTPUT;
@@ -99,7 +95,8 @@
                 curNode.addChild(yangOutput);
             } catch (DataModelException e) {
                 throw new ParserException(constructExtendedListenerErrorMessage(UNHANDLED_PARSED_DATA,
-                                                                                OUTPUT_DATA, "", ENTRY, e.getMessage()));
+                                                                                OUTPUT_DATA,
+                                                                                "", ENTRY, e.getMessage()));
             }
             listener.getParsedDataStack().push(yangOutput);
         } else {
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PathListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PathListener.java
index c1e8b7c..a342f5c 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PathListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PathListener.java
@@ -21,8 +21,6 @@
 import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PathStatementContext;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.PATH_DATA;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListener.java
index c522c4b..65db33f 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListener.java
@@ -111,9 +111,10 @@
 
         if (type.getDataType() != YangDataTypes.STRING && type.getDataType() != YangDataTypes.DERIVED) {
 
-            ParserException parserException = new ParserException("YANG file error : " +
-                                                                          getYangConstructType(PATTERN_DATA) + " name " + ctx.string().getText() +
-                                                                          " can be used to restrict the built-in type string or types derived from string.");
+            ParserException parserException =
+                    new ParserException("YANG file error : " + getYangConstructType(PATTERN_DATA) + " name " +
+                                                ctx.string().getText() + " can be used to restrict the built-in " +
+                                                "type string or types derived from string.");
             parserException.setLine(ctx.getStart().getLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
             throw parserException;
@@ -191,9 +192,9 @@
         try {
             Pattern.compile(compile);
         } catch (PatternSyntaxException exception) {
-            ParserException parserException = new ParserException("YANG file error : " +
-                                                                          getYangConstructType(PATTERN_DATA) + " name " + ctx.string().getText() +
-                                                                          " is not a valid regular expression");
+            ParserException parserException =
+                    new ParserException("YANG file error : " + getYangConstructType(PATTERN_DATA) + " name " +
+                                                ctx.string().getText() + " is not a valid regular expression");
             parserException.setLine(ctx.getStart().getLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
             throw parserException;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PositionListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PositionListener.java
index a29d3a0..9b5057a 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PositionListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PositionListener.java
@@ -39,8 +39,6 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.POSITION_DATA;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PositionStatementContext;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PrefixListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PrefixListener.java
index 5aadc65..6608d66 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PrefixListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PrefixListener.java
@@ -22,8 +22,6 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.PREFIX_DATA;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PrefixStatementContext;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PresenceListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PresenceListener.java
index 27b9061..a60531a 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PresenceListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PresenceListener.java
@@ -20,7 +20,6 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.CONTAINER_DATA;
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.PRESENCE_DATA;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RequireInstanceListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RequireInstanceListener.java
index c83623a..9246ae9 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RequireInstanceListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RequireInstanceListener.java
@@ -22,9 +22,6 @@
 import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.REQUIRE_INSTANCE_DATA;
 import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.INSTANCE_IDENTIFIER;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RevisionDateListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RevisionDateListener.java
index 7a49388..f5df147 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RevisionDateListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RevisionDateListener.java
@@ -21,9 +21,6 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import java.util.Date;
 
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RpcListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RpcListener.java
index 25baa54..59f7cea 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RpcListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RpcListener.java
@@ -26,22 +26,14 @@
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
 
 import static org.onosproject.yang.compiler.datamodel.utils.GeneratedLanguage.JAVA_GENERATION;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DESCRIPTION_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.INPUT_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.OUTPUT_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.REFERENCE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.RPC_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.STATUS_DATA;
+import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.*;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.RpcStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector.detectCollidingChildUtil;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityMaxOne;
@@ -120,7 +112,9 @@
                 curNode.addChild(yangRpc);
             } catch (DataModelException e) {
                 throw new ParserException(constructExtendedListenerErrorMessage(UNHANDLED_PARSED_DATA,
-                                                                                RPC_DATA, ctx.identifier().getText(), ENTRY, e.getMessage()));
+                                                                                RPC_DATA,
+                                                                                ctx.identifier().getText(),
+                                                                                ENTRY, e.getMessage()));
             }
             listener.getParsedDataStack().push(yangRpc);
         } else {
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ShortCaseListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ShortCaseListener.java
index 8876bda..3a58c16 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ShortCaseListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/ShortCaseListener.java
@@ -23,11 +23,6 @@
 import org.onosproject.yang.compiler.datamodel.exceptions.DataModelException;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
-import org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory;
 
 import static org.onosproject.yang.compiler.datamodel.utils.GeneratedLanguage.JAVA_GENERATION;
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.CASE_DATA;
@@ -38,11 +33,7 @@
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_CHILD;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory.getYangCaseNode;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/StatusListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/StatusListener.java
index d00afd1..bcdb8ec 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/StatusListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/StatusListener.java
@@ -19,15 +19,9 @@
 import org.onosproject.yang.compiler.datamodel.YangStatus;
 import org.onosproject.yang.compiler.datamodel.YangStatusType;
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
-import org.onosproject.yang.compiler.datamodel.utils.YangConstructType;
 import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation;
 
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.STATUS_DATA;
 import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.getYangConstructType;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/TypeDefListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/TypeDefListener.java
index 5e9d7a6..8c3806a 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/TypeDefListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/TypeDefListener.java
@@ -31,34 +31,18 @@
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.GeneratedLanguage.JAVA_GENERATION;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DEFAULT_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DESCRIPTION_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.REFERENCE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.STATUS_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.TYPEDEF_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.TYPE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.UNITS_DATA;
+import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.*;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.TypedefStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector.detectCollidingChildUtil;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_CONTENT;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidIdentifier;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityEqualsOne;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityMaxOne;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.*;
 import static org.onosproject.yang.compiler.translator.tojava.YangDataModelFactory.getYangTypeDefNode;
 
 /*
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/TypeListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/TypeListener.java
index 7a23e7a..7855dce 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/TypeListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/TypeListener.java
@@ -283,7 +283,8 @@
                                        TypeStatementContext ctx) {
 
         // Check for stack to be non empty.
-        checkStackIsNotEmpty(listener, ListenerErrorType.MISSING_CURRENT_HOLDER, TYPE_DATA, ctx.string().getText(), EXIT);
+        checkStackIsNotEmpty(listener, ListenerErrorType.MISSING_CURRENT_HOLDER, TYPE_DATA,
+                             ctx.string().getText(), EXIT);
 
         Parsable parsableType = listener.getParsedDataStack().pop();
         if (!(parsableType instanceof YangType)) {
@@ -304,7 +305,8 @@
             DataModelUtils.addResolutionInfo(resolutionInfo);
         } catch (DataModelException e) {
             throw new ParserException(constructExtendedListenerErrorMessage(ListenerErrorType.UNHANDLED_PARSED_DATA,
-                                                                            TYPE_DATA, ctx.string().getText(), ENTRY, e.getMessage()));
+                                                                            TYPE_DATA, ctx.string().getText(),
+                                                                            ENTRY, e.getMessage()));
         }
     }
 
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/UsesListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/UsesListener.java
index 616d761..26bb887 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/UsesListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/UsesListener.java
@@ -33,26 +33,17 @@
 import org.onosproject.yang.compiler.linker.impl.YangResolutionInfoImpl;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType;
-import org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil;
 
 import static org.onosproject.yang.compiler.datamodel.utils.DataModelUtils.addResolutionInfo;
 import static org.onosproject.yang.compiler.datamodel.utils.GeneratedLanguage.JAVA_GENERATION;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.DESCRIPTION_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.REFERENCE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.STATUS_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.USES_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.WHEN_DATA;
+import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.*;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.UsesStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerCollisionDetector.detectCollidingChildUtil;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.*;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerUtil.getValidNodeIdentifier;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.validateCardinalityMaxOne;
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerUtil.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerUtil.java
index 328b6bc..0a4ef7d 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerUtil.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerUtil.java
@@ -130,15 +130,18 @@
 
         if (identifierString.length() > IDENTIFIER_LENGTH) {
             parserException = new ParserException("YANG file error : " +
-                                                          getYangConstructType(yangConstruct) + " name " + identifierString + " is " +
+                                                          getYangConstructType(yangConstruct) + " name " +
+                                                          identifierString + " is " +
                                                           "greater than 64 characters.");
         } else if (!IDENTIFIER_PATTERN.matcher(identifierString).matches()) {
             parserException = new ParserException("YANG file error : " +
-                                                          getYangConstructType(yangConstruct) + " name " + identifierString + " is not " +
+                                                          getYangConstructType(yangConstruct) + " name " +
+                                                          identifierString + " is not " +
                                                           "valid.");
         } else if (identifierString.toLowerCase().startsWith(XML)) {
             parserException = new ParserException("YANG file error : " +
-                                                          getYangConstructType(yangConstruct) + " identifier " + identifierString +
+                                                          getYangConstructType(yangConstruct) + " identifier " +
+                                                          identifierString +
                                                           " must not start with (('X'|'x') ('M'|'m') ('L'|'l')).");
         } else {
             return identifierString;
@@ -206,8 +209,8 @@
         String value = removeQuotesAndHandleConcat(integerValue);
         if (!value.matches(NON_NEGATIVE_INTEGER_PATTERN)) {
             ParserException parserException = new ParserException("YANG file error : " +
-                                                                          getYangConstructType(yangConstruct) + " value " + value + " is not " +
-                                                                          "valid.");
+                                                                          getYangConstructType(yangConstruct) +
+                                                                          " value " + value + " is not valid.");
             parserException.setLine(ctx.getStart().getLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
             throw parserException;
@@ -218,8 +221,8 @@
             valueInInteger = Integer.parseInt(value);
         } catch (NumberFormatException e) {
             ParserException parserException = new ParserException("YANG file error : " +
-                                                                          getYangConstructType(yangConstruct) + " value " + value + " is not " +
-                                                                          "valid.");
+                                                                          getYangConstructType(yangConstruct) +
+                                                                          " value " + value + " is not valid.");
             parserException.setLine(ctx.getStart().getLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
             throw parserException;
@@ -241,8 +244,8 @@
         String value = removeQuotesAndHandleConcat(integerValue);
         if (!INTEGER_PATTERN.matcher(value).matches()) {
             ParserException parserException = new ParserException("YANG file error : " +
-                                                                          getYangConstructType(yangConstruct) + " value " + value + " is not " +
-                                                                          "valid.");
+                                                                          getYangConstructType(yangConstruct) +
+                                                                          " value " + value + " is not valid.");
             parserException.setLine(ctx.getStart().getLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
             throw parserException;
@@ -253,8 +256,8 @@
             valueInInteger = Integer.parseInt(value);
         } catch (NumberFormatException e) {
             ParserException parserException = new ParserException("YANG file error : " +
-                                                                          getYangConstructType(yangConstruct) + " value " + value + " is not " +
-                                                                          "valid.");
+                                                                          getYangConstructType(yangConstruct) +
+                                                                          " value " + value + " is not valid.");
             parserException.setLine(ctx.getStart().getLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
             throw parserException;
@@ -280,8 +283,8 @@
             return false;
         } else {
             ParserException parserException = new ParserException("YANG file error : " +
-                                                                          getYangConstructType(yangConstruct) + " value " + value + " is not " +
-                                                                          "valid.");
+                                                                          getYangConstructType(yangConstruct) +
+                                                                          " value " + value + " is not valid.");
             parserException.setLine(ctx.getStart().getLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
             throw parserException;
@@ -332,7 +335,8 @@
             return nodeIdentifier;
         } else {
             ParserException parserException = new ParserException("YANG file error : " +
-                                                                          getYangConstructType(yangConstruct) + " name " + nodeIdentifierString +
+                                                                          getYangConstructType(yangConstruct) +
+                                                                          " name " + nodeIdentifierString +
                                                                           " is not valid.");
             parserException.setLine(ctx.getStart().getLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
@@ -438,8 +442,9 @@
             yangAtomicPathPath.setNodeIdentifier(nodeIdentifier);
             atomicPath.add(yangAtomicPathPath);
             if (nodeIdentifier.getPrefix() != null && nodeIdentifier.getPrefix() != prefixOfFile) {
-                ParserException parserException = new ParserException("YANG file error : A leaf reference, in unique," +
-                                                                              " must refer to a leaf in the list");
+                ParserException parserException =
+                        new ParserException("YANG file error : A leaf reference, in unique," +
+                                                    " must refer to a leaf in the list");
                 parserException.setLine(ctx.getStart().getLine());
                 parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
                 throw parserException;
@@ -473,9 +478,9 @@
                     leaf = getReferenceLeafFromUnique(holderOfLeaf, leafInPath);
                 }
                 if (leaf == null) {
-                    ParserException parserException = new ParserException("YANG file error : A leaf reference, in " +
-                                                                                  "unique," +
-                                                                                  " must refer to a leaf under the list");
+                    ParserException parserException =
+                            new ParserException("YANG file error : A leaf reference, in unique," +
+                                                        " must refer to a leaf under the list");
                     parserException.setLine(ctx.getStart().getLine());
                     parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
                     throw parserException;
@@ -501,8 +506,9 @@
             YangNode referredNode = getReferredNodeFromTheUniqueNodes(nodeInUnique.getNodeIdentifier(),
                                                                       potentialReferredNode);
             if (referredNode == null) {
-                ParserException parserException = new ParserException("YANG file error : The target node in unique " +
-                                                                              "reference path is invalid");
+                ParserException parserException =
+                        new ParserException("YANG file error : The target node in unique " +
+                                                    "reference path is invalid");
                 parserException.setLine(ctx.getStart().getLine());
                 parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
                 throw parserException;
@@ -606,9 +612,9 @@
 
         // absolute-schema-nodeid = 1*("/" node-identifier)
         if (!tmpSchemaNodeId.startsWith(SLASH)) {
-            ParserException parserException = new ParserException("YANG file error : " +
-                                                                          getYangConstructType(yangConstructType) + " name " + argumentString +
-                                                                          "is not valid");
+            ParserException parserException =
+                    new ParserException("YANG file error : " + getYangConstructType(yangConstructType) +
+                                                " name " + argumentString + "is not valid");
             parserException.setLine(ctx.getStart().getLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
             throw parserException;
@@ -689,9 +695,9 @@
         if (tmpData.length == 2) {
             return tmpData[0];
         } else {
-            ParserException parserException = new ParserException("YANG file error : " +
-                                                                          getYangConstructType(yangConstruct) + " name " + inputString +
-                                                                          " is not valid.");
+            ParserException parserException =
+                    new ParserException("YANG file error : " + getYangConstructType(yangConstruct) +
+                                                " name " + inputString + " is not valid.");
             parserException.setLine(ctx.getStart().getLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
             throw parserException;
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumListenerTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumListenerTest.java
index 4f56ef8..a900a1b 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumListenerTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/EnumListenerTest.java
@@ -111,7 +111,7 @@
     public void processEnumMaxNextValue() throws IOException, ParserException {
         thrown.expect(ParserException.class);
         thrown.expectMessage("YANG file error : "
-                + "An enum value MUST be specified for enum substatements following the one"
+                + "An enum value MUST be specified for enum substatements following the one "
                 + "with the current highest value");
         YangNode node = manager.getDataModel("src/test/resources/EnumMaxNextValue.yang");
     }
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/NamespaceListenerTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/NamespaceListenerTest.java
index 745b882..1a11053 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/NamespaceListenerTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/NamespaceListenerTest.java
@@ -39,7 +39,6 @@
      */
     @Test(expected = ParserException.class)
     public void processNamespaceWithInvalidSpaces() throws IOException, ParserException {
-
         YangNode node = manager.getDataModel("src/test/resources/NamespaceWithInvalidSpaces.yang");
     }
 
@@ -48,12 +47,10 @@
      */
     @Test()
     public void processNamespaceInDoubleQuotes() throws IOException, ParserException {
-
         YangNode node = manager.getDataModel("src/test/resources/NamespaceInDoubleQuotes.yang");
 
         // Checks for the version value in data model tree.
-        assertThat(((YangModule) node).getModuleNamespace(), is
-                ("urn:ietf:params:xml:ns:yang:ietf-ospf"));
+        assertThat(((YangModule) node).getModuleNamespace(), is("urn:ietf:params:xml:ns:yang:ietf-ospf"));
     }
 
     /**
@@ -61,7 +58,6 @@
      */
     @Test()
     public void processNamespaceWithoutQuotes() throws IOException, ParserException {
-
         YangNode node = manager.getDataModel("src/test/resources/NamespaceWithoutQuotes.yang");
 
         // Checks for the version value in data model tree.
@@ -73,7 +69,6 @@
      */
     @Test(expected = ParserException.class)
     public void processNamespaceDualEntry() throws IOException, ParserException {
-
         YangNode node = manager.getDataModel("src/test/resources/NamespaceDualEntry.yang");
     }
 
@@ -82,7 +77,6 @@
      */
     @Test(expected = ParserException.class)
     public void processNamespaceNoEntryTest() throws IOException, ParserException {
-
         YangNode node = manager.getDataModel("src/test/resources/NamespaceNoEntryTest.yang");
     }
 }
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerErrorMessageConstructionTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerErrorMessageConstructionTest.java
index 1301c8b..e61e611 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerErrorMessageConstructionTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerErrorMessageConstructionTest.java
@@ -21,6 +21,8 @@
 
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
 
 /**
  * Test case for testing listener error message construction util.
@@ -34,11 +36,14 @@
     public void checkErrorMsgConstructionWithName() {
 
         // Create an test error message
-        String testErrorMessage = ListenerErrorMessageConstruction.constructListenerErrorMessage(ListenerErrorType.INVALID_HOLDER, YangConstructType.CONTACT_DATA, "Test Instance", ListenerErrorLocation.ENTRY);
+        String testErrorMessage = constructListenerErrorMessage(ListenerErrorType.INVALID_HOLDER,
+                                                                YangConstructType.CONTACT_DATA,
+                                                                "Test Instance",
+                                                                ListenerErrorLocation.ENTRY);
 
         // Check message.
         assertThat(testErrorMessage, is("Internal parser error detected: Invalid holder for contact "
-                + "\"Test Instance\" before processing."));
+                                                + "\"Test Instance\" before processing."));
     }
 
     /**
@@ -48,12 +53,15 @@
     public void checkErrorMsgConstructionWithoutName() {
 
         // Create an test error message
-        String testErrorMessage = ListenerErrorMessageConstruction.constructListenerErrorMessage(ListenerErrorType.INVALID_HOLDER, YangConstructType.CONTACT_DATA, "Test Instance", ListenerErrorLocation.ENTRY);
+        String testErrorMessage = constructListenerErrorMessage(ListenerErrorType.INVALID_HOLDER,
+                                                                YangConstructType.CONTACT_DATA,
+                                                                "Test Instance",
+                                                                ListenerErrorLocation.ENTRY);
 
         // Check message.
         assertThat(testErrorMessage,
                    is("Internal parser error detected: Invalid holder for contact \"Test Instance\""
-                           + " before processing."));
+                              + " before processing."));
     }
 
     /**
@@ -64,14 +72,16 @@
     public void checkExtendedErrorMsgConstructionWithName() {
 
         // Create an test error message
-        String testErrorMessage = ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage(ListenerErrorType.INVALID_HOLDER, YangConstructType.CONTACT_DATA,
-                                                                                                         "Test Instance", ListenerErrorLocation.ENTRY,
-                                                                                                         "Extended Information");
+        String testErrorMessage = constructExtendedListenerErrorMessage(ListenerErrorType.INVALID_HOLDER,
+                                                                        YangConstructType.CONTACT_DATA,
+                                                                        "Test Instance",
+                                                                        ListenerErrorLocation.ENTRY,
+                                                                        "Extended Information");
 
         // Check message.
         assertThat(testErrorMessage,
                    is("Internal parser error detected: Invalid holder for contact \"Test Instance\""
-                           + " before processing.\n" + "Error Information: Extended Information"));
+                              + " before processing.\n" + "Error Information: Extended Information"));
     }
 
     /**
@@ -82,11 +92,14 @@
     public void checkExtendedErrorMsgConstructionWithoutName() {
 
         // Create an test error message
-        String testErrorMessage = ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage(ListenerErrorType.INVALID_HOLDER, YangConstructType.CONTACT_DATA, "", ListenerErrorLocation.ENTRY,
-                                                                                                         "Extended Information");
+        String testErrorMessage = constructExtendedListenerErrorMessage(ListenerErrorType.INVALID_HOLDER,
+                                                                        YangConstructType.CONTACT_DATA,
+                                                                        "", ListenerErrorLocation.ENTRY,
+                                                                        "Extended Information");
 
         // Check message.
-        assertThat(testErrorMessage, is("Internal parser error detected: Invalid holder for contact"
-                + " before processing.\n" + "Error Information: Extended Information"));
+        assertThat(testErrorMessage,
+                   is("Internal parser error detected: Invalid holder for contact before processing.\n" +
+                              "Error Information: Extended Information"));
     }
 }
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerValidationTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerValidationTest.java
index 6ed3d3b..05657e2 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerValidationTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/parserutils/ListenerValidationTest.java
@@ -24,6 +24,8 @@
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
 
+import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
+
 /**
  * Test case for testing listener validation util.
  */
@@ -39,7 +41,9 @@
     @Test
     public void validateStackIsNotEmptyForEmptyStack() {
 
-        String expectedError = ListenerErrorMessageConstruction.constructListenerErrorMessage(ListenerErrorType.MISSING_HOLDER, YangConstructType.YANGBASE_DATA, "", ListenerErrorLocation.EXIT);
+        String expectedError = constructListenerErrorMessage(ListenerErrorType.MISSING_HOLDER,
+                                                             YangConstructType.YANGBASE_DATA,
+                                                             "", ListenerErrorLocation.EXIT);
 
         // Get the exception occurred during parsing.
         thrown.expect(ParserException.class);
@@ -48,7 +52,8 @@
         // Create test walker and assign test error to it.
         TreeWalkListener testWalker = new TreeWalkListener();
 
-        ListenerValidation.checkStackIsNotEmpty(testWalker, ListenerErrorType.MISSING_HOLDER, YangConstructType.YANGBASE_DATA, "", ListenerErrorLocation.EXIT);
+        ListenerValidation.checkStackIsNotEmpty(testWalker, ListenerErrorType.MISSING_HOLDER,
+                                                YangConstructType.YANGBASE_DATA, "", ListenerErrorLocation.EXIT);
     }
 
     /**
@@ -65,7 +70,8 @@
         YangRevision tmpNode = new YangRevision();
         testWalker.getParsedDataStack().push(tmpNode);
 
-        ListenerValidation.checkStackIsNotEmpty(testWalker, ListenerErrorType.MISSING_HOLDER, YangConstructType.YANGBASE_DATA, "", ListenerErrorLocation.EXIT);
+        ListenerValidation.checkStackIsNotEmpty(testWalker, ListenerErrorType.MISSING_HOLDER,
+                                                YangConstructType.YANGBASE_DATA, "", ListenerErrorLocation.EXIT);
     }
 
     /**
@@ -75,7 +81,9 @@
     @Test
     public void validateStackIsEmptyForNonEmptyStack() {
 
-        String expectedError = ListenerErrorMessageConstruction.constructListenerErrorMessage(ListenerErrorType.MISSING_HOLDER, YangConstructType.YANGBASE_DATA, "", ListenerErrorLocation.EXIT);
+        String expectedError = constructListenerErrorMessage(ListenerErrorType.MISSING_HOLDER,
+                                                             YangConstructType.YANGBASE_DATA,
+                                                             "", ListenerErrorLocation.EXIT);
 
         // Get the exception occurred during parsing.
         thrown.expect(ParserException.class);
@@ -88,7 +96,8 @@
         YangRevision tmpNode = new YangRevision();
         testWalker.getParsedDataStack().push(tmpNode);
 
-        ListenerValidation.checkStackIsEmpty(testWalker, ListenerErrorType.MISSING_HOLDER, YangConstructType.YANGBASE_DATA, "", ListenerErrorLocation.EXIT);
+        ListenerValidation.checkStackIsEmpty(testWalker, ListenerErrorType.MISSING_HOLDER,
+                                             YangConstructType.YANGBASE_DATA, "", ListenerErrorLocation.EXIT);
     }
 
     /**
@@ -101,6 +110,7 @@
         // Create test walker and assign test error to it.
         TreeWalkListener testWalker = new TreeWalkListener();
 
-        ListenerValidation.checkStackIsEmpty(testWalker, ListenerErrorType.MISSING_HOLDER, YangConstructType.YANGBASE_DATA, "", ListenerErrorLocation.EXIT);
+        ListenerValidation.checkStackIsEmpty(testWalker, ListenerErrorType.MISSING_HOLDER,
+                                             YangConstructType.YANGBASE_DATA, "", ListenerErrorLocation.EXIT);
     }
 }
diff --git a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/JavaCodeGeneratorUtil.java b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/JavaCodeGeneratorUtil.java
index 1910d65..6b1f371 100644
--- a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/JavaCodeGeneratorUtil.java
+++ b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/JavaCodeGeneratorUtil.java
@@ -62,8 +62,10 @@
             if (curTraversal != PARENT) {
                 if (!(codeGenNode instanceof JavaCodeGenerator)) {
                     throw new TranslatorException("Unsupported node to generate code " +
-                                                          codeGenNode.getName() + " in " + codeGenNode.getLineNumber() + " at "
-                                                          + codeGenNode.getCharPosition() + " in " + codeGenNode.getFileName());
+                                                          codeGenNode.getName() + " in " +
+                                                          codeGenNode.getLineNumber() + " at " +
+                                                          codeGenNode.getCharPosition() + " in " +
+                                                          codeGenNode.getFileName());
                 }
                 try {
                     generateCodeEntry(codeGenNode, yangPlugin, rootNode);
diff --git a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaEventFragmentFiles.java b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaEventFragmentFiles.java
index efc860b..25c6ca0 100644
--- a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaEventFragmentFiles.java
+++ b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaEventFragmentFiles.java
@@ -152,14 +152,10 @@
         addGeneratedTempFile(EVENT_SUBJECT_SETTER_MASK);
 
         eventEnumTempFileHandle = getTemporaryFileHandle(EVENT_ENUM_FILE_NAME);
-        eventMethodTempFileHandle = getTemporaryFileHandle(
-                EVENT_METHOD_FILE_NAME);
-        eventSubjectAttributeTempFileHandle = getTemporaryFileHandle
-                (EVENT_SUBJECT_ATTRIBUTE_FILE_NAME);
-        eventSubjectGetterTempFileHandle = getTemporaryFileHandle(
-                EVENT_SUBJECT_GETTER_FILE_NAME);
-        eventSubjectSetterTempFileHandle = getTemporaryFileHandle(
-                EVENT_SUBJECT_SETTER_FILE_NAME);
+        eventMethodTempFileHandle = getTemporaryFileHandle(EVENT_METHOD_FILE_NAME);
+        eventSubjectAttributeTempFileHandle = getTemporaryFileHandle(EVENT_SUBJECT_ATTRIBUTE_FILE_NAME);
+        eventSubjectGetterTempFileHandle = getTemporaryFileHandle(EVENT_SUBJECT_GETTER_FILE_NAME);
+        eventSubjectSetterTempFileHandle = getTemporaryFileHandle(EVENT_SUBJECT_SETTER_FILE_NAME);
     }
 
     /**
diff --git a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaFragmentFiles.java b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaFragmentFiles.java
index b88ce13..4ea25c7 100644
--- a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaFragmentFiles.java
+++ b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaFragmentFiles.java
@@ -257,7 +257,7 @@
     private static final String KEY_CLASS_FILE_NAME_SUFFIX = KEYS;
 
     /**
-     * Current attributes YANG node
+     * Current attributes YANG node.
      */
     private YangNode attrNode;
 
diff --git a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaTypeFragmentFiles.java b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaTypeFragmentFiles.java
index e65127f..f796586 100644
--- a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaTypeFragmentFiles.java
+++ b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/TempJavaTypeFragmentFiles.java
@@ -420,8 +420,7 @@
         }
 
         if ((getGeneratedTempFiles() & CONSTRUCTOR_FOR_TYPE_MASK) != 0) {
-            addTypeConstructor(javaAttributeInfo, types.indexOf
-                    (javaAttributeInfo.getAttributeType()));
+            addTypeConstructor(javaAttributeInfo, types.indexOf(javaAttributeInfo.getAttributeType()));
         }
     }
 
@@ -527,8 +526,8 @@
     private void addFromStringMethod(JavaAttributeInfo newAttrInfo, YangPluginConfig pluginConfig)
             throws IOException {
 
-        JavaQualifiedTypeInfoTranslator qualifiedInfoOfFromString = getQualifiedInfoOfFromString(newAttrInfo,
-                                                                                                 pluginConfig.getConflictResolver());
+        JavaQualifiedTypeInfoTranslator qualifiedInfoOfFromString =
+                getQualifiedInfoOfFromString(newAttrInfo, pluginConfig.getConflictResolver());
             /*
              * Create a new java attribute info with qualified information of
              * wrapper classes.
diff --git a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaFileGenerator.java b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaFileGenerator.java
index e886af2..1a5deba 100644
--- a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaFileGenerator.java
+++ b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaFileGenerator.java
@@ -839,10 +839,9 @@
                 getGetter(INT, className, GENERATE_ENUM_CLASS) + NEW_LINE);
 
         if (!enumFile.isEnumClass()) {
-            insertDataIntoJavaFile(file, getBitSetEnumClassFromString
-                    (getCapitalCase(className)));
-            insertDataIntoJavaFile(file, getBitSetEnumClassToString(
-                    getCapitalCase(className), (YangEnumeration) curNode));
+            insertDataIntoJavaFile(file, getBitSetEnumClassFromString(getCapitalCase(className)));
+            insertDataIntoJavaFile(file, getBitSetEnumClassToString(getCapitalCase(className),
+                                                                    (YangEnumeration) curNode));
         } else {
             insertDataIntoJavaFile(file, getToStringForEnumClass());
         }
diff --git a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaIdentifierSyntax.java b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaIdentifierSyntax.java
index 0a065d6..b22026e 100644
--- a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaIdentifierSyntax.java
+++ b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaIdentifierSyntax.java
@@ -118,8 +118,7 @@
 
         ArrayList<String> pkgArr = new ArrayList<>();
         nameSpace = nameSpace.replace(QUOTES, EMPTY_STRING);
-        String properNameSpace = nameSpace.replaceAll
-                (REGEX_WITH_ALL_SPECIAL_CHAR, COLON);
+        String properNameSpace = nameSpace.replaceAll(REGEX_WITH_ALL_SPECIAL_CHAR, COLON);
         String[] nameSpaceArr = properNameSpace.split(COLON);
 
         Collections.addAll(pkgArr, nameSpaceArr);
diff --git a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/StringGenerator.java b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/StringGenerator.java
index f2cccb8..796079b 100644
--- a/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/StringGenerator.java
+++ b/compiler/base/translator/src/main/java/org/onosproject/yang/compiler/translator/tojava/utils/StringGenerator.java
@@ -1025,8 +1025,7 @@
                                         String name2) {
         StringBuilder builder = new StringBuilder();
         builder.append(type).append(DIAMOND_OPEN_BRACKET).append(name1)
-                .append(COMMA).append(SPACE).append(name2).append
-                (DIAMOND_CLOSE_BRACKET);
+                .append(COMMA).append(SPACE).append(name2).append(DIAMOND_CLOSE_BRACKET);
         return builder.toString();
     }
 
@@ -1094,7 +1093,7 @@
     }
 
     /**
-     * Returns string builder attribute string;
+     * Returns string builder attribute string.
      *
      * @param init  first param to be appended to string builder
      * @param space indentation space
@@ -1146,7 +1145,7 @@
     }
 
     /**
-     * Returns for loop string
+     * Returns for loop string.
      *
      * @param space indentation
      * @param type  data type
diff --git a/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/javamodel/AttributesJavaDataTypeTest.java b/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/javamodel/AttributesJavaDataTypeTest.java
index 7ae5564..e10800c 100644
--- a/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/javamodel/AttributesJavaDataTypeTest.java
+++ b/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/javamodel/AttributesJavaDataTypeTest.java
@@ -141,7 +141,8 @@
      */
     @Test
     public void testForTypeDef() throws DataModelException {
-        test = AttributesJavaDataType.getJavaImportPackage(getStubExtendedInfo(getStubYangType(TYPE_DEF)), false, pluginConfig);
+        test = AttributesJavaDataType.getJavaImportPackage(getStubExtendedInfo(getStubYangType(TYPE_DEF)),
+                                                           false, pluginConfig);
         assertThat(true, is(test.equals(TYPE_DEF_PKG)));
     }
 
diff --git a/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaCodeSnippetGenTest.java b/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaCodeSnippetGenTest.java
index 92c1177..95f5026 100644
--- a/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaCodeSnippetGenTest.java
+++ b/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaCodeSnippetGenTest.java
@@ -26,6 +26,7 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.core.IsNot.not;
+import static org.onosproject.yang.compiler.translator.tojava.utils.JavaCodeSnippetGen.getJavaAttributeDefinition;
 
 /**
  * Unit test cases for java code snippet generator.
@@ -70,7 +71,9 @@
 
         String imports = JavaCodeSnippetGen.getImportText(importInfo);
 
-        assertThat(true, is(imports.equals(UtilConstants.IMPORT + PKG_INFO + UtilConstants.PERIOD + CLASS_INFO + UtilConstants.SEMI_COLON + UtilConstants.NEW_LINE)));
+        assertThat(true, is(imports.equals(UtilConstants.IMPORT + PKG_INFO +
+                                                   UtilConstants.PERIOD + CLASS_INFO +
+                                                   UtilConstants.SEMI_COLON + UtilConstants.NEW_LINE)));
     }
 
     /**
@@ -78,27 +81,37 @@
      */
     @Test
     public void testForJavaAttributeInfo() {
-
-        String attributeWithoutTypePkg = JavaCodeSnippetGen.getJavaAttributeDefinition(null, UtilConstants.STRING_DATA_TYPE, YANG_NAME,
-                                                                                       false, UtilConstants.PRIVATE, null);
+        String attributeWithoutTypePkg =
+                getJavaAttributeDefinition(null, UtilConstants.STRING_DATA_TYPE, YANG_NAME,
+                                           false, UtilConstants.PRIVATE, null);
         assertThat(true, is(attributeWithoutTypePkg.contains(
-                UtilConstants.PRIVATE + UtilConstants.SPACE + UtilConstants.STRING_DATA_TYPE + UtilConstants.SPACE + YANG_NAME + UtilConstants.SEMI_COLON + UtilConstants.NEW_LINE)));
+                UtilConstants.PRIVATE + UtilConstants.SPACE + UtilConstants.STRING_DATA_TYPE +
+                        UtilConstants.SPACE + YANG_NAME + UtilConstants.SEMI_COLON + UtilConstants.NEW_LINE)));
 
-        String attributeWithTypePkg = JavaCodeSnippetGen.getJavaAttributeDefinition(UtilConstants.JAVA_LANG, UtilConstants.STRING_DATA_TYPE, YANG_NAME,
-                                                                                    false, UtilConstants.PRIVATE, null);
-        assertThat(true, is(attributeWithTypePkg.contains(UtilConstants.PRIVATE + UtilConstants.SPACE + UtilConstants.JAVA_LANG + UtilConstants.PERIOD
-                                                                  + UtilConstants.STRING_DATA_TYPE + UtilConstants.SPACE + YANG_NAME + UtilConstants.SEMI_COLON + UtilConstants.NEW_LINE)));
+        String attributeWithTypePkg =
+                getJavaAttributeDefinition(UtilConstants.JAVA_LANG, UtilConstants.STRING_DATA_TYPE, YANG_NAME,
+                                           false, UtilConstants.PRIVATE, null);
+        assertThat(true, is(attributeWithTypePkg.contains(UtilConstants.PRIVATE + UtilConstants.SPACE +
+                                                                  UtilConstants.JAVA_LANG + UtilConstants.PERIOD +
+                                                                  UtilConstants.STRING_DATA_TYPE +
+                                                                  UtilConstants.SPACE + YANG_NAME +
+                                                                  UtilConstants.SEMI_COLON + UtilConstants.NEW_LINE)));
 
-        String attributeWithListPkg = JavaCodeSnippetGen.getJavaAttributeDefinition(UtilConstants.JAVA_LANG, UtilConstants.STRING_DATA_TYPE, YANG_NAME,
-                                                                                    true, UtilConstants.PRIVATE, null);
+        String attributeWithListPkg =
+                getJavaAttributeDefinition(UtilConstants.JAVA_LANG, UtilConstants.STRING_DATA_TYPE, YANG_NAME,
+                                           true, UtilConstants.PRIVATE, null);
         assertThat(true, is(attributeWithListPkg.contains(
-                UtilConstants.PRIVATE + UtilConstants.SPACE + UtilConstants.LIST + UtilConstants.DIAMOND_OPEN_BRACKET + UtilConstants.JAVA_LANG + UtilConstants.PERIOD + UtilConstants.STRING_DATA_TYPE
-                        + UtilConstants.DIAMOND_CLOSE_BRACKET + UtilConstants.SPACE + YANG_NAME)));
+                UtilConstants.PRIVATE + UtilConstants.SPACE + UtilConstants.LIST +
+                        UtilConstants.DIAMOND_OPEN_BRACKET + UtilConstants.JAVA_LANG +
+                        UtilConstants.PERIOD + UtilConstants.STRING_DATA_TYPE +
+                        UtilConstants.DIAMOND_CLOSE_BRACKET + UtilConstants.SPACE + YANG_NAME)));
 
-        String attributeWithListWithoutPkg = JavaCodeSnippetGen.getJavaAttributeDefinition(null, UtilConstants.STRING_DATA_TYPE, YANG_NAME,
-                                                                                           true, UtilConstants.PRIVATE, null);
+        String attributeWithListWithoutPkg =
+                getJavaAttributeDefinition(null, UtilConstants.STRING_DATA_TYPE, YANG_NAME,
+                                           true, UtilConstants.PRIVATE, null);
         assertThat(true, is(attributeWithListWithoutPkg.contains(
-                UtilConstants.PRIVATE + UtilConstants.SPACE + UtilConstants.LIST + UtilConstants.DIAMOND_OPEN_BRACKET + UtilConstants.STRING_DATA_TYPE + UtilConstants.DIAMOND_CLOSE_BRACKET + UtilConstants.SPACE
-                        + YANG_NAME)));
+                UtilConstants.PRIVATE + UtilConstants.SPACE + UtilConstants.LIST +
+                        UtilConstants.DIAMOND_OPEN_BRACKET + UtilConstants.STRING_DATA_TYPE +
+                        UtilConstants.DIAMOND_CLOSE_BRACKET + UtilConstants.SPACE + YANG_NAME)));
     }
 }
diff --git a/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaIdentifierSyntaxTest.java b/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaIdentifierSyntaxTest.java
index d21cfba..9dc4826 100644
--- a/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaIdentifierSyntaxTest.java
+++ b/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/JavaIdentifierSyntaxTest.java
@@ -149,7 +149,8 @@
         conflictResolver.setPrefixForIdentifier(null);
         String rootPackage = getRootPackage((byte) 1, CHILD_PACKAGE, getYangRevision(DATE1), conflictResolver);
         assertThat(rootPackage.equals(UtilConstants.DEFAULT_BASE_PKG + UtilConstants.PERIOD + VERSION_NUMBER
-                                              + UtilConstants.PERIOD + CHILD_WITH_PERIOD + UtilConstants.PERIOD + DATE_WITH_REV1), is(true));
+                                              + UtilConstants.PERIOD + CHILD_WITH_PERIOD +
+                                              UtilConstants.PERIOD + DATE_WITH_REV1), is(true));
     }
 
     /**
@@ -173,19 +174,23 @@
             throws ParseException {
         conflictResolver.setPrefixForIdentifier(VALID_PREFIX);
         String rootPackage = getRootPackage((byte) 1, INVALID_NAME_SPACE1, getYangRevision(DATE1), conflictResolver);
-        assertThat(rootPackage.equals(UtilConstants.DEFAULT_BASE_PKG + UtilConstants.PERIOD + VERSION_NUMBER
-                                              + UtilConstants.PERIOD + VALID_NAME_SPACE1 + UtilConstants.PERIOD + DATE_WITH_REV1), is(true));
+        assertThat(rootPackage.equals(UtilConstants.DEFAULT_BASE_PKG + UtilConstants.PERIOD + VERSION_NUMBER +
+                                              UtilConstants.PERIOD + VALID_NAME_SPACE1 +
+                                              UtilConstants.PERIOD + DATE_WITH_REV1), is(true));
         conflictResolver.setPrefixForIdentifier(null);
         String rootPackage1 = getRootPackage((byte) 1, INVALID_NAME_SPACE2, getYangRevision(DATE1), conflictResolver);
         assertThat(rootPackage1.equals(UtilConstants.DEFAULT_BASE_PKG + UtilConstants.PERIOD + VERSION_NUMBER
-                                               + UtilConstants.PERIOD + VALID_NAME_SPACE2 + UtilConstants.PERIOD + DATE_WITH_REV1), is(true));
+                                               + UtilConstants.PERIOD + VALID_NAME_SPACE2 + UtilConstants.PERIOD
+                                               + DATE_WITH_REV1), is(true));
         String rootPackage2 = getRootPackage((byte) 1, INVALID_NAME_SPACE3, getYangRevision(DATE1), conflictResolver);
         assertThat(rootPackage2.equals(UtilConstants.DEFAULT_BASE_PKG + UtilConstants.PERIOD + VERSION_NUMBER
-                                               + UtilConstants.PERIOD + VALID_NAME_SPACE4 + UtilConstants.PERIOD + DATE_WITH_REV1), is(true));
+                                               + UtilConstants.PERIOD + VALID_NAME_SPACE4 + UtilConstants.PERIOD
+                                               + DATE_WITH_REV1), is(true));
         conflictResolver.setPrefixForIdentifier(INVALID_PREFIX1);
         String rootPackage3 = getRootPackage((byte) 1, INVALID_NAME_SPACE2, getYangRevision(DATE1), conflictResolver);
         assertThat(rootPackage3.equals(UtilConstants.DEFAULT_BASE_PKG + UtilConstants.PERIOD + VERSION_NUMBER
-                                               + UtilConstants.PERIOD + VALID_NAME_SPACE3 + UtilConstants.PERIOD + DATE_WITH_REV1), is(true));
+                                               + UtilConstants.PERIOD + VALID_NAME_SPACE3 + UtilConstants.PERIOD
+                                               + DATE_WITH_REV1), is(true));
     }
 
     /**
@@ -197,8 +202,8 @@
         Date date = simpleDateFormat.parse(DATE2);
         String rootPkgWithRev = getRootPackage((byte) 1, CHILD_PACKAGE, getYangRevision(DATE2), null);
         assertThat(rootPkgWithRev.equals(
-                UtilConstants.DEFAULT_BASE_PKG + UtilConstants.PERIOD + VERSION_NUMBER + UtilConstants.PERIOD + CHILD_WITH_PERIOD + UtilConstants.PERIOD + DATE_WITH_REV2),
-                   is(true));
+                UtilConstants.DEFAULT_BASE_PKG + UtilConstants.PERIOD + VERSION_NUMBER + UtilConstants.PERIOD +
+                        CHILD_WITH_PERIOD + UtilConstants.PERIOD + DATE_WITH_REV2), is(true));
     }
 
     /**
diff --git a/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/MethodsGeneratorTest.java b/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/MethodsGeneratorTest.java
index 75ad047..3ac56d5 100644
--- a/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/MethodsGeneratorTest.java
+++ b/compiler/base/translator/src/test/java/org/onosproject/yang/compiler/translator/tojava/utils/MethodsGeneratorTest.java
@@ -32,6 +32,7 @@
 import static org.hamcrest.core.IsNot.not;
 import static org.junit.Assert.assertThat;
 import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.STRING;
+import static org.onosproject.yang.compiler.translator.tojava.utils.MethodsGenerator.*;
 
 /**
  * Unit tests for generated methods from the file type.
@@ -107,7 +108,8 @@
         assertThat(true, is(method.equals(
                 UtilConstants.EIGHT_SPACE_INDENTATION + UtilConstants.CHECK_NOT_NULL_STRING +
                         UtilConstants.OPEN_PARENTHESIS + CLASS_NAME + UtilConstants.COMMA + UtilConstants.SPACE +
-                        CLASS_NAME + UtilConstants.CLOSE_PARENTHESIS + UtilConstants.SEMI_COLON + UtilConstants.NEW_LINE)));
+                        CLASS_NAME + UtilConstants.CLOSE_PARENTHESIS + UtilConstants.SEMI_COLON +
+                        UtilConstants.NEW_LINE)));
     }
 
     /**
@@ -132,8 +134,8 @@
         assertThat(true, is(method.equals(
                 UtilConstants.TWELVE_SPACE_INDENTATION + UtilConstants.PERIOD + UtilConstants.ADD_STRING +
                         UtilConstants.OPEN_PARENTHESIS + UtilConstants.QUOTES + testAttr.getAttributeName() +
-                        UtilConstants.QUOTES + UtilConstants.COMMA + UtilConstants.SPACE + testAttr.getAttributeName() +
-                        UtilConstants.CLOSE_PARENTHESIS)));
+                        UtilConstants.QUOTES + UtilConstants.COMMA + UtilConstants.SPACE +
+                        testAttr.getAttributeName() + UtilConstants.CLOSE_PARENTHESIS)));
     }
 
     /**
@@ -154,8 +156,9 @@
     @Test
     public void getGetterForClassTest() {
         JavaAttributeInfo testAttr = getTestAttribute();
-        String method = MethodsGenerator.getGetterForClass(testAttr, GeneratedJavaFileType.GENERATE_SERVICE_AND_MANAGER);
-        assertThat(true, is(method.contains(UtilConstants.PUBLIC + UtilConstants.SPACE + UtilConstants.STRING_DATA_TYPE +
+        String method = getGetterForClass(testAttr, GeneratedJavaFileType.GENERATE_SERVICE_AND_MANAGER);
+        assertThat(true, is(method.contains(UtilConstants.PUBLIC + UtilConstants.SPACE +
+                                                    UtilConstants.STRING_DATA_TYPE +
                                                     UtilConstants.SPACE + UtilConstants.GET_METHOD_PREFIX)));
     }
 
@@ -164,8 +167,8 @@
      */
     @Test
     public void getGetterForInterfaceTest() {
-        String method = MethodsGenerator.getGetterForInterface(CLASS_NAME, UtilConstants.STRING_DATA_TYPE, false,
-                                                               GeneratedJavaFileType.GENERATE_SERVICE_AND_MANAGER, null);
+        String method = getGetterForInterface(CLASS_NAME, UtilConstants.STRING_DATA_TYPE, false,
+                                              GeneratedJavaFileType.GENERATE_SERVICE_AND_MANAGER, null);
         assertThat(true, is(method.contains(UtilConstants.STRING_DATA_TYPE + UtilConstants.SPACE +
                                                     UtilConstants.GET_METHOD_PREFIX)));
     }
@@ -176,10 +179,10 @@
     @Test
     public void getSetterForClassTest() {
         JavaAttributeInfo testAttr = getTestAttribute();
-        String method = MethodsGenerator.getSetterForClass(testAttr, CLASS_NAME,
-                                                           GeneratedJavaFileType.GENERATE_SERVICE_AND_MANAGER);
+        String method = getSetterForClass(testAttr, CLASS_NAME, GeneratedJavaFileType.GENERATE_SERVICE_AND_MANAGER);
         assertThat(true, is(
-                method.contains(UtilConstants.PUBLIC + UtilConstants.SPACE + UtilConstants.VOID + UtilConstants.SPACE + UtilConstants.SET_METHOD_PREFIX +
+                method.contains(UtilConstants.PUBLIC + UtilConstants.SPACE + UtilConstants.VOID +
+                                        UtilConstants.SPACE + UtilConstants.SET_METHOD_PREFIX +
                                         CLASS_NAME + UtilConstants.OPEN_PARENTHESIS +
                                         UtilConstants.STRING_DATA_TYPE + UtilConstants.SPACE +
                                         ATTRIBUTE_NAME)));
@@ -190,11 +193,11 @@
      */
     @Test
     public void getSetterForInterfaceTest() {
-        String method = MethodsGenerator.getSetterForInterface(CLASS_NAME, UtilConstants.STRING_DATA_TYPE,
-                                                               CLASS_NAME, false,
-                                                               GeneratedJavaFileType.GENERATE_SERVICE_AND_MANAGER, null);
-        assertThat(true, is(method.contains(UtilConstants.VOID + UtilConstants.SPACE + UtilConstants.SET_METHOD_PREFIX +
-                                                    CLASS_NAME)));
+        String method = getSetterForInterface(CLASS_NAME, UtilConstants.STRING_DATA_TYPE,
+                                              CLASS_NAME, false,
+                                              GeneratedJavaFileType.GENERATE_SERVICE_AND_MANAGER, null);
+        assertThat(true, is(method.contains(UtilConstants.VOID + UtilConstants.SPACE +
+                                                    UtilConstants.SET_METHOD_PREFIX + CLASS_NAME)));
     }
 
     /**
@@ -205,8 +208,9 @@
         JavaAttributeInfo testAttr = getTestAttribute();
         String method = MethodsGenerator.getOfMethodStringAndJavaDoc(testAttr, CLASS_NAME);
         assertThat(true, is(method.contains(
-                UtilConstants.PUBLIC + UtilConstants.SPACE + UtilConstants.STATIC + UtilConstants.SPACE + CLASS_NAME + UtilConstants.SPACE + UtilConstants.OF +
-                        UtilConstants.OPEN_PARENTHESIS + UtilConstants.STRING_DATA_TYPE + UtilConstants.SPACE + UtilConstants.VALUE +
+                UtilConstants.PUBLIC + UtilConstants.SPACE + UtilConstants.STATIC + UtilConstants.SPACE + CLASS_NAME +
+                        UtilConstants.SPACE + UtilConstants.OF + UtilConstants.OPEN_PARENTHESIS +
+                        UtilConstants.STRING_DATA_TYPE + UtilConstants.SPACE + UtilConstants.VALUE +
                         UtilConstants.CLOSE_PARENTHESIS)));
     }
 
@@ -217,8 +221,8 @@
     public void getSetterForTypeDefClassTest() {
         JavaAttributeInfo testAttr = getTestAttribute();
         String method = MethodsGenerator.getSetterForTypeDefClass(testAttr);
-        assertThat(true, is(method.contains(UtilConstants.PUBLIC + UtilConstants.SPACE + UtilConstants.VOID + UtilConstants.SPACE +
-                                                    UtilConstants.SET_METHOD_PREFIX)));
+        assertThat(true, is(method.contains(UtilConstants.PUBLIC + UtilConstants.SPACE + UtilConstants.VOID +
+                                                    UtilConstants.SPACE + UtilConstants.SET_METHOD_PREFIX)));
     }
 
     /**
diff --git a/compiler/base/utils/src/main/java/org/onosproject/yang/compiler/utils/UtilConstants.java b/compiler/base/utils/src/main/java/org/onosproject/yang/compiler/utils/UtilConstants.java
index 8659dd8..e62f284 100644
--- a/compiler/base/utils/src/main/java/org/onosproject/yang/compiler/utils/UtilConstants.java
+++ b/compiler/base/utils/src/main/java/org/onosproject/yang/compiler/utils/UtilConstants.java
@@ -1804,7 +1804,7 @@
      */
     public static final String CAMEL_CLASS = "Class";
 
-	/*
+    /**
      * Default meta data path.
      */
     public static final String DEFAULT_JAR_RES_PATH = SLASH + TEMP + SLASH +
diff --git a/compiler/base/utils/src/main/java/org/onosproject/yang/compiler/utils/io/impl/YangIoUtils.java b/compiler/base/utils/src/main/java/org/onosproject/yang/compiler/utils/io/impl/YangIoUtils.java
index f284c7d..2c5c974 100644
--- a/compiler/base/utils/src/main/java/org/onosproject/yang/compiler/utils/io/impl/YangIoUtils.java
+++ b/compiler/base/utils/src/main/java/org/onosproject/yang/compiler/utils/io/impl/YangIoUtils.java
@@ -824,8 +824,7 @@
             prefixForIdentifier = conflictResolver.getPrefixForIdentifier();
         }
         if (prefixForIdentifier != null) {
-            prefixForIdentifier = prefixForIdentifier.replaceAll
-                    (REGEX_WITH_ALL_SPECIAL_CHAR, COLON);
+            prefixForIdentifier = prefixForIdentifier.replaceAll(REGEX_WITH_ALL_SPECIAL_CHAR, COLON);
             String[] strArray = prefixForIdentifier.split(COLON);
             try {
                 if (strArray[0].isEmpty()) {
diff --git a/compiler/base/utils/src/test/java/org/onosproject/yang/compiler/utils/UtilConstantsTest.java b/compiler/base/utils/src/test/java/org/onosproject/yang/compiler/utils/UtilConstantsTest.java
index 7e9c8ce..8c5de5c 100644
--- a/compiler/base/utils/src/test/java/org/onosproject/yang/compiler/utils/UtilConstantsTest.java
+++ b/compiler/base/utils/src/test/java/org/onosproject/yang/compiler/utils/UtilConstantsTest.java
@@ -19,7 +19,6 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
-import org.onosproject.yang.compiler.utils.UtilConstants;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
diff --git a/compiler/base/utils/src/test/java/org/onosproject/yang/compiler/utils/io/impl/CopyrightHeaderTest.java b/compiler/base/utils/src/test/java/org/onosproject/yang/compiler/utils/io/impl/CopyrightHeaderTest.java
index e29240f..0d489d0 100644
--- a/compiler/base/utils/src/test/java/org/onosproject/yang/compiler/utils/io/impl/CopyrightHeaderTest.java
+++ b/compiler/base/utils/src/test/java/org/onosproject/yang/compiler/utils/io/impl/CopyrightHeaderTest.java
@@ -19,7 +19,6 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
-import org.onosproject.yang.compiler.utils.io.impl.CopyrightHeader;
 
 import java.io.File;
 import java.io.FileInputStream;
diff --git a/compiler/plugin/buck/src/main/java/org/onosproject/yang/compiler/plugin/buck/YangLibraryDescription.java b/compiler/plugin/buck/src/main/java/org/onosproject/yang/compiler/plugin/buck/YangLibraryDescription.java
index dc088dd..3388820 100644
--- a/compiler/plugin/buck/src/main/java/org/onosproject/yang/compiler/plugin/buck/YangLibraryDescription.java
+++ b/compiler/plugin/buck/src/main/java/org/onosproject/yang/compiler/plugin/buck/YangLibraryDescription.java
@@ -120,7 +120,8 @@
                                 .add(yangLib)
 //                                .addAll(deps)
                                 //FIXME remove when we figure out compile time deps
-                                .addAll((args.deps.or(ImmutableSortedSet.<BuildTarget>of())).stream().map(resolver::getRule).collect(Collectors.toList()))
+                                .addAll((args.deps.or(ImmutableSortedSet.<BuildTarget>of())).
+                                        stream().map(resolver::getRule).collect(Collectors.toList()))
 //                                .addAll(BuildRules.getExportedRules(deps))
                                 .addAll(pathResolver.filterBuildRuleInputs(javacOptions.getInputs(pathResolver)))
                                 .build()),
diff --git a/compiler/plugin/buck/src/main/java/org/onosproject/yang/compiler/plugin/buck/YangParsingException.java b/compiler/plugin/buck/src/main/java/org/onosproject/yang/compiler/plugin/buck/YangParsingException.java
index c4b9461..c145361 100644
--- a/compiler/plugin/buck/src/main/java/org/onosproject/yang/compiler/plugin/buck/YangParsingException.java
+++ b/compiler/plugin/buck/src/main/java/org/onosproject/yang/compiler/plugin/buck/YangParsingException.java
@@ -25,7 +25,7 @@
      * Creates a YangParsingException based on another exception.
      * @param t exception from the parser
      */
-    public YangParsingException (Throwable t) {
+    public YangParsingException(Throwable t) {
         super(t);
     }
 
diff --git a/compiler/plugin/buck/src/main/java/org/onosproject/yang/compiler/plugin/buck/package-info.java b/compiler/plugin/buck/src/main/java/org/onosproject/yang/compiler/plugin/buck/package-info.java
new file mode 100644
index 0000000..2e29e18
--- /dev/null
+++ b/compiler/plugin/buck/src/main/java/org/onosproject/yang/compiler/plugin/buck/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2017-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Buck plugin for compiling YANG models.
+ */
+package org.onosproject.yang.compiler.plugin.buck;
\ No newline at end of file
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterFileDeviationLinkingTest.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterFileDeviationLinkingTest.java
index 69eed20..bcdbce3 100644
--- a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterFileDeviationLinkingTest.java
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterFileDeviationLinkingTest.java
@@ -177,8 +177,8 @@
         assertThat(lisfOfLeaf.isEmpty(), is(true));
         assertThat(deviationValid.getNextSibling(), nullValue());
 
-        assertThat(testValid.getYangSchemaNodeIdentifier(), is
-                (deviationValid.getYangSchemaNodeIdentifier()));
+        assertThat(testValid.getYangSchemaNodeIdentifier(),
+                   is(deviationValid.getYangSchemaNodeIdentifier()));
 
         JavaFileInfoTranslator deviateJavaFile = ((JavaFileInfoContainer)
                 deviationValid).getJavaFileInfo();
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterJarLinkerTest.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterJarLinkerTest.java
index 9d767e8..b5b0a9e 100644
--- a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterJarLinkerTest.java
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterJarLinkerTest.java
@@ -281,8 +281,7 @@
             dir.delete();
         }
         dir.mkdirs();
-        FileOutputStream fileOutputStream = new FileOutputStream
-                (serFileDirPath + YANG_META_DATA);
+        FileOutputStream fileOutputStream = new FileOutputStream(serFileDirPath + YANG_META_DATA);
         ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
         objectOutputStream.writeObject(utilManager.getYangNodeSet());
         objectOutputStream.close();
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileLeafrefLinking2Test.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileLeafrefLinking2Test.java
new file mode 100644
index 0000000..5a61086
--- /dev/null
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileLeafrefLinking2Test.java
@@ -0,0 +1,1003 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.yang.compiler.plugin.maven;
+
+import org.hamcrest.core.Is;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.onosproject.yang.compiler.datamodel.YangContainer;
+import org.onosproject.yang.compiler.datamodel.YangInput;
+import org.onosproject.yang.compiler.datamodel.YangLeaf;
+import org.onosproject.yang.compiler.datamodel.YangLeafList;
+import org.onosproject.yang.compiler.datamodel.YangLeafRef;
+import org.onosproject.yang.compiler.datamodel.YangModule;
+import org.onosproject.yang.compiler.datamodel.YangNode;
+import org.onosproject.yang.compiler.datamodel.YangNodeType;
+import org.onosproject.yang.compiler.datamodel.utils.ResolvableStatus;
+import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
+import org.onosproject.yang.compiler.linker.exceptions.LinkerException;
+import org.onosproject.yang.compiler.linker.impl.YangLinkerManager;
+import org.onosproject.yang.compiler.linker.impl.YangLinkerUtils;
+import org.onosproject.yang.compiler.parser.exceptions.ParserException;
+import org.onosproject.yang.compiler.parser.impl.YangUtilsParserManager;
+import org.onosproject.yang.compiler.tool.impl.YangCompilerManager;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.ListIterator;
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.onosproject.yang.compiler.utils.io.impl.YangFileScanner.getYangFiles;
+
+/**
+ * Test cases for testing leafref intra file linking.
+ */
+public class IntraFileLeafrefLinking2Test {
+
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+    private final YangCompilerManager utilManager =
+            new YangCompilerManager();
+    private final YangLinkerManager yangLinkerManager = new YangLinkerManager();
+    private final YangUtilsParserManager manager = new YangUtilsParserManager();
+
+    /**
+     * Checks self resolution when leafref under module refers to leaf in container.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefReferToContainerLeaf()
+            throws IOException, ParserException {
+
+        String searchDir = "src/test/resources/leafreflinker/intrafile/simpleleafref";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("SelfResolutionWhenLeafrefReferToContainerLeaf")) {
+            selfNode = rootNode;
+        }
+
+        // Check whether the data model tree returned is of type module.
+        assertThat((selfNode instanceof YangModule), is(true));
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+        assertThat(yangNode.getName(), is("SelfResolutionWhenLeafrefReferToContainerLeaf"));
+
+        ListIterator<YangLeaf> leafIterator;
+        YangLeaf leafInfo;
+
+        leafIterator = yangNode.getListOfLeaf().listIterator();
+        leafInfo = leafIterator.next();
+
+        // Check whether the information in the leaf is correct.
+        assertThat(leafInfo.getName(), is("network-ref"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
+        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
+
+        // Check whether leafref type got resolved.
+        assertThat(leafref.getResolvableStatus(),
+                   Is.is(ResolvableStatus.RESOLVED));
+
+        // Check the effective type for the leaf.
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.UINT8));
+    }
+
+    /**
+     * Checks self resolution when leafref under module refers to leaf in input of rpc.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefInModuleReferToLeafInInputOfRpc()
+            throws IOException, ParserException {
+
+        String searchDir = "src/test/resources/leafreflinker/intrafile/leafrefwithrpc";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("SelfResolutionWhenLeafrefInModuleReferToLeafInInputOfRpc")) {
+            selfNode = rootNode;
+        }
+
+        // Check whether the data model tree returned is of type module.
+        assertThat((selfNode instanceof YangModule), is(true));
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+        assertThat(yangNode.getName(), is("SelfResolutionWhenLeafrefInModuleReferToLeafInInputOfRpc"));
+
+        ListIterator<YangLeaf> leafIterator;
+        YangLeaf leafInfo;
+
+        leafIterator = yangNode.getListOfLeaf().listIterator();
+        leafInfo = leafIterator.next();
+
+        // Check whether the information in the leaf is correct.
+        assertThat(leafInfo.getName(), is("network-ref"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
+        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
+
+        // Check whether leafref type got resolved.
+        assertThat(leafref.getResolvableStatus(),
+                   is(ResolvableStatus.RESOLVED));
+
+        // Check the effective type for the leaf.
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.UINT8));
+    }
+
+    /**
+     * Checks self resolution when leafref under module refers to grouping rpc with input as name.
+     * Rpc has input child also. So here the node search must be done by taking input node.
+     * TODO: When path has RPC's input but grouping & typedef with the same name occurs.
+     */
+    @Ignore
+    public void processSelfResolutionWhenLeafrefInModuleReferToGroupingWithInputInRpc()
+            throws IOException, ParserException {
+
+        String searchDir = "src/test/resources/leafreflinker/intrafile/leafrefwithrpcandgrouping";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("SelfResolutionWhenLeafrefInModuleReferToGroupingWithInputInRpc")) {
+            selfNode = rootNode;
+        }
+
+        // Check whether the data model tree returned is of type module.
+        assertThat((selfNode instanceof YangModule), is(true));
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+        assertThat(yangNode.getName(), is("SelfResolutionWhenLeafrefInModuleReferToGroupingWithInputInRpc"));
+
+        ListIterator<YangLeaf> leafIterator;
+        YangLeaf leafInfo;
+
+        leafIterator = yangNode.getListOfLeaf().listIterator();
+        leafInfo = leafIterator.next();
+
+        // Check whether the information in the leaf is correct.
+        assertThat(leafInfo.getName(), is("network-ref"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
+        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
+
+        // Check whether leafref type got resolved.
+        assertThat(leafref.getResolvableStatus(),
+                   is(ResolvableStatus.RESOLVED));
+
+        // Check the effective type for the leaf.
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.UINT8));
+    }
+
+    /**
+     * Checks self resolution when leafref under module refers to grouping under module.
+     * Grouping/typedef cannot be referred.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefInModuleReferToGrouping()
+            throws IOException, ParserException {
+/*
+        thrown.expect(LinkerException.class);
+        thrown.expectMessage(
+                "YANG file error: The target node, in the leafref path /networks/network-id, is invalid.");
+*/
+        String searchDir = "src/test/resources/leafreflinker/intrafile/invalidscenerioforgrouping";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+    }
+
+    /**
+     * Checks self resolution error scenerio where leafref is without path.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefDoesntHavePath()
+            throws IOException, ParserException {
+
+        thrown.expect(ParserException.class);
+        thrown.expectMessage(
+                "YANG file error : a type leafref must have one path statement.");
+        YangNode node = manager
+                .getDataModel("src/test/resources/SelfResolutionWhenLeafrefDoesntHavePath.yang");
+    }
+
+    /**
+     * Checks self resolution when leafref under module refers to invalid node.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefInModuleReferToInvalidNode()
+            throws IOException, ParserException {
+
+        thrown.expect(LinkerException.class);
+        thrown.expectMessage(
+                "YANG file error: Unable to find base leaf/leaf-list for given leafref path /define/network-id");
+        String searchDir = "src/test/resources/leafreflinker/intrafile/invalidsceneriowithinvalidnode";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+    }
+
+    /**
+     * Checks self resolution when leafref under module refers to invalid node.
+     * Inter file linking also has to be done to know the error message.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefIsInDeepTreeAndLeafIsInModuleWithReferredTypeUnion()
+            throws IOException, ParserException {
+
+        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreflinking";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("Test")) {
+            selfNode = rootNode;
+        }
+
+        // Check whether the data model tree returned is of type module.
+        assertThat((selfNode instanceof YangModule), is(true));
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+        assertThat(yangNode.getName(), is("Test"));
+
+        YangContainer containerParent = (YangContainer) yangNode.getChild().getChild().getChild();
+        ListIterator<YangLeaf> leafIterator;
+        YangLeaf leafInfo;
+
+        leafIterator = containerParent.getListOfLeaf().listIterator();
+        leafInfo = leafIterator.next();
+
+        // Check whether the information in the leaf is correct.
+        assertThat(leafInfo.getName(), is("name"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
+        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
+
+        // Check whether leafref type got resolved.
+        assertThat(leafref.getResolvableStatus(),
+                   is(ResolvableStatus.RESOLVED));
+
+        // Check the effective type for the leaf.
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.UNION));
+    }
+
+    /**
+     * Checks self resolution when leafref of leaf-list under module refers to leaf in container.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefReferToContainerLeafList()
+            throws IOException, ParserException {
+
+        String searchDir = "src/test/resources/leafreflinker/intrafile/leafrefreferingtoleaflist";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("ietf-network")) {
+            selfNode = rootNode;
+        }
+
+        // Check whether the data model tree returned is of type module.
+        assertThat((selfNode instanceof YangModule), is(true));
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+        assertThat(yangNode.getName(), is("ietf-network"));
+
+        ListIterator<YangLeafList> leafListIterator;
+        YangLeafList leafListInfo;
+
+        leafListIterator = yangNode.getListOfLeafList().listIterator();
+        leafListInfo = leafListIterator.next();
+
+        // Check whether the information in the leaf is correct.
+        assertThat(leafListInfo.getName(), is("network-ref"));
+        assertThat(leafListInfo.getDataType().getDataTypeName(), is("leafref"));
+        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+        YangLeafRef leafref = (YangLeafRef) (leafListInfo.getDataType().getDataTypeExtendedInfo());
+
+        // Check whether leafref type got resolved.
+        assertThat(leafref.getResolvableStatus(),
+                   is(ResolvableStatus.RESOLVED));
+
+        // Check the effective type for the leaf.
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.UINT8));
+    }
+
+    /**
+     * Checks self resolution when leafref of leaf-list under module refers to leaf-list in input of rpc.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefInModuleReferToLeafListInInputOfRpc()
+            throws IOException, ParserException {
+
+        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreftoinputinrpc";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("ietf-network")) {
+            selfNode = rootNode;
+        }
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+        assertThat(yangNode.getName(), is("ietf-network"));
+
+        ListIterator<YangLeafList> leafListIterator;
+        YangLeafList leafListInfo;
+
+        leafListIterator = yangNode.getListOfLeafList().listIterator();
+        leafListInfo = leafListIterator.next();
+
+        // Check whether the information in the leaf is correct.
+        assertThat(leafListInfo.getName(), is("network-ref"));
+        assertThat(leafListInfo.getDataType().getDataTypeName(), is("leafref"));
+        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+        YangLeafRef leafref = (YangLeafRef) (leafListInfo.getDataType().getDataTypeExtendedInfo());
+
+        // Check whether leafref type got resolved.
+        assertThat(leafref.getResolvableStatus(),
+                   is(ResolvableStatus.RESOLVED));
+
+        // Check the effective type for the leaf.
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.UINT8));
+    }
+
+    /**
+     * Checks self resolution when leafref of leaf-list under module refers to invalid node.
+     * Inter file linking also has to be done to know the error message.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefIsInDeepTreeAndLeafListIsInModuleWithReferredTypeEnumeration()
+            throws IOException, ParserException {
+
+        String searchDir = "src/test/resources/leafreflinker/intrafile/leafrefwithrefleafderived";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("Test")) {
+            selfNode = rootNode;
+        }
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+
+        assertThat(yangNode.getName(), is("Test"));
+
+        YangContainer containerParent = (YangContainer) yangNode.getChild().getChild().getChild();
+        ListIterator<YangLeafList> leafListListIterator;
+        YangLeafList leafListInfo;
+
+        leafListListIterator = containerParent.getListOfLeafList().listIterator();
+        leafListInfo = leafListListIterator.next();
+
+        // Check whether the information in the leaf is correct.
+        assertThat(leafListInfo.getName(), is("name"));
+        assertThat(leafListInfo.getDataType().getDataTypeName(), is("leafref"));
+        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+        YangLeafRef leafref = (YangLeafRef) (leafListInfo.getDataType().getDataTypeExtendedInfo());
+
+        // Check whether leafref type got resolved.
+        assertThat(leafref.getResolvableStatus(),
+                   is(ResolvableStatus.RESOLVED));
+
+        // Check the effective type for the leaf.
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.ENUMERATION));
+    }
+
+    /**
+     * Checks the error scenerio when the referred node is not a leaf or leaf-list.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefDoesNotReferToLeafOrLeafList()
+            throws IOException, ParserException {
+
+        thrown.expect(LinkerException.class);
+        thrown.expectMessage(
+                "YANG file error: Unable to find base leaf/leaf-list for given leafref path /networks");
+        String searchDir = "src/test/resources/leafreflinker/intrafile/invalidsceneriowithnorefleaf";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+    }
+
+    /**
+     * Checks self resolution when leafref of leaf-list under module refers to leaf in container.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefInTypedefReferToContainer()
+            throws IOException, ParserException {
+        String searchDir = "src/test/resources/leafreflinker/intrafile/leafrefintypedef";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("ietf-network")) {
+            selfNode = rootNode;
+        }
+        // Check whether the data model tree returned is of type module.
+        assertThat((selfNode instanceof YangModule), is(true));
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+        assertThat(yangNode.getName(), is("ietf-network"));
+
+        YangContainer yangContainer = (YangContainer) yangNode.getChild();
+        ListIterator<YangLeaf> leafIterator;
+        YangLeaf leafInfo;
+        leafIterator = yangContainer.getListOfLeaf().listIterator();
+        leafInfo = leafIterator.next();
+
+        // Check whether the information in the leaf is correct under grouping.
+        assertThat(leafInfo.getName(), is("network-id"));
+        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+
+        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
+
+        // Check whether leafref type got resolved.
+        assertThat(leafref.getResolvableStatus(),
+                   is(ResolvableStatus.RESOLVED));
+
+        // Check the effective type for the leaf.
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.UINT8));
+    }
+
+    /**
+     * Checks self resolution when leafref of leaf-list under module refers to leaf-list in input of rpc.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefInTypedefModuleReferToLeafListInInputOfRpc()
+            throws IOException, ParserException {
+
+        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreftorpcinputleaflist";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("ietf-network")) {
+            selfNode = rootNode;
+        }
+        // Check whether the data model tree returned is of type module.
+        assertThat((selfNode instanceof YangModule), is(true));
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+        assertThat(yangNode.getName(), is("ietf-network"));
+
+        YangInput yangInput = (YangInput) yangNode.getChild().getChild();
+
+        ListIterator<YangLeafList> leafListIterator;
+        YangLeafList yangLeafListInfo;
+        leafListIterator = yangInput.getListOfLeafList().listIterator();
+        yangLeafListInfo = leafListIterator.next();
+
+        // Check whether the information in the leaf is correct under grouping.
+        assertThat(yangLeafListInfo.getName(), is("network-id"));
+        assertThat(yangLeafListInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+
+        YangLeafRef leafref = (YangLeafRef) (yangLeafListInfo.getDataType().getDataTypeExtendedInfo());
+
+        // Check whether leafref type got resolved.
+        assertThat(leafref.getResolvableStatus(),
+                   is(ResolvableStatus.RESOLVED));
+
+        // Check the effective type for the leaf.
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.UINT8));
+    }
+
+    /**
+     * Checks self resolution when leafref of leaf-list under module refers to invalid node.
+     * Inter file linking also has to be done to know the error message.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefInTypedefIsInDeepTreeAndLeafListIsInModuleWithReferredTypeEnumeration()
+            throws IOException, ParserException {
+
+        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreftoleafrefwithtypedef";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("Test")) {
+            selfNode = rootNode;
+        }
+        // Check whether the data model tree returned is of type module.
+        assertThat((selfNode instanceof YangModule), is(true));
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+        assertThat(yangNode.getName(), is("Test"));
+
+        YangContainer yangContainer = (YangContainer) yangNode.getChild().getChild().getChild().getNextSibling();
+
+        ListIterator<YangLeaf> leafIterator;
+        YangLeaf yangLeafInfo;
+        leafIterator = yangContainer.getListOfLeaf().listIterator();
+        yangLeafInfo = leafIterator.next();
+
+        // Check whether the information in the leaf is correct under grouping.
+        assertThat(yangLeafInfo.getName(), is("interval"));
+        assertThat(yangLeafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+
+        YangLeafRef leafref = (YangLeafRef) (yangLeafInfo.getDataType().getDataTypeExtendedInfo());
+
+        // Check whether leafref type got resolved.
+        assertThat(leafref.getResolvableStatus(),
+                   is(ResolvableStatus.RESOLVED));
+
+        // Check the effective type for the leaf.
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.ENUMERATION));
+    }
+
+    /**
+     * Checks self resolution when grouping and uses are siblings.
+     * Grouping followed by uses.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefRefersAnotherLeafref()
+            throws IOException, ParserException {
+
+        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreftoleafref";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("ietf-network")) {
+            selfNode = rootNode;
+        }
+        // Check whether the data model tree returned is of type module.
+        assertThat((selfNode instanceof YangModule), is(true));
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+        assertThat(yangNode.getName(), is("ietf-network"));
+
+        ListIterator<YangLeaf> leafIterator;
+        YangLeaf leafInfo;
+
+        //YangGrouping grouping = (YangGrouping) yangNode.getChild().getNextSibling();
+        leafIterator = yangNode.getListOfLeaf().listIterator();
+        leafInfo = leafIterator.next();
+
+        // Check whether the information in the leaf is correct under grouping.
+        assertThat(leafInfo.getName(), is("network-ref"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
+        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
+
+        assertThat(leafref.getResolvableStatus(),
+                   is(ResolvableStatus.RESOLVED));
+
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.UINT8));
+    }
+
+    /**
+     * Checks self resolution when leafref refers to many other leafref.
+     */
+    @Test
+    public void processSelfResolutionWhenLeafrefReferToMultipleLeafref()
+            throws IOException, ParserException {
+
+        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreftomultileafref";
+
+        Set<Path> paths = new HashSet<>();
+        for (String file : getYangFiles(searchDir)) {
+            paths.add(Paths.get(file));
+        }
+
+        utilManager.createYangFileInfoSet(paths);
+        utilManager.parseYangFileInfoSet();
+        utilManager.createYangNodeSet();
+        YangNode selfNode = null;
+        // Create YANG node set
+        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
+
+        // Add references to import list.
+        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
+
+        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
+
+        // Carry out inter-file linking.
+        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
+
+        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
+
+        YangNode rootNode = yangNodeIterator.next();
+
+        if (rootNode.getName().equals("Test")) {
+            selfNode = rootNode;
+        }
+        // Check whether the data model tree returned is of type module.
+        assertThat((selfNode instanceof YangModule), is(true));
+
+        // Check whether the node type is set properly to module.
+        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
+
+        // Check whether the module name is set correctly.
+        YangModule yangNode = (YangModule) selfNode;
+        assertThat(yangNode.getName(), is("Test"));
+
+        YangContainer containerInModule = (YangContainer) yangNode.getChild().getNextSibling();
+        YangContainer containerInList = (YangContainer) containerInModule.getChild().getChild();
+
+        ListIterator<YangLeaf> leafIterator;
+        YangLeaf leafInfo;
+
+        leafIterator = containerInList.getListOfLeaf().listIterator();
+        leafInfo = leafIterator.next();
+
+        // Check whether the information in the leaf is correct under grouping.
+        assertThat(leafInfo.getName(), is("remove"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
+        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
+        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
+
+        assertThat(leafref.getResolvableStatus(),
+                   is(ResolvableStatus.RESOLVED));
+
+        assertThat(leafref.getEffectiveDataType().getDataType(),
+                   is(YangDataTypes.ENUMERATION));
+    }
+
+}
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileLeafrefLinkingTest.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileLeafrefLinkingTest.java
index 906fcb2..8776766 100644
--- a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileLeafrefLinkingTest.java
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileLeafrefLinkingTest.java
@@ -26,9 +26,7 @@
 import org.onosproject.yang.compiler.datamodel.YangContainer;
 import org.onosproject.yang.compiler.datamodel.YangFeature;
 import org.onosproject.yang.compiler.datamodel.YangIfFeature;
-import org.onosproject.yang.compiler.datamodel.YangInput;
 import org.onosproject.yang.compiler.datamodel.YangLeaf;
-import org.onosproject.yang.compiler.datamodel.YangLeafList;
 import org.onosproject.yang.compiler.datamodel.YangLeafRef;
 import org.onosproject.yang.compiler.datamodel.YangList;
 import org.onosproject.yang.compiler.datamodel.YangModule;
@@ -44,7 +42,6 @@
 import org.onosproject.yang.compiler.linker.impl.YangLinkerManager;
 import org.onosproject.yang.compiler.linker.impl.YangLinkerUtils;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
-import org.onosproject.yang.compiler.parser.impl.YangUtilsParserManager;
 import org.onosproject.yang.compiler.tool.impl.YangCompilerManager;
 
 import java.io.IOException;
@@ -71,948 +68,9 @@
     @Rule
     public ExpectedException thrown = ExpectedException.none();
 
-
     private final YangCompilerManager utilManager =
             new YangCompilerManager();
     private final YangLinkerManager yangLinkerManager = new YangLinkerManager();
-    private final YangUtilsParserManager manager = new YangUtilsParserManager();
-
-    /**
-     * Checks self resolution when leafref under module refers to leaf in container.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefReferToContainerLeaf()
-            throws IOException, ParserException {
-
-        String searchDir = "src/test/resources/leafreflinker/intrafile/simpleleafref";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("SelfResolutionWhenLeafrefReferToContainerLeaf")) {
-            selfNode = rootNode;
-        }
-
-        // Check whether the data model tree returned is of type module.
-        assertThat((selfNode instanceof YangModule), is(true));
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-        assertThat(yangNode.getName(), is("SelfResolutionWhenLeafrefReferToContainerLeaf"));
-
-        ListIterator<YangLeaf> leafIterator;
-        YangLeaf leafInfo;
-
-        leafIterator = yangNode.getListOfLeaf().listIterator();
-        leafInfo = leafIterator.next();
-
-        // Check whether the information in the leaf is correct.
-        assertThat(leafInfo.getName(), is("network-ref"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
-
-        // Check whether leafref type got resolved.
-        assertThat(leafref.getResolvableStatus(),
-                   Is.is(ResolvableStatus.RESOLVED));
-
-        // Check the effective type for the leaf.
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.UINT8));
-    }
-
-    /**
-     * Checks self resolution when leafref under module refers to leaf in input of rpc.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefInModuleReferToLeafInInputOfRpc()
-            throws IOException, ParserException {
-
-        String searchDir = "src/test/resources/leafreflinker/intrafile/leafrefwithrpc";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("SelfResolutionWhenLeafrefInModuleReferToLeafInInputOfRpc")) {
-            selfNode = rootNode;
-        }
-
-        // Check whether the data model tree returned is of type module.
-        assertThat((selfNode instanceof YangModule), is(true));
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-        assertThat(yangNode.getName(), is("SelfResolutionWhenLeafrefInModuleReferToLeafInInputOfRpc"));
-
-        ListIterator<YangLeaf> leafIterator;
-        YangLeaf leafInfo;
-
-        leafIterator = yangNode.getListOfLeaf().listIterator();
-        leafInfo = leafIterator.next();
-
-        // Check whether the information in the leaf is correct.
-        assertThat(leafInfo.getName(), is("network-ref"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
-
-        // Check whether leafref type got resolved.
-        assertThat(leafref.getResolvableStatus(),
-                   is(ResolvableStatus.RESOLVED));
-
-        // Check the effective type for the leaf.
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.UINT8));
-    }
-
-    /**
-     * Checks self resolution when leafref under module refers to grouping rpc with input as name.
-     * Rpc has input child also. So here the node search must be done by taking input node.
-     * TODO: When path has RPC's input but grouping & typedef with the same name occurs.
-     */
-    @Ignore
-    public void processSelfResolutionWhenLeafrefInModuleReferToGroupingWithInputInRpc()
-            throws IOException, ParserException {
-
-        String searchDir = "src/test/resources/leafreflinker/intrafile/leafrefwithrpcandgrouping";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("SelfResolutionWhenLeafrefInModuleReferToGroupingWithInputInRpc")) {
-            selfNode = rootNode;
-        }
-
-        // Check whether the data model tree returned is of type module.
-        assertThat((selfNode instanceof YangModule), is(true));
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-        assertThat(yangNode.getName(), is("SelfResolutionWhenLeafrefInModuleReferToGroupingWithInputInRpc"));
-
-        ListIterator<YangLeaf> leafIterator;
-        YangLeaf leafInfo;
-
-        leafIterator = yangNode.getListOfLeaf().listIterator();
-        leafInfo = leafIterator.next();
-
-        // Check whether the information in the leaf is correct.
-        assertThat(leafInfo.getName(), is("network-ref"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
-
-        // Check whether leafref type got resolved.
-        assertThat(leafref.getResolvableStatus(),
-                   is(ResolvableStatus.RESOLVED));
-
-        // Check the effective type for the leaf.
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.UINT8));
-    }
-
-    /**
-     * Checks self resolution when leafref under module refers to grouping under module.
-     * Grouping/typedef cannot be referred.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefInModuleReferToGrouping()
-            throws IOException, ParserException {
-/*
-        thrown.expect(LinkerException.class);
-        thrown.expectMessage(
-                "YANG file error: The target node, in the leafref path /networks/network-id, is invalid.");
-*/
-        String searchDir = "src/test/resources/leafreflinker/intrafile/invalidscenerioforgrouping";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-    }
-
-    /**
-     * Checks self resolution error scenerio where leafref is without path.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefDoesntHavePath()
-            throws IOException, ParserException {
-
-        thrown.expect(ParserException.class);
-        thrown.expectMessage(
-                "YANG file error : a type leafref must have one path statement.");
-        YangNode node = manager
-                .getDataModel("src/test/resources/SelfResolutionWhenLeafrefDoesntHavePath.yang");
-    }
-
-    /**
-     * Checks self resolution when leafref under module refers to invalid node.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefInModuleReferToInvalidNode()
-            throws IOException, ParserException {
-
-        thrown.expect(LinkerException.class);
-        thrown.expectMessage(
-                "YANG file error: Unable to find base leaf/leaf-list for given leafref path /define/network-id");
-        String searchDir = "src/test/resources/leafreflinker/intrafile/invalidsceneriowithinvalidnode";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-    }
-
-    /**
-     * Checks self resolution when leafref under module refers to invalid node.
-     * Inter file linking also has to be done to know the error message.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefIsInDeepTreeAndLeafIsInModuleWithReferredTypeUnion()
-            throws IOException, ParserException {
-
-        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreflinking";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("Test")) {
-            selfNode = rootNode;
-        }
-
-        // Check whether the data model tree returned is of type module.
-        assertThat((selfNode instanceof YangModule), is(true));
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-        assertThat(yangNode.getName(), is("Test"));
-
-        YangContainer containerParent = (YangContainer) yangNode.getChild().getChild().getChild();
-        ListIterator<YangLeaf> leafIterator;
-        YangLeaf leafInfo;
-
-        leafIterator = containerParent.getListOfLeaf().listIterator();
-        leafInfo = leafIterator.next();
-
-        // Check whether the information in the leaf is correct.
-        assertThat(leafInfo.getName(), is("name"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
-
-        // Check whether leafref type got resolved.
-        assertThat(leafref.getResolvableStatus(),
-                   is(ResolvableStatus.RESOLVED));
-
-        // Check the effective type for the leaf.
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.UNION));
-    }
-
-    /**
-     * Checks self resolution when leafref of leaf-list under module refers to leaf in container.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefReferToContainerLeafList()
-            throws IOException, ParserException {
-
-        String searchDir = "src/test/resources/leafreflinker/intrafile/leafrefreferingtoleaflist";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("ietf-network")) {
-            selfNode = rootNode;
-        }
-
-        // Check whether the data model tree returned is of type module.
-        assertThat((selfNode instanceof YangModule), is(true));
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-        assertThat(yangNode.getName(), is("ietf-network"));
-
-        ListIterator<YangLeafList> leafListIterator;
-        YangLeafList leafListInfo;
-
-        leafListIterator = yangNode.getListOfLeafList().listIterator();
-        leafListInfo = leafListIterator.next();
-
-        // Check whether the information in the leaf is correct.
-        assertThat(leafListInfo.getName(), is("network-ref"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("leafref"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-        YangLeafRef leafref = (YangLeafRef) (leafListInfo.getDataType().getDataTypeExtendedInfo());
-
-        // Check whether leafref type got resolved.
-        assertThat(leafref.getResolvableStatus(),
-                   is(ResolvableStatus.RESOLVED));
-
-        // Check the effective type for the leaf.
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.UINT8));
-    }
-
-    /**
-     * Checks self resolution when leafref of leaf-list under module refers to leaf-list in input of rpc.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefInModuleReferToLeafListInInputOfRpc()
-            throws IOException, ParserException {
-
-        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreftoinputinrpc";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("ietf-network")) {
-            selfNode = rootNode;
-        }
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-        assertThat(yangNode.getName(), is("ietf-network"));
-
-        ListIterator<YangLeafList> leafListIterator;
-        YangLeafList leafListInfo;
-
-        leafListIterator = yangNode.getListOfLeafList().listIterator();
-        leafListInfo = leafListIterator.next();
-
-        // Check whether the information in the leaf is correct.
-        assertThat(leafListInfo.getName(), is("network-ref"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("leafref"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-        YangLeafRef leafref = (YangLeafRef) (leafListInfo.getDataType().getDataTypeExtendedInfo());
-
-        // Check whether leafref type got resolved.
-        assertThat(leafref.getResolvableStatus(),
-                   is(ResolvableStatus.RESOLVED));
-
-        // Check the effective type for the leaf.
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.UINT8));
-    }
-
-    /**
-     * Checks self resolution when leafref of leaf-list under module refers to invalid node.
-     * Inter file linking also has to be done to know the error message.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefIsInDeepTreeAndLeafListIsInModuleWithReferredTypeEnumeration()
-            throws IOException, ParserException {
-
-        String searchDir = "src/test/resources/leafreflinker/intrafile/leafrefwithrefleafderived";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("Test")) {
-            selfNode = rootNode;
-        }
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-
-        assertThat(yangNode.getName(), is("Test"));
-
-        YangContainer containerParent = (YangContainer) yangNode.getChild().getChild().getChild();
-        ListIterator<YangLeafList> leafListListIterator;
-        YangLeafList leafListInfo;
-
-        leafListListIterator = containerParent.getListOfLeafList().listIterator();
-        leafListInfo = leafListListIterator.next();
-
-        // Check whether the information in the leaf is correct.
-        assertThat(leafListInfo.getName(), is("name"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("leafref"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-        YangLeafRef leafref = (YangLeafRef) (leafListInfo.getDataType().getDataTypeExtendedInfo());
-
-        // Check whether leafref type got resolved.
-        assertThat(leafref.getResolvableStatus(),
-                   is(ResolvableStatus.RESOLVED));
-
-        // Check the effective type for the leaf.
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.ENUMERATION));
-    }
-
-    /**
-     * Checks the error scenerio when the referred node is not a leaf or leaf-list.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefDoesNotReferToLeafOrLeafList()
-            throws IOException, ParserException {
-
-        thrown.expect(LinkerException.class);
-        thrown.expectMessage(
-                "YANG file error: Unable to find base leaf/leaf-list for given leafref path /networks");
-        String searchDir = "src/test/resources/leafreflinker/intrafile/invalidsceneriowithnorefleaf";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-    }
-
-    /**
-     * Checks self resolution when leafref of leaf-list under module refers to leaf in container.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefInTypedefReferToContainer()
-            throws IOException, ParserException {
-        String searchDir = "src/test/resources/leafreflinker/intrafile/leafrefintypedef";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("ietf-network")) {
-            selfNode = rootNode;
-        }
-        // Check whether the data model tree returned is of type module.
-        assertThat((selfNode instanceof YangModule), is(true));
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-        assertThat(yangNode.getName(), is("ietf-network"));
-
-        YangContainer yangContainer = (YangContainer) yangNode.getChild();
-        ListIterator<YangLeaf> leafIterator;
-        YangLeaf leafInfo;
-        leafIterator = yangContainer.getListOfLeaf().listIterator();
-        leafInfo = leafIterator.next();
-
-        // Check whether the information in the leaf is correct under grouping.
-        assertThat(leafInfo.getName(), is("network-id"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-
-        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
-
-        // Check whether leafref type got resolved.
-        assertThat(leafref.getResolvableStatus(),
-                   is(ResolvableStatus.RESOLVED));
-
-        // Check the effective type for the leaf.
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.UINT8));
-    }
-
-    /**
-     * Checks self resolution when leafref of leaf-list under module refers to leaf-list in input of rpc.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefInTypedefModuleReferToLeafListInInputOfRpc()
-            throws IOException, ParserException {
-
-        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreftorpcinputleaflist";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("ietf-network")) {
-            selfNode = rootNode;
-        }
-        // Check whether the data model tree returned is of type module.
-        assertThat((selfNode instanceof YangModule), is(true));
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-        assertThat(yangNode.getName(), is("ietf-network"));
-
-        YangInput yangInput = (YangInput) yangNode.getChild().getChild();
-
-        ListIterator<YangLeafList> leafListIterator;
-        YangLeafList yangLeafListInfo;
-        leafListIterator = yangInput.getListOfLeafList().listIterator();
-        yangLeafListInfo = leafListIterator.next();
-
-        // Check whether the information in the leaf is correct under grouping.
-        assertThat(yangLeafListInfo.getName(), is("network-id"));
-        assertThat(yangLeafListInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-
-        YangLeafRef leafref = (YangLeafRef) (yangLeafListInfo.getDataType().getDataTypeExtendedInfo());
-
-        // Check whether leafref type got resolved.
-        assertThat(leafref.getResolvableStatus(),
-                   is(ResolvableStatus.RESOLVED));
-
-        // Check the effective type for the leaf.
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.UINT8));
-    }
-
-    /**
-     * Checks self resolution when leafref of leaf-list under module refers to invalid node.
-     * Inter file linking also has to be done to know the error message.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefInTypedefIsInDeepTreeAndLeafListIsInModuleWithReferredTypeEnumeration()
-            throws IOException, ParserException {
-
-        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreftoleafrefwithtypedef";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("Test")) {
-            selfNode = rootNode;
-        }
-        // Check whether the data model tree returned is of type module.
-        assertThat((selfNode instanceof YangModule), is(true));
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-        assertThat(yangNode.getName(), is("Test"));
-
-        YangContainer yangContainer = (YangContainer) yangNode.getChild().getChild().getChild().getNextSibling();
-
-        ListIterator<YangLeaf> leafIterator;
-        YangLeaf yangLeafInfo;
-        leafIterator = yangContainer.getListOfLeaf().listIterator();
-        yangLeafInfo = leafIterator.next();
-
-        // Check whether the information in the leaf is correct under grouping.
-        assertThat(yangLeafInfo.getName(), is("interval"));
-        assertThat(yangLeafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-
-        YangLeafRef leafref = (YangLeafRef) (yangLeafInfo.getDataType().getDataTypeExtendedInfo());
-
-        // Check whether leafref type got resolved.
-        assertThat(leafref.getResolvableStatus(),
-                   is(ResolvableStatus.RESOLVED));
-
-        // Check the effective type for the leaf.
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.ENUMERATION));
-    }
-
-    /**
-     * Checks self resolution when grouping and uses are siblings.
-     * Grouping followed by uses.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefRefersAnotherLeafref()
-            throws IOException, ParserException {
-
-        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreftoleafref";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("ietf-network")) {
-            selfNode = rootNode;
-        }
-        // Check whether the data model tree returned is of type module.
-        assertThat((selfNode instanceof YangModule), is(true));
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-        assertThat(yangNode.getName(), is("ietf-network"));
-
-        ListIterator<YangLeaf> leafIterator;
-        YangLeaf leafInfo;
-
-        //YangGrouping grouping = (YangGrouping) yangNode.getChild().getNextSibling();
-        leafIterator = yangNode.getListOfLeaf().listIterator();
-        leafInfo = leafIterator.next();
-
-        // Check whether the information in the leaf is correct under grouping.
-        assertThat(leafInfo.getName(), is("network-ref"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
-
-        assertThat(leafref.getResolvableStatus(),
-                   is(ResolvableStatus.RESOLVED));
-
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.UINT8));
-    }
-
-    /**
-     * Checks self resolution when leafref refers to many other leafref.
-     */
-    @Test
-    public void processSelfResolutionWhenLeafrefReferToMultipleLeafref()
-            throws IOException, ParserException {
-
-        String searchDir = "src/test/resources/leafreflinker/intrafile/leafreftomultileafref";
-
-        Set<Path> paths = new HashSet<>();
-        for (String file : getYangFiles(searchDir)) {
-            paths.add(Paths.get(file));
-        }
-
-        utilManager.createYangFileInfoSet(paths);
-        utilManager.parseYangFileInfoSet();
-        utilManager.createYangNodeSet();
-        YangNode selfNode = null;
-        // Create YANG node set
-        yangLinkerManager.createYangNodeSet(utilManager.getYangNodeSet());
-
-        // Add references to import list.
-        yangLinkerManager.addRefToYangFilesImportList(utilManager.getYangNodeSet());
-
-        YangLinkerUtils.updateFilePriority(utilManager.getYangNodeSet());
-
-        // Carry out inter-file linking.
-        yangLinkerManager.processInterFileLinking(utilManager.getYangNodeSet());
-
-        Iterator<YangNode> yangNodeIterator = utilManager.getYangNodeSet().iterator();
-
-        YangNode rootNode = yangNodeIterator.next();
-
-        if (rootNode.getName().equals("Test")) {
-            selfNode = rootNode;
-        }
-        // Check whether the data model tree returned is of type module.
-        assertThat((selfNode instanceof YangModule), is(true));
-
-        // Check whether the node type is set properly to module.
-        assertThat(selfNode.getNodeType(), is(YangNodeType.MODULE_NODE));
-
-        // Check whether the module name is set correctly.
-        YangModule yangNode = (YangModule) selfNode;
-        assertThat(yangNode.getName(), is("Test"));
-
-        YangContainer containerInModule = (YangContainer) yangNode.getChild().getNextSibling();
-        YangContainer containerInList = (YangContainer) containerInModule.getChild().getChild();
-
-        ListIterator<YangLeaf> leafIterator;
-        YangLeaf leafInfo;
-
-        leafIterator = containerInList.getListOfLeaf().listIterator();
-        leafInfo = leafIterator.next();
-
-        // Check whether the information in the leaf is correct under grouping.
-        assertThat(leafInfo.getName(), is("remove"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("leafref"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.LEAFREF));
-        YangLeafRef leafref = (YangLeafRef) (leafInfo.getDataType().getDataTypeExtendedInfo());
-
-        assertThat(leafref.getResolvableStatus(),
-                   is(ResolvableStatus.RESOLVED));
-
-        assertThat(leafref.getEffectiveDataType().getDataType(),
-                   is(YangDataTypes.ENUMERATION));
-    }
 
     /**
      * Checks self resolution when grouping and uses are siblings.
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileUsesLinkingTest.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileUsesLinkingTest.java
index f5dee73..e7e5a6b 100644
--- a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileUsesLinkingTest.java
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileUsesLinkingTest.java
@@ -356,7 +356,8 @@
         //validate end point uses
         assertThat(grouping.getNextSibling() instanceof YangUses, is(true));
         assertThat(grouping.getNextSibling().getNextSibling().getNextSibling().getNextSibling()
-                           .getNextSibling().getNextSibling().getNextSibling().getNextSibling() instanceof YangContainer,
+                           .getNextSibling().getNextSibling().getNextSibling()
+                           .getNextSibling() instanceof YangContainer,
                    is(true));
         container = (YangContainer) grouping.getNextSibling().getNextSibling().getNextSibling().getNextSibling()
                 .getNextSibling().getNextSibling().getNextSibling().getNextSibling();
@@ -374,9 +375,8 @@
             throws IOException, ParserException {
 
         thrown.expect(ParserException.class);
-        thrown.expectMessage(
-                "YANG File Error: Identifier collision detected in uses as " +
-                        "\"failure in 10 at 13 in src/test/resources/SelfResolutionGroupingHavingSameUsesManyTimes.yang");
+        thrown.expectMessage("YANG File Error: Identifier collision detected in uses as \"failure in 10 at 13 in " +
+                                     "src/test/resources/SelfResolutionGroupingHavingSameUsesManyTimes.yang");
         YangNode node = manager
                 .getDataModel("src/test/resources/SelfResolutionGroupingHavingSameUsesManyTimes.yang");
     }
@@ -389,9 +389,8 @@
     public void processSelfResolutionRpcWithOneTypedefAndTwoGroupingUnderDifferentNode()
             throws IOException, ParserException {
 
-        YangNode node = manager
-                .getDataModel(
-                        "src/test/resources/SelfResolutionRpcWithOneTypedefAndTwoGroupingUnderDifferentNode.yang");
+        String y = "src/test/resources/SelfResolutionRpcWithOneTypedefAndTwoGroupingUnderDifferentNode.yang";
+        YangNode node = manager.getDataModel(y);
 
         // Check whether the data model tree returned is of type module.
         assertThat((node instanceof YangModule), is(true));
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/NotificationTranslatorTest.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/NotificationTranslatorTest.java
index 6043bee..362cc22 100644
--- a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/NotificationTranslatorTest.java
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/NotificationTranslatorTest.java
@@ -32,9 +32,8 @@
 public final class NotificationTranslatorTest {
 
     private final YangUtilsParserManager manager = new YangUtilsParserManager();
-    private final static String YANG = "src/test/resources/NotificationTest" +
-            ".yang";
-    private final static String DIR = "target/notificationTranslator/";
+    private static final String YANG = "src/test/resources/NotificationTest.yang";
+    private static final String DIR = "target/notificationTranslator/";
 
     /**
      * Checks union translation should not result in any exception.
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/TypeLinkingAfterCloningTest.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/TypeLinkingAfterCloningTest.java
index 3a10625..9927a4e 100644
--- a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/TypeLinkingAfterCloningTest.java
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/TypeLinkingAfterCloningTest.java
@@ -461,6 +461,18 @@
                 .getNextSibling().getNextSibling().getNextSibling()
                 .getNextSibling().getNextSibling();
 
+        validateList1(list);
+        validateList2(list);
+    }
+
+    private void validateList1(YangList list) {
+        YangUnion union2;
+        Iterator<YangType<?>> unionTypeItr2;
+        YangUnion union3;
+        Iterator<YangType<?>> unionTypeItr3;
+        YangDerivedInfo derivedInfo;
+        YangTypeDef typeDef;
+        Iterator<YangType<?>> typeDefItr;
         Iterator<YangLeaf> leafItr = list.getListOfLeaf().listIterator();
         YangLeaf leafInfo = leafItr.next();
 
@@ -549,9 +561,17 @@
                 FIRST, FIRST, USABILITY_SYS_LOG, TYPEDEF, CORRECT),
                    idRef.getBaseIdentity().getName(),
                    is(USABILITY_SYS_LOG));
+    }
 
-        YangContainer container = (YangContainer) list.getChild()
-                .getNextSibling().getNextSibling();
+    private void validateList2(YangList list) {
+        YangUnion union2;
+        Iterator<YangType<?>> unionTypeItr2;
+        YangUnion union3;
+        Iterator<YangType<?>> unionTypeItr3;
+        YangDerivedInfo derivedInfo;
+        YangTypeDef typeDef;
+        Iterator<YangType<?>> typeDefItr;
+        YangContainer container = (YangContainer) list.getChild().getNextSibling().getNextSibling();
 
         Iterator<YangLeafList> leafListItr = container.getListOfLeafList()
                 .listIterator();
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/YangJavaModelUtilsTest.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/YangJavaModelUtilsTest.java
index 9b35c2c..b01ec65 100644
--- a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/YangJavaModelUtilsTest.java
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/YangJavaModelUtilsTest.java
@@ -38,13 +38,11 @@
  */
 public class YangJavaModelUtilsTest {
 
-
-    private final YangCompilerManager utilManager =
-            new YangCompilerManager();
+    private final YangCompilerManager utilManager = new YangCompilerManager();
 
     @Test
-    public void isRootNodeContainsOnlyAugmentTest() throws IOException,
-            ParserException, MojoExecutionException {
+    public void isRootNodeContainsOnlyAugmentTest()
+            throws IOException, ParserException, MojoExecutionException {
         String searchDir = "src/test/resources/rootNode/onlyaugment";
 
         Set<Path> paths = new HashSet<>();
@@ -68,8 +66,8 @@
     }
 
     @Test
-    public void isRootNodeCodeGenRequiredOnlyLeafTest() throws IOException
-            , ParserException, MojoExecutionException {
+    public void isRootNodeCodeGenRequiredOnlyLeafTest()
+            throws IOException, ParserException, MojoExecutionException {
         String searchDir = "src/test/resources/rootNode/onlyleaf";
 
         Set<Path> paths = new HashSet<>();
@@ -90,8 +88,8 @@
     }
 
     @Test
-    public void isRootNodeCodeGenRequiredOnlyLeafListTest() throws IOException
-            , ParserException, MojoExecutionException {
+    public void isRootNodeCodeGenRequiredOnlyLeafListTest()
+            throws IOException, ParserException, MojoExecutionException {
         String searchDir = "src/test/resources/rootNode/onlyleaflist";
 
         Set<Path> paths = new HashSet<>();
@@ -112,8 +110,8 @@
     }
 
     @Test
-    public void isRootNodeCodeGenRequiredOnlyGroupingTest() throws IOException
-            , ParserException, MojoExecutionException {
+    public void isRootNodeCodeGenRequiredOnlyGroupingTest()
+            throws IOException, ParserException, MojoExecutionException {
         String searchDir = "src/test/resources/rootNode/onlygrouping";
 
         Set<Path> paths = new HashSet<>();
@@ -138,8 +136,8 @@
 
 
     @Test
-    public void isRootNodeCodeGenRequiredOnlyTypeDefTest() throws IOException
-            , ParserException, MojoExecutionException {
+    public void isRootNodeCodeGenRequiredOnlyTypeDefTest()
+            throws IOException, ParserException, MojoExecutionException {
         String searchDir = "src/test/resources/rootNode/onlytypdef";
 
         Set<Path> paths = new HashSet<>();
@@ -163,8 +161,8 @@
     }
 
     @Test
-    public void isRootNodeCodeGenRequiredNoGenTest() throws IOException
-            , ParserException, MojoExecutionException {
+    public void isRootNodeCodeGenRequiredNoGenTest()
+            throws IOException, ParserException, MojoExecutionException {
         String searchDir = "src/test/resources/rootNode/nogen";
 
         Set<Path> paths = new HashSet<>();
@@ -185,8 +183,8 @@
     }
 
     @Test
-    public void isRootNodeCodeGenRequiredMixedTest() throws IOException
-            , ParserException, MojoExecutionException {
+    public void isRootNodeCodeGenRequiredMixedTest()
+            throws IOException, ParserException, MojoExecutionException {
         String searchDir = "src/test/resources/rootNode/mixed";
 
         Set<Path> paths = new HashSet<>();
@@ -210,8 +208,8 @@
     }
 
     @Test
-    public void isRootNodeCodeGenRequiredTypedefGroupingTest() throws IOException
-            , ParserException, MojoExecutionException {
+    public void isRootNodeCodeGenRequiredTypedefGroupingTest()
+            throws IOException, ParserException, MojoExecutionException {
         String searchDir = "src/test/resources/rootNode/typedefgrouping";
 
         Set<Path> paths = new HashSet<>();
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/YangXpathLinkerTest.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/YangXpathLinkerTest.java
index 4919914..e3d4e93 100644
--- a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/YangXpathLinkerTest.java
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/YangXpathLinkerTest.java
@@ -310,8 +310,7 @@
                 targetNodeName = augment.getTargetNode().get(
                         augment.getTargetNode().size() - 1).getNodeIdentifier()
                         .getName();
-                targetNode = linker.processXpathLinking
-                        (augment.getTargetNode(), node, AUGMENT_LINKING);
+                targetNode = linker.processXpathLinking(augment.getTargetNode(), node, AUGMENT_LINKING);
             }
         }
 
diff --git a/compiler/plugin/utils/src/main/java/org/onosproject/yang/compiler/plugin/utils/YangApacheUtils.java b/compiler/plugin/utils/src/main/java/org/onosproject/yang/compiler/plugin/utils/YangApacheUtils.java
index 1f91d96..1ce96b4 100644
--- a/compiler/plugin/utils/src/main/java/org/onosproject/yang/compiler/plugin/utils/YangApacheUtils.java
+++ b/compiler/plugin/utils/src/main/java/org/onosproject/yang/compiler/plugin/utils/YangApacheUtils.java
@@ -56,6 +56,10 @@
     private static final String ONOS = "org.onosproject";
     private static final Logger log = getLogger(YangApacheUtils.class);
 
+    // Forbid construction.
+    private YangApacheUtils() {
+    }
+
     /**
      * Returns YANG model for generated module class.
      *
diff --git a/compiler/plugin/utils/src/main/java/org/onosproject/yang/compiler/plugin/utils/package-info.java b/compiler/plugin/utils/src/main/java/org/onosproject/yang/compiler/plugin/utils/package-info.java
new file mode 100644
index 0000000..96630b1
--- /dev/null
+++ b/compiler/plugin/utils/src/main/java/org/onosproject/yang/compiler/plugin/utils/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2017-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Build plugin utilities for compiling YANG models.
+ */
+package org.onosproject.yang.compiler.plugin.utils;
\ No newline at end of file
diff --git a/model/src/main/java/org/onosproject/yang/model/DataNode.java b/model/src/main/java/org/onosproject/yang/model/DataNode.java
index 1727195..ed3338b 100644
--- a/model/src/main/java/org/onosproject/yang/model/DataNode.java
+++ b/model/src/main/java/org/onosproject/yang/model/DataNode.java
@@ -100,7 +100,7 @@
      *
      * @param <B> type of data node builder
      */
-    public static abstract class Builder<B extends Builder<B>> {
+    public abstract static class Builder<B extends Builder<B>> {
 
         /**
          * Type of node in data store.
@@ -121,7 +121,7 @@
          * Application related information, this enables application to use
          * this builder as there work bench.
          */
-        protected Object AppInfo;
+        protected Object appInfo;
 
         /**
          * Parent data node.
@@ -292,7 +292,7 @@
          * @return application information
          */
         public Object appInfo() {
-            return AppInfo;
+            return appInfo;
         }
 
         /**
@@ -302,7 +302,7 @@
          * @param appInfo application related information
          */
         public void appInfo(Object appInfo) {
-            AppInfo = appInfo;
+            this.appInfo = appInfo;
         }
     }
 }
diff --git a/model/src/main/java/org/onosproject/yang/model/LeafListKey.java b/model/src/main/java/org/onosproject/yang/model/LeafListKey.java
index 1758d2e..ba4ab46 100644
--- a/model/src/main/java/org/onosproject/yang/model/LeafListKey.java
+++ b/model/src/main/java/org/onosproject/yang/model/LeafListKey.java
@@ -24,7 +24,7 @@
  * Representation of an entity which identifies a uniquely branching
  * leaf-list entry corresponding to a multi instance leaf schema.
  */
-public class LeafListKey extends NodeKey<LeafListKey>
+public final class LeafListKey extends NodeKey<LeafListKey>
         implements Comparable<LeafListKey> {
     private Object val;
 
diff --git a/model/src/main/java/org/onosproject/yang/model/LeafNode.java b/model/src/main/java/org/onosproject/yang/model/LeafNode.java
index ca46b9a..3c49c31 100644
--- a/model/src/main/java/org/onosproject/yang/model/LeafNode.java
+++ b/model/src/main/java/org/onosproject/yang/model/LeafNode.java
@@ -83,7 +83,7 @@
      * builder will be used both to create leaf node from scratch or from a
      * given leaf node.
      */
-    public final static class Builder extends DataNode.Builder<Builder> {
+    public static final class Builder extends DataNode.Builder<Builder> {
 
         /**
          * Leaf node value.
diff --git a/model/src/main/java/org/onosproject/yang/model/LeafType.java b/model/src/main/java/org/onosproject/yang/model/LeafType.java
index d60d8b1..ca6509e 100644
--- a/model/src/main/java/org/onosproject/yang/model/LeafType.java
+++ b/model/src/main/java/org/onosproject/yang/model/LeafType.java
@@ -113,7 +113,7 @@
     RESOURCE_IDENTIFIER,
 
     /**
-     * The identityref type is used to reference an existing identity
+     * The identityref type is used to reference an existing identity.
      */
     IDENTITY_REF,
 
diff --git a/model/src/main/java/org/onosproject/yang/model/ListKey.java b/model/src/main/java/org/onosproject/yang/model/ListKey.java
index 4082cc5..51ce2f4 100644
--- a/model/src/main/java/org/onosproject/yang/model/ListKey.java
+++ b/model/src/main/java/org/onosproject/yang/model/ListKey.java
@@ -26,7 +26,7 @@
  * Represents an entity which identifies a unique branching node
  * corresponding to a multi instance schema definition.
  */
-public class ListKey extends NodeKey<ListKey> implements Comparable<ListKey> {
+public final class ListKey extends NodeKey<ListKey> implements Comparable<ListKey> {
 
     private List<KeyLeaf> keyLeafs;
 
diff --git a/model/src/main/java/org/onosproject/yang/model/ModelConstants.java b/model/src/main/java/org/onosproject/yang/model/ModelConstants.java
index 4c24cdd..5439998 100644
--- a/model/src/main/java/org/onosproject/yang/model/ModelConstants.java
+++ b/model/src/main/java/org/onosproject/yang/model/ModelConstants.java
@@ -24,4 +24,8 @@
     static final String LEAF_IS_TERMINAL = "Leaf must be the terminal node";
     static final String NON_KEY_LEAF = "Leaf list is not a key of list";
     static final String NO_KEY_SET = "Resource Identifier is empty";
+
+    // Forbid construction.
+    private ModelConstants() {
+    }
 }
diff --git a/model/src/main/java/org/onosproject/yang/model/ResourceId.java b/model/src/main/java/org/onosproject/yang/model/ResourceId.java
index d81911d..5b09d2b 100644
--- a/model/src/main/java/org/onosproject/yang/model/ResourceId.java
+++ b/model/src/main/java/org/onosproject/yang/model/ResourceId.java
@@ -32,7 +32,7 @@
  * hierarchy to reach a resource in the instance tree.
  */
 
-public class ResourceId {
+public final class ResourceId {
 
     /**
      * List of node keys.
@@ -111,7 +111,7 @@
          * Application related information, this enables application to use
          * this builder as there work bench.
          */
-        protected Object AppInfo;
+        protected Object appInfo;
 
         private List<NodeKey> nodeKeyList;
         private NodeKey.NodeKeyBuilder curKeyBuilder = null;
@@ -246,7 +246,7 @@
          * @return application information
          */
         public Object appInfo() {
-            return AppInfo;
+            return appInfo;
         }
 
         /**
@@ -256,7 +256,7 @@
          * @param appInfo application related information
          */
         public void appInfo(Object appInfo) {
-            AppInfo = appInfo;
+            this.appInfo = appInfo;
         }
     }
 }
diff --git a/model/src/test/java/org/onosproject/yang/model/ResourceIdTest.java b/model/src/test/java/org/onosproject/yang/model/ResourceIdTest.java
index 7a4bb62..6a5075d 100644
--- a/model/src/test/java/org/onosproject/yang/model/ResourceIdTest.java
+++ b/model/src/test/java/org/onosproject/yang/model/ResourceIdTest.java
@@ -15,7 +15,7 @@
 import static org.junit.Assert.assertEquals;
 
 /**
- * Test resource id
+ * Test resource ID.
  */
 
 public class ResourceIdTest {
diff --git a/pom.xml b/pom.xml
index 98aea8f..9483615 100644
--- a/pom.xml
+++ b/pom.xml
@@ -30,6 +30,7 @@
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <onos-build-conf.version>1.3</onos-build-conf.version>
     </properties>
 
     <modules>
@@ -88,6 +89,42 @@
                 <version>2.5.4</version>
                 <extensions>true</extensions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-checkstyle-plugin</artifactId>
+                <version>2.17</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.onosproject</groupId>
+                        <artifactId>onos-build-conf</artifactId>
+                        <version>${onos-build-conf.version}</version>
+                    </dependency>
+                </dependencies>
+                <configuration>
+                    <!-- begin: workaround for unexpected NullPointerException on Eclipse -->
+                    <sourceDirectory>${project.build.sourceDirectory}
+                    </sourceDirectory>
+                    <testSourceDirectory>${project.build.testSourceDirectory}
+                    </testSourceDirectory>
+                    <!-- end: workaround for unexpected NullPointerException on Eclipse -->
+                    <configLocation>onos/checkstyle.xml</configLocation>
+                    <suppressionsLocation>onos/suppressions.xml
+                    </suppressionsLocation>
+                    <failsOnError>false</failsOnError>
+                    <logViolationsToConsole>true</logViolationsToConsole>
+                    <includeTestSourceDirectory>true
+                    </includeTestSourceDirectory>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>validate-checkstyle</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 </project>
diff --git a/runtime/api/src/main/java/org/onosproject/yang/runtime/api/YangSerializer.java b/runtime/api/src/main/java/org/onosproject/yang/runtime/api/YangSerializer.java
index 46e026d..bc22af0 100644
--- a/runtime/api/src/main/java/org/onosproject/yang/runtime/api/YangSerializer.java
+++ b/runtime/api/src/main/java/org/onosproject/yang/runtime/api/YangSerializer.java
@@ -16,11 +16,9 @@
 
 package org.onosproject.yang.runtime.api;
 
-import org.onosproject.yang.model.DataNode;
-
 /**
  * Abstraction of entity capable of encoding and decoding arbitrary
- * {@link DataNode} structures, which are in-memory representations of
+ * {@link org.onosproject.yang.model.DataNode} structures, which are in-memory representations of
  * YANG models, to and from various external representations, e.g. XML, JSON.
  * <p>
  * This interface is not intended for use by applications, but rather only
diff --git a/runtime/app/src/test/java/org/onosproject/yang/runtime/app/DefaultYangModelRegistryTest.java b/runtime/app/src/test/java/org/onosproject/yang/runtime/app/DefaultYangModelRegistryTest.java
index 8445d34..92f542c 100644
--- a/runtime/app/src/test/java/org/onosproject/yang/runtime/app/DefaultYangModelRegistryTest.java
+++ b/runtime/app/src/test/java/org/onosproject/yang/runtime/app/DefaultYangModelRegistryTest.java
@@ -194,7 +194,7 @@
         assertThat(true, is(yangNode == null));
 
         //Here the yangNode should be the node which does not have revision.
-        
+
         // asset should pass with false.
         yangNode = registry.getForSchemaName(SCHEMA_NAME_4);
         assertThat(true, is(((YangNode) yangNode).getRevision() == null));
diff --git a/runtime/utils/src/main/java/org/onosproject/yang/runtime/utils/RuntimeHelper.java b/runtime/utils/src/main/java/org/onosproject/yang/runtime/utils/RuntimeHelper.java
index d30b337..5792862 100644
--- a/runtime/utils/src/main/java/org/onosproject/yang/runtime/utils/RuntimeHelper.java
+++ b/runtime/utils/src/main/java/org/onosproject/yang/runtime/utils/RuntimeHelper.java
@@ -41,6 +41,10 @@
  */
 public final class RuntimeHelper {
 
+    // Forbid construction.
+    private RuntimeHelper() {
+    }
+
     /**
      * Returns YANG model for given generated class.
      *
diff --git a/runtime/utils/src/main/java/org/onosproject/yang/runtime/utils/SerializerHelper.java b/runtime/utils/src/main/java/org/onosproject/yang/runtime/utils/SerializerHelper.java
index a717942..eecae7e 100644
--- a/runtime/utils/src/main/java/org/onosproject/yang/runtime/utils/SerializerHelper.java
+++ b/runtime/utils/src/main/java/org/onosproject/yang/runtime/utils/SerializerHelper.java
@@ -23,6 +23,10 @@
  */
 public final class SerializerHelper {
 
+    // Forbid construction.
+    private SerializerHelper() {
+    }
+
     /**
      * Initializes resource identifier builder with YANG serializer context
      * information.
