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 ec20614..e1fd462 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
@@ -22,14 +22,14 @@
 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.parser.antlrgencode.GeneratedYangParser;
+import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
+import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.LengthStatementContext;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
 
-import static org.onosproject.yang.compiler.datamodel.utils.RestrictionResolver.processLengthRestriction;
+import static org.onosproject.yang.compiler.datamodel.utils.RestrictionResolver.processLengthRes;
 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.builtindatatype.YangDataTypes.DERIVED;
 import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.STRING;
@@ -57,8 +57,8 @@
  *
  *
  * ANTLR grammar rule
- * lengthStatement : LENGTH_KEYWORD length
- *                 (STMTEND | LEFT_CURLY_BRACE commonStatements RIGHT_CURLY_BRACE);
+ * lengthStatement : LENGTH_KEYWORD length (STMTEND | LEFT_CURLY_BRACE
+ * commonStatements RIGHT_CURLY_BRACE);
  */
 
 /**
@@ -67,6 +67,10 @@
  */
 public final class LengthRestrictionListener {
 
+    private static final String E_INVALID_TYPE = "YANG file error : Length can" +
+            " only be used to restrict the built-in type string/binary or " +
+            "types derived from string/binary.";
+
     /**
      * Creates a new length restriction listener.
      */
@@ -74,114 +78,115 @@
     }
 
     /**
-     * It is called when parser receives an input matching the grammar
-     * rule (length), performs validation and updates the data model
-     * tree.
+     * Processes pattern restriction, when parser receives an input matching
+     * the grammar rule (length), performs validation and updates the data
+     * model tree.
      *
-     * @param listener listener's object
-     * @param ctx      context object of the grammar rule
+     * @param lis listener object
+     * @param ctx context object
      */
-    public static void processLengthRestrictionEntry(TreeWalkListener listener,
-                                                     GeneratedYangParser.LengthStatementContext ctx) {
+    public static void processLengthRestrictionEntry(TreeWalkListener lis,
+                                                     LengthStatementContext ctx) {
 
         // Check for stack to be non empty.
-        checkStackIsNotEmpty(listener, MISSING_HOLDER, LENGTH_DATA, ctx.length().getText(), ENTRY);
+        checkStackIsNotEmpty(lis, MISSING_HOLDER, LENGTH_DATA,
+                             ctx.length().getText(), ENTRY);
 
-        Parsable tmpData = listener.getParsedDataStack().peek();
+        Parsable tmpData = lis.getParsedDataStack().peek();
         if (tmpData.getYangConstructType() == TYPE_DATA) {
             YangType type = (YangType) tmpData;
-            setLengthRestriction(listener, type, ctx);
+            setLengthRestriction(lis, type, ctx);
         } else {
-            throw new ParserException(constructListenerErrorMessage(INVALID_HOLDER, LENGTH_DATA,
-                                                                    ctx.length().getText(), ENTRY));
+            throw new ParserException(constructListenerErrorMessage(
+                    INVALID_HOLDER, LENGTH_DATA,
+                    ctx.length().getText(), ENTRY));
         }
     }
 
     /**
      * Sets the length restriction to type.
      *
-     * @param listener listener's object
-     * @param type     Yang type for which length restriction to be set
-     * @param ctx      context object of the grammar rule
+     * @param lis  listener object
+     * @param type YANG type
+     * @param ctx  context object
      */
-    private static void setLengthRestriction(TreeWalkListener listener, YangType type,
-                                             GeneratedYangParser.LengthStatementContext ctx) {
+    private static void setLengthRestriction(TreeWalkListener lis,
+                                             YangType type,
+                                             LengthStatementContext ctx) {
 
-        if (type.getDataType() == DERIVED) {
-            ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
-                    .setLengthRestrictionString(ctx.length().getText());
-            ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
-                    .setLineNumber(ctx.getStart().getLine());
-            ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
-                    .setCharPosition(ctx.getStart().getCharPositionInLine());
+        int line = ctx.getStart().getLine();
+        int pos = ctx.getStart().getCharPositionInLine();
+        String txt = ctx.length().getText();
+        YangDataTypes dataType = type.getDataType();
+
+        YangRangeRestriction lenRes = new YangRangeRestriction(txt);
+        lenRes.setFileName(lis.getFileName());
+        lenRes.setCharPosition(pos);
+        lenRes.setLineNumber(line);
+        lis.getParsedDataStack().push(lenRes);
+
+        if (dataType == DERIVED) {
+            YangDerivedInfo info = (YangDerivedInfo<?>) type
+                    .getDataTypeExtendedInfo();
+            info.setLengthRes(lenRes);
+            info.setFileName(lis.getFileName());
+            info.setCharPosition(pos);
+            info.setLineNumber(line);
             return;
         }
 
-        if (type.getDataType() != STRING && type.getDataType() != BINARY) {
-            ParserException parserException =
-                    new ParserException(
-                            "YANG file error : " +
-                                    getYangConstructType(LENGTH_DATA) +
-                                    " name " + ctx.length().getText() +
-                                    " can be used to restrict the built-in type string/binary" +
-                                    " or types derived from string/binary.");
-            parserException.setLine(ctx.getStart().getLine());
-            parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
-            throw parserException;
+        if (dataType != STRING && dataType != BINARY) {
+            ParserException exc = new ParserException(E_INVALID_TYPE);
+            exc.setLine(line);
+            exc.setCharPosition(pos);
+            throw exc;
         }
-
-        YangRangeRestriction lengthRestriction = null;
         try {
-            lengthRestriction = processLengthRestriction(null, ctx.getStart().getLine(),
-                                                         ctx.getStart().getCharPositionInLine(), false,
-                                                         ctx.length().getText(), listener.getFileName());
+            lenRes = processLengthRes(null, line, pos, false, lenRes,
+                                      lis.getFileName());
         } catch (DataModelException e) {
-            ParserException parserException = new ParserException(e.getMessage());
-            parserException.setCharPosition(e.getCharPositionInLine());
-            parserException.setLine(e.getLineNumber());
-            throw parserException;
+            ParserException exc = new ParserException(e.getMessage());
+            exc.setCharPosition(e.getCharPositionInLine());
+            exc.setLine(e.getLineNumber());
+            throw exc;
         }
 
-        if (type.getDataType() == STRING) {
-            YangStringRestriction stringRestriction = (YangStringRestriction) type.getDataTypeExtendedInfo();
-            if (stringRestriction == null) {
-                stringRestriction = new YangStringRestriction();
-                stringRestriction.setFileName(listener.getFileName());
-                stringRestriction.setCharPosition(ctx.getStart().getCharPositionInLine());
-                stringRestriction.setLineNumber(ctx.getStart().getLine());
-                type.setDataTypeExtendedInfo(stringRestriction);
+        if (dataType == STRING) {
+            YangStringRestriction strRes = (YangStringRestriction) type
+                    .getDataTypeExtendedInfo();
+            if (strRes == null) {
+                strRes = new YangStringRestriction();
+                strRes.setFileName(lis.getFileName());
+                strRes.setCharPosition(ctx.getStart().getCharPositionInLine());
+                strRes.setLineNumber(ctx.getStart().getLine());
+                type.setDataTypeExtendedInfo(strRes);
             }
-
-            stringRestriction.setLengthRestriction(lengthRestriction);
+            strRes.setLengthRestriction(lenRes);
         } else {
-            type.setDataTypeExtendedInfo(lengthRestriction);
+            type.setDataTypeExtendedInfo(lenRes);
         }
-
-        listener.getParsedDataStack().push(lengthRestriction);
     }
 
     /**
      * Performs validation and updates the data model tree.
      * It is called when parser exits from grammar rule (length).
      *
-     * @param listener listener's object
-     * @param ctx      context object of the grammar rule
+     * @param lis listener object
+     * @param ctx context object
      */
-    public static void processLengthRestrictionExit(TreeWalkListener listener,
-                                                    GeneratedYangParser.LengthStatementContext ctx) {
+    public static void processLengthRestrictionExit(TreeWalkListener lis,
+                                                    LengthStatementContext ctx) {
+
+        String txt = ctx.length().getText();
 
         // Check for stack to be non empty.
-        checkStackIsNotEmpty(listener, MISSING_HOLDER, LENGTH_DATA, ctx.length().getText(), EXIT);
+        checkStackIsNotEmpty(lis, MISSING_HOLDER, LENGTH_DATA, txt, EXIT);
 
-        Parsable tmpData = listener.getParsedDataStack().peek();
-        if (tmpData instanceof YangRangeRestriction) {
-            listener.getParsedDataStack().pop();
-        } else if (tmpData instanceof YangType
-                && ((YangType) tmpData).getDataType() == DERIVED) {
-            // TODO : need to handle in linker
-        } else {
-            throw new ParserException(constructListenerErrorMessage(MISSING_CURRENT_HOLDER, LENGTH_DATA,
-                                                                    ctx.length().getText(), EXIT));
+        Parsable tmpData = lis.getParsedDataStack().peek();
+        if (!(tmpData instanceof YangRangeRestriction)) {
+            throw new ParserException(constructListenerErrorMessage(
+                    MISSING_CURRENT_HOLDER, LENGTH_DATA, txt, EXIT));
         }
+        lis.getParsedDataStack().pop();
     }
 }
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 65db33f..4fdc648 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
@@ -22,7 +22,6 @@
 import org.onosproject.yang.compiler.datamodel.YangStringRestriction;
 import org.onosproject.yang.compiler.datamodel.YangType;
 import org.onosproject.yang.compiler.datamodel.utils.Parsable;
-import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
 
@@ -34,6 +33,7 @@
 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.DERIVED;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.STRING;
 import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PatternStatementContext;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
@@ -42,6 +42,7 @@
 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.ListenerValidation.checkStackIsNotEmpty;
+import static org.onosproject.yang.compiler.utils.UtilConstants.EMPTY_STRING;
 
 /*
  * Reference: RFC6020 and YANG ANTLR Grammar
@@ -58,7 +59,8 @@
  *                          "}")
  *
  * ANTLR grammar rule
- *  patternStatement : PATTERN_KEYWORD string (STMTEND | LEFT_CURLY_BRACE commonStatements RIGHT_CURLY_BRACE);
+ *  patternStatement : PATTERN_KEYWORD string (STMTEND |
+ *  LEFT_CURLY_BRACE commonStatements RIGHT_CURLY_BRACE);
  */
 
 /**
@@ -67,7 +69,9 @@
  */
 public final class PatternRestrictionListener {
 
-    private static final String EMPTY_STRING = "";
+    private static final String E_INVALID_TYPE = "YANG file error : Pattern " +
+            "can only be used to restrict the built-in type string or types" +
+            " derived from string.";
 
     /**
      * Creates a new pattern restriction listener.
@@ -76,128 +80,123 @@
     }
 
     /**
-     * It is called when parser receives an input matching the grammar
-     * rule (pattern), performs validation and updates the data model
-     * tree.
+     * Processes pattern restriction, when parser receives an input matching
+     * the grammar rule (pattern), performs validation and updates the data
+     * model tree.
      *
-     * @param listener listener's object
-     * @param ctx      context object of the grammar rule
+     * @param lis listener object
+     * @param ctx context object
      */
-    public static void processPatternRestrictionEntry(TreeWalkListener listener,
+    public static void processPatternRestrictionEntry(TreeWalkListener lis,
                                                       PatternStatementContext ctx) {
 
         // Check for stack to be non empty.
-        checkStackIsNotEmpty(listener, MISSING_HOLDER, PATTERN_DATA, ctx.string().getText(), ENTRY);
+        checkStackIsNotEmpty(lis, MISSING_HOLDER, PATTERN_DATA,
+                             ctx.string().getText(), ENTRY);
 
-        Parsable tmpData = listener.getParsedDataStack().peek();
+        Parsable tmpData = lis.getParsedDataStack().peek();
         if (tmpData.getYangConstructType() == TYPE_DATA) {
             YangType type = (YangType) tmpData;
-            setPatternRestriction(listener, type, ctx);
+            setPatternRestriction(lis, type, ctx);
         } else {
-            throw new ParserException(constructListenerErrorMessage(INVALID_HOLDER, PATTERN_DATA,
-                                                                    ctx.string().getText(), ENTRY));
+            throw new ParserException(constructListenerErrorMessage(
+                    INVALID_HOLDER, PATTERN_DATA,
+                    ctx.string().getText(), ENTRY));
         }
     }
 
     /**
      * Sets the pattern restriction to type.
      *
-     * @param listener listener's object
-     * @param type     Yang type for which pattern restriction to be set
-     * @param ctx      context object of the grammar rule
+     * @param lis  listener object
+     * @param type YANG type
+     * @param ctx  context object
      */
-    private static void setPatternRestriction(TreeWalkListener listener, YangType type,
+    private static void setPatternRestriction(TreeWalkListener lis,
+                                              YangType type,
                                               PatternStatementContext ctx) {
 
-        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.setLine(ctx.getStart().getLine());
-            parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
-            throw parserException;
+        if (type.getDataType() != STRING && type.getDataType() != DERIVED) {
+            ParserException exc = new ParserException(E_INVALID_TYPE);
+            exc.setLine(ctx.getStart().getLine());
+            exc.setCharPosition(ctx.getStart().getCharPositionInLine());
+            throw exc;
         }
 
         // Validate and get valid pattern restriction string.
-        String patternArgument = getValidPattern(ctx);
+        String pattern = getValidPattern(ctx);
 
-        if (type.getDataType() == YangDataTypes.STRING) {
-            YangStringRestriction stringRestriction = (YangStringRestriction) type.getDataTypeExtendedInfo();
-            if (stringRestriction == null) {
-                stringRestriction = new YangStringRestriction();
-                stringRestriction.setFileName(listener.getFileName());
-                stringRestriction.setCharPosition(ctx.getStart().getCharPositionInLine());
-                stringRestriction.setLineNumber(ctx.getStart().getLine());
-                type.setDataTypeExtendedInfo(stringRestriction);
-                stringRestriction.addPattern(patternArgument);
-            } else {
-                stringRestriction.addPattern(patternArgument);
+        YangPatternRestriction patRes = new YangPatternRestriction(pattern);
+        patRes.setFileName(lis.getFileName());
+        patRes.setCharPosition(ctx.getStart().getCharPositionInLine());
+        patRes.setLineNumber(ctx.getStart().getLine());
+
+        if (type.getDataType() == STRING) {
+            YangStringRestriction strRes = (YangStringRestriction) type
+                    .getDataTypeExtendedInfo();
+            if (strRes == null) {
+                strRes = new YangStringRestriction();
+                strRes.setFileName(lis.getFileName());
+                strRes.setCharPosition(ctx.getStart().getCharPositionInLine());
+                strRes.setLineNumber(ctx.getStart().getLine());
+                type.setDataTypeExtendedInfo(strRes);
             }
-            listener.getParsedDataStack().push(stringRestriction);
+            strRes.addPaternRes(patRes);
         } else {
-            YangPatternRestriction patternRestriction = ((YangDerivedInfo<?>) type
-                    .getDataTypeExtendedInfo()).getPatternRestriction();
-            if (patternRestriction == null) {
-                patternRestriction = new YangPatternRestriction();
-                ((YangDerivedInfo<?>) type.getDataTypeExtendedInfo()).setPatternRestriction(patternRestriction);
-                patternRestriction.addPattern(patternArgument);
-            } else {
-                ((YangDerivedInfo<?>) type.getDataTypeExtendedInfo()).setPatternRestriction(patternRestriction);
-                patternRestriction.addPattern(patternArgument);
-            }
+            YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+                    .getDataTypeExtendedInfo();
+            info.addPatternRes(patRes);
         }
+        lis.getParsedDataStack().push(patRes);
     }
 
     /**
      * Performs validation and updates the data model tree.
      * It is called when parser exits from grammar rule (pattern).
      *
-     * @param listener listener's object
-     * @param ctx      context object of the grammar rule
+     * @param listener listener object
+     * @param ctx      context object
      */
     public static void processPatternRestrictionExit(TreeWalkListener listener,
                                                      PatternStatementContext ctx) {
 
+        String txt = ctx.string().getText();
+
         // Check for stack to be non empty.
-        checkStackIsNotEmpty(listener, MISSING_HOLDER, PATTERN_DATA, ctx.string().getText(), EXIT);
+        checkStackIsNotEmpty(listener, MISSING_HOLDER, PATTERN_DATA, txt, EXIT);
 
         Parsable tmpData = listener.getParsedDataStack().peek();
-        if (tmpData instanceof YangStringRestriction) {
-            listener.getParsedDataStack().pop();
-        } else if (tmpData instanceof YangType
-                && ((YangType) tmpData).getDataType() == DERIVED) {
-            // TODO : need to handle in linker
-        } else {
-            throw new ParserException(constructListenerErrorMessage(MISSING_CURRENT_HOLDER, PATTERN_DATA,
-                                                                    ctx.string().getText(), EXIT));
+        if (!(tmpData instanceof YangPatternRestriction)) {
+            throw new ParserException(constructListenerErrorMessage(
+                    MISSING_CURRENT_HOLDER, PATTERN_DATA, txt, EXIT));
         }
+        listener.getParsedDataStack().pop();
     }
 
     /**
      * Validates and return the valid pattern.
      *
-     * @param ctx context object of the grammar rule
+     * @param ctx context object
      * @return validated string
      */
     private static String getValidPattern(PatternStatementContext ctx) {
         List<TerminalNode> patternList = ctx.string().STRING();
-        StringBuilder userInputPattern = new StringBuilder();
+        StringBuilder inputPat = new StringBuilder();
         String compile;
         for (TerminalNode pattern : patternList) {
-            userInputPattern.append(pattern.getText());
+            inputPat.append(pattern.getText());
         }
-        compile = userInputPattern.toString().replaceAll("[\'\"]", EMPTY_STRING);
+        compile = inputPat.toString().replaceAll("[\'\"]", EMPTY_STRING);
         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.setLine(ctx.getStart().getLine());
-            parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
-            throw parserException;
+        } catch (PatternSyntaxException e) {
+            ParserException exc = new ParserException(
+                    "YANG file error : " + getYangConstructType(PATTERN_DATA)
+                            + " name " + ctx.string().getText()
+                            + " is not a valid regular expression");
+            exc.setLine(ctx.getStart().getLine());
+            exc.setCharPosition(ctx.getStart().getCharPositionInLine());
+            throw exc;
         }
         return compile;
     }
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListener.java
index 418482f..9eb2597 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListener.java
@@ -22,6 +22,7 @@
 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.builtindatatype.YangDataTypes;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
 
@@ -55,7 +56,8 @@
  *                          "}")
  *
  * ANTLR grammar rule
- *  rangeStatement : RANGE_KEYWORD range (STMTEND | LEFT_CURLY_BRACE commonStatements RIGHT_CURLY_BRACE);
+ *  rangeStatement : RANGE_KEYWORD range (STMTEND | LEFT_CURLY_BRACE
+ *  commonStatements RIGHT_CURLY_BRACE);
  */
 
 /**
@@ -64,6 +66,9 @@
  */
 public final class RangeRestrictionListener {
 
+    private static final String E_INVALID_TYPE = "YANG file error: Range " +
+            "restriction can't be applied to a given type";
+
     /**
      * Creates a new range restriction listener.
      */
@@ -71,116 +76,115 @@
     }
 
     /**
-     * It is called when parser receives an input matching the grammar
-     * rule (range), performs validation and updates the data model
+     * Processes pattern restriction, when parser receives an input matching
+     * the grammar rule (range), performs validation and updates the data model
      * tree.
      *
-     * @param listener listener's object
-     * @param ctx      context object of the grammar rule
+     * @param lis listener object
+     * @param ctx context object
      */
-    public static void processRangeRestrictionEntry(TreeWalkListener listener,
+    public static void processRangeRestrictionEntry(TreeWalkListener lis,
                                                     RangeStatementContext ctx) {
 
         // Check for stack to be non empty.
-        checkStackIsNotEmpty(listener, MISSING_HOLDER, RANGE_DATA, ctx.range().getText(), ENTRY);
+        checkStackIsNotEmpty(lis, MISSING_HOLDER, RANGE_DATA,
+                             ctx.range().getText(), ENTRY);
 
-        Parsable tmpData = listener.getParsedDataStack().peek();
+        Parsable tmpData = lis.getParsedDataStack().peek();
         if (tmpData.getYangConstructType() == TYPE_DATA) {
             YangType type = (YangType) tmpData;
-            setRangeRestriction(listener, type, ctx);
+            setRangeRestriction(lis, type, ctx);
         } else {
-            throw new ParserException(constructListenerErrorMessage(INVALID_HOLDER, RANGE_DATA,
-                                                                    ctx.range().getText(), ENTRY));
+            throw new ParserException(constructListenerErrorMessage(
+                    INVALID_HOLDER, RANGE_DATA, ctx.range().getText(), ENTRY));
         }
     }
 
     /**
      * Sets the range restriction to type.
      *
-     * @param listener listener's object
-     * @param type     YANG type for which range restriction to be added
-     * @param ctx      context object of the grammar rule
+     * @param lis  listener's object
+     * @param type YANG type
+     * @param ctx  context object
      */
-    private static void setRangeRestriction(TreeWalkListener listener, YangType type,
+    private static void setRangeRestriction(TreeWalkListener lis, YangType type,
                                             RangeStatementContext ctx) {
+        String txt = ctx.range().getText();
+        int line = ctx.getStart().getLine();
+        int pos = ctx.getStart().getCharPositionInLine();
+        YangDataTypes dataType = type.getDataType();
 
-        if (type.getDataType() == DERIVED) {
-            ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
-                    .setRangeRestrictionString(ctx.range().getText());
-            ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
-                    .setLineNumber(ctx.getStart().getLine());
-            ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
-                    .setCharPosition(ctx.getStart().getCharPositionInLine());
+        YangRangeRestriction ranRes = new YangRangeRestriction(txt);
+        ranRes.setFileName(lis.getFileName());
+        ranRes.setCharPosition(pos);
+        ranRes.setLineNumber(line);
+        lis.getParsedDataStack().push(ranRes);
+
+        if (dataType == DERIVED) {
+            YangDerivedInfo info = (YangDerivedInfo<?>) type
+                    .getDataTypeExtendedInfo();
+            info.setRangeRes(ranRes);
+            info.setFileName(lis.getFileName());
+            info.setCharPosition(pos);
+            info.setLineNumber(line);
             return;
         }
 
-        if (!(isOfRangeRestrictedType(type.getDataType())) && (type.getDataType() != DECIMAL64)) {
-            ParserException parserException = new ParserException("YANG file error: Range restriction can't be " +
-                                                                          "applied to a given type");
-            parserException.setLine(ctx.getStart().getLine());
-            parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
-            throw parserException;
+        if (!(isOfRangeRestrictedType(dataType)) && (dataType != DECIMAL64)) {
+            ParserException exc = new ParserException(E_INVALID_TYPE);
+            exc.setLine(line);
+            exc.setCharPosition(pos);
+            throw exc;
         }
-
-        YangRangeRestriction rangeRestriction = null;
         try {
-            if (type.getDataType() == DECIMAL64) {
-                YangDecimal64 yangDecimal64 = (YangDecimal64) type.getDataTypeExtendedInfo();
-                rangeRestriction =
-                        processRangeRestriction(yangDecimal64.getDefaultRangeRestriction(),
-                                                ctx.getStart().getLine(),
-                                                ctx.getStart().getCharPositionInLine(),
-                                                true, ctx.range().getText(),
-                                                type.getDataType(), listener.getFileName());
+            if (dataType == DECIMAL64) {
+                YangDecimal64 deci64 = (YangDecimal64) type
+                        .getDataTypeExtendedInfo();
+                ranRes = processRangeRestriction(
+                        deci64.getDefaultRangeRestriction(), line, pos, true,
+                        ranRes, dataType, lis.getFileName());
             } else {
-                rangeRestriction =
-                        processRangeRestriction(null, ctx.getStart().getLine(),
-                                                ctx.getStart().getCharPositionInLine(),
-                                                false, ctx.range()
-                                                        .getText(), type
-                                                        .getDataType(),
-                                                listener.getFileName());
+                ranRes = processRangeRestriction(null, line, pos, false, ranRes,
+                                                 dataType, lis.getFileName());
             }
         } catch (DataModelException e) {
-            ParserException parserException = new ParserException(e.getMessage());
-            parserException.setCharPosition(e.getCharPositionInLine());
-            parserException.setLine(e.getLineNumber());
-            throw parserException;
+            ParserException exc = new ParserException(e.getMessage());
+            exc.setCharPosition(e.getCharPositionInLine());
+            exc.setLine(e.getLineNumber());
+            throw exc;
         }
 
-        if (rangeRestriction != null) {
-            if (type.getDataType() == DECIMAL64) {
-                ((YangDecimal64<YangRangeRestriction>) type.getDataTypeExtendedInfo())
-                        .setRangeRestrictedExtendedInfo(rangeRestriction);
+        if (ranRes != null) {
+            if (dataType == DECIMAL64) {
+                ((YangDecimal64<YangRangeRestriction>) type
+                        .getDataTypeExtendedInfo())
+                        .setRangeRestrictedExtendedInfo(ranRes);
             } else {
-                type.setDataTypeExtendedInfo(rangeRestriction);
+                type.setDataTypeExtendedInfo(ranRes);
             }
         }
-        listener.getParsedDataStack().push(rangeRestriction);
     }
 
     /**
      * Performs validation and updates the data model tree.
      * It is called when parser exits from grammar rule (range).
      *
-     * @param listener listener's object
-     * @param ctx      context object of the grammar rule
+     * @param lis listener object
+     * @param ctx context object
      */
-    public static void processRangeRestrictionExit(TreeWalkListener listener,
+    public static void processRangeRestrictionExit(TreeWalkListener lis,
                                                    RangeStatementContext ctx) {
 
-        // Check for stack to be non empty.
-        checkStackIsNotEmpty(listener, MISSING_HOLDER, RANGE_DATA, ctx.range().getText(), EXIT);
+        String txt = ctx.range().getText();
 
-        Parsable tmpData = listener.getParsedDataStack().peek();
-        if (tmpData instanceof YangRangeRestriction) {
-            listener.getParsedDataStack().pop();
-        } else if (tmpData instanceof YangType
-                && ((YangType) tmpData).getDataType() == DERIVED) {
-            // TODO : need to handle in linker
-        } else {
-            throw new ParserException(constructListenerErrorMessage(MISSING_CURRENT_HOLDER, RANGE_DATA,
-                                                                    ctx.range().getText(), EXIT));
+        // Check for stack to be non empty.
+        checkStackIsNotEmpty(lis, MISSING_HOLDER, RANGE_DATA, txt, EXIT);
+
+        Parsable tmpData = lis.getParsedDataStack().peek();
+        if (!(tmpData instanceof YangRangeRestriction)) {
+            throw new ParserException(constructListenerErrorMessage(
+                    MISSING_CURRENT_HOLDER, RANGE_DATA, txt, EXIT));
         }
+        lis.getParsedDataStack().pop();
     }
 }
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64ListenerTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64ListenerTest.java
index 8a54a51..3498273 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64ListenerTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64ListenerTest.java
@@ -563,13 +563,15 @@
     public void processDecimal64MultiTypedefMultiInvalidRangeStatement() throws IOException, LinkerException {
         thrown.expect(LinkerException.class);
         thrown.expectMessage(
-                "Range interval doesn't fall within the referred restriction ranges" +
-                        " restriction ranges. in 0 at 0 in src/test/resources/decimal64/" +
-                        "Decimal64MultiTypedefMultiInvalidRangeStatement.yang\"type." +
-                        " in 19 at 12 in src/test/resources/decimal64/Decimal64MultiTypedef" +
-                        "MultiInvalidRangeStatement.yang");
+                "Range interval doesn't fall within the referred restriction" +
+                        " ranges restriction ranges. in 9 at 12 in src/test/" +
+                        "resources/decimal64/Decimal64MultiTypedefMultiInval" +
+                        "idRangeStatement.yang\"type. in 19 at 12 in src/tes" +
+                        "t/resources/decimal64/Decimal64MultiTypedefMultiInv" +
+                        "alidRangeStatement.yang");
 
-        manager.getDataModel("src/test/resources/decimal64/Decimal64MultiTypedefMultiInvalidRangeStatement.yang");
+        manager.getDataModel("src/test/resources/decimal64/Decimal64MultiTyp" +
+                                     "edefMultiInvalidRangeStatement.yang");
     }
 
     /**
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListenerTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListenerTest.java
index af9572f..bae9399 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListenerTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListenerTest.java
@@ -27,8 +27,8 @@
 import org.onosproject.yang.compiler.datamodel.YangRangeInterval;
 import org.onosproject.yang.compiler.datamodel.YangRangeRestriction;
 import org.onosproject.yang.compiler.datamodel.YangStringRestriction;
+import org.onosproject.yang.compiler.datamodel.YangType;
 import org.onosproject.yang.compiler.datamodel.YangTypeDef;
-import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
 import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangUint64;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.YangUtilsParserManager;
@@ -37,49 +37,55 @@
 import java.math.BigInteger;
 import java.util.ListIterator;
 
+import static java.math.BigInteger.valueOf;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.BINARY;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.STRING;
 
 /**
  * Test cases for length restriction listener.
  */
 public class LengthRestrictionListenerTest {
 
+    private final YangUtilsParserManager manager = new YangUtilsParserManager();
     @Rule
     public ExpectedException thrown = ExpectedException.none();
 
-    private final YangUtilsParserManager manager = new YangUtilsParserManager();
-
     /**
      * Checks valid length statement as sub-statement of leaf statement.
      */
     @Test
     public void processValidLengthStatement() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/ValidLengthStatement.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/ValidLengthStatement.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
-        YangLeaf leafInfo = leafIterator.next();
+        ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+        YangLeaf leaf = it.next();
+        YangType<?> type = leaf.getDataType();
 
-        assertThat(leafInfo.getName(), is("invalid-interval"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        YangStringRestriction stringRestriction = (YangStringRestriction) leafInfo
-                .getDataType().getDataTypeExtendedInfo();
-        YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
+        assertThat(leaf.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("string"));
+        assertThat(type.getDataType(), is(STRING));
+        YangStringRestriction strRes = (YangStringRestriction) type
+                .getDataTypeExtendedInfo();
+        YangRangeRestriction lenRes = strRes.getLengthRestriction();
 
-        ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
-                .listIterator();
+        ListIterator<YangRangeInterval> lenIt = lenRes
+                .getAscendingRangeIntervals().listIterator();
 
-        YangRangeInterval rangeInterval = lengthListIterator.next();
+        YangRangeInterval range = lenIt.next();
 
-        assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
-        assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+        assertThat(((YangUint64) range.getStartValue()).getValue(),
+                   is(valueOf(0)));
+        assertThat(((YangUint64) range.getEndValue()).getValue(),
+                   is(valueOf(100)));
     }
 
     /**
@@ -88,29 +94,33 @@
     @Test
     public void processLengthStatementInsideLeafList() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/LengthStatementInsideLeafList.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/LengthStatementInsideLeafList.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
-        YangLeafList leafListInfo = leafListIterator.next();
-
-        assertThat(leafListInfo.getName(), is("invalid-interval"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
-                .getDataType().getDataTypeExtendedInfo();
-        YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
-
-        ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
+        ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
                 .listIterator();
+        YangLeafList ll = it.next();
+        YangType<?> type = ll.getDataType();
+        assertThat(ll.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("string"));
+        assertThat(type.getDataType(), is(STRING));
+        YangStringRestriction strRes = (YangStringRestriction) type
+                .getDataTypeExtendedInfo();
+        YangRangeRestriction lenRes = strRes.getLengthRestriction();
 
-        YangRangeInterval rangeInterval = lengthListIterator.next();
-        assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(1)));
-        assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+        ListIterator<YangRangeInterval> llIt = lenRes
+                .getAscendingRangeIntervals().listIterator();
+
+        YangRangeInterval range = llIt.next();
+        assertThat(((YangUint64) range.getStartValue()).getValue(),
+                   is(valueOf(1)));
+        assertThat(((YangUint64) range.getEndValue()).getValue(),
+                   is(valueOf(100)));
     }
 
     /**
@@ -119,7 +129,8 @@
     @Test
     public void processLengthStatementInsideTypeDef() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/LengthStatementInsideTypeDef.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/LengthStatementInsideTypeDef.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
@@ -127,15 +138,20 @@
         assertThat(yangNode.getName(), is("Test"));
 
         YangTypeDef typedef = (YangTypeDef) yangNode.getChild();
-        YangStringRestriction stringRestriction = (YangStringRestriction) typedef.getTypeDefBaseType()
-                .getDataTypeExtendedInfo();
+        YangStringRestriction strRes = (YangStringRestriction) typedef
+                .getTypeDefBaseType().getDataTypeExtendedInfo();
 
-        YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
-        ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
+        YangRangeRestriction lenRes = strRes.getLengthRestriction();
+        assertThat(lenRes.getDescription(),
+                   is("\"length-description typedef\""));
+        assertThat(lenRes.getReference(), is("\"reference typedef\""));
+        ListIterator<YangRangeInterval> it = lenRes.getAscendingRangeIntervals()
                 .listIterator();
-        YangRangeInterval rangeInterval = lengthListIterator.next();
-        assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(1)));
-        assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+        YangRangeInterval rangeInterval = it.next();
+        assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(),
+                   is(valueOf(1)));
+        assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(),
+                   is(valueOf(100)));
     }
 
     /**
@@ -144,29 +160,36 @@
     @Test
     public void processValidBinaryLengthStatement() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/ValidBinaryLengthStatement.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/ValidBinaryLengthStatement.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
-        YangLeaf leafInfo = leafIterator.next();
+        ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+        YangLeaf leaf = it.next();
+        YangType<?> type = leaf.getDataType();
 
-        assertThat(leafInfo.getName(), is("message"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("binary"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.BINARY));
-        YangRangeRestriction lengthRestriction = (YangRangeRestriction) leafInfo
-                                                  .getDataType().getDataTypeExtendedInfo();
+        assertThat(leaf.getName(), is("message"));
+        assertThat(type.getDataTypeName(), is("binary"));
+        assertThat(type.getDataType(), is(BINARY));
+        YangRangeRestriction lenRes = (YangRangeRestriction) type
+                .getDataTypeExtendedInfo();
 
-        ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
-                .listIterator();
+        assertThat(lenRes.getDescription(), is("\"binary description\""));
+        assertThat(lenRes.getReference(), is("\"binary reference\""));
 
-        YangRangeInterval rangeInterval = lengthListIterator.next();
+        ListIterator<YangRangeInterval> llIt = lenRes
+                .getAscendingRangeIntervals().listIterator();
 
-        assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(4)));
-        assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(4)));
+        YangRangeInterval range = llIt.next();
+
+        assertThat(((YangUint64) range.getStartValue()).getValue(),
+                   is(valueOf(4)));
+        assertThat(((YangUint64) range.getEndValue()).getValue(),
+                   is(valueOf(4)));
     }
 
     /**
@@ -175,9 +198,11 @@
     @Test
     public void processLengthWithInvalidType() throws IOException, ParserException {
         thrown.expect(ParserException.class);
-        thrown.expectMessage("YANG file error : length name \"1..100\" can be used to restrict the built-in type" +
-                " string/binary or types derived from string/binary.");
-        YangNode node = manager.getDataModel("src/test/resources/LengthWithInvalidType.yang");
+        thrown.expectMessage("YANG file error : Length can only be used to" +
+                                     " restrict the built-in type string/" +
+                                     "binary or types derived from string/" +
+                                     "binary");
+        manager.getDataModel("src/test/resources/LengthWithInvalidType.yang");
     }
 
     /**
@@ -187,29 +212,34 @@
     public void processLengthWithOneInterval() throws IOException, ParserException {
 
 
-        YangNode node = manager.getDataModel("src/test/resources/LengthWithOneInterval.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/LengthWithOneInterval.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
-        YangLeafList leafListInfo = leafListIterator.next();
-
-        assertThat(leafListInfo.getName(), is("invalid-interval"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
-                .getDataType().getDataTypeExtendedInfo();
-        YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
-
-        ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
+        ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
                 .listIterator();
+        YangLeafList ll = it.next();
+        YangType<?> type = ll.getDataType();
 
-        YangRangeInterval rangeInterval = lengthListIterator.next();
-        assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(1)));
-        assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(1)));
+        assertThat(ll.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("string"));
+        assertThat(type.getDataType(), is(STRING));
+        YangStringRestriction strRes = (YangStringRestriction) type
+                .getDataTypeExtendedInfo();
+        YangRangeRestriction lenRes = strRes.getLengthRestriction();
+
+        ListIterator<YangRangeInterval> llIt = lenRes
+                .getAscendingRangeIntervals().listIterator();
+
+        YangRangeInterval range = llIt.next();
+        assertThat(((YangUint64) range.getStartValue()).getValue(),
+                   is(valueOf(1)));
+        assertThat(((YangUint64) range.getEndValue()).getValue(),
+                   is(valueOf(1)));
     }
 
     /**
@@ -219,29 +249,34 @@
     public void processLengthWithMinMax() throws IOException, ParserException {
 
 
-        YangNode node = manager.getDataModel("src/test/resources/LengthWithMinMax.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/LengthWithMinMax.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
-        YangLeafList leafListInfo = leafListIterator.next();
-
-        assertThat(leafListInfo.getName(), is("invalid-interval"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
-                .getDataType().getDataTypeExtendedInfo();
-        YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
-
-        ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
+        ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
                 .listIterator();
+        YangLeafList ll = it.next();
+        YangType<?> type = ll.getDataType();
 
-        YangRangeInterval rangeInterval = lengthListIterator.next();
-        assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
-        assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(new BigInteger("18446744073709551615")));
+        assertThat(ll.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("string"));
+        assertThat(type.getDataType(), is(STRING));
+        YangStringRestriction strRes = (YangStringRestriction) type
+                .getDataTypeExtendedInfo();
+        YangRangeRestriction lenRes = strRes.getLengthRestriction();
+
+        ListIterator<YangRangeInterval> llIt = lenRes
+                .getAscendingRangeIntervals().listIterator();
+
+        YangRangeInterval range = llIt.next();
+        assertThat(((YangUint64) range.getStartValue()).getValue(),
+                   is(valueOf(0)));
+        assertThat(((YangUint64) range.getEndValue()).getValue(),
+                   is(new BigInteger("18446744073709551615")));
     }
 
     /**
@@ -250,8 +285,10 @@
     @Test
     public void processLengthWithInvalidIntegerPattern() throws IOException, ParserException {
         thrown.expect(ParserException.class);
-        thrown.expectMessage("YANG file error : Input value \"a\" is not a valid uint64.");
-        YangNode node = manager.getDataModel("src/test/resources/LengthWithInvalidIntegerPattern.yang");
+        thrown.expectMessage("YANG file error : Input value \"a\" is not a" +
+                                     " valid uint64.");
+        manager.getDataModel("src/test/resources/LengthWithInvalidI" +
+                                     "ntegerPattern.yang");
     }
 
     /**
@@ -260,44 +297,50 @@
     @Test
     public void processLengthWithInvalidInterval() throws IOException, ParserException {
         thrown.expect(ParserException.class);
-        thrown.expectMessage("YANG file error : 18446744073709551617 is greater than maximum value" +
-                " 18446744073709551615.");
-        YangNode node = manager.getDataModel("src/test/resources/LengthWithInvalidInterval.yang");
+        thrown.expectMessage("YANG file error : 18446744073709551617 is gre" +
+                                     "ater than maximum value " +
+                                     "18446744073709551615.");
+        manager.getDataModel("src/test/resources/LengthWithInvalidInter" +
+                                     "val.yang");
     }
 
     /**
-     * Checks valid length substatements.
+     * Checks valid length sub-statements.
      */
     @Test
     public void processLengthSubStatements() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/LengthSubStatements.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/LengthSubStatements.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
-        YangLeaf leafInfo = leafIterator.next();
+        ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+        YangLeaf leaf = it.next();
+        YangType<?> type = leaf.getDataType();
 
-        assertThat(leafInfo.getName(), is("invalid-interval"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        YangStringRestriction stringRestriction = (YangStringRestriction) leafInfo
-                .getDataType().getDataTypeExtendedInfo();
-        YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
+        assertThat(leaf.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("string"));
+        assertThat(type.getDataType(), is(STRING));
+        YangStringRestriction strRes = (YangStringRestriction) type
+                .getDataTypeExtendedInfo();
+        YangRangeRestriction lenRes = strRes.getLengthRestriction();
 
-        assertThat(lengthRestriction.getDescription(), is("\"length description\""));
-        assertThat(lengthRestriction.getReference(), is("\"length reference\""));
+        assertThat(lenRes.getDescription(), is("\"length description\""));
+        assertThat(lenRes.getReference(), is("\"length reference\""));
 
-        ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
-                .listIterator();
+        ListIterator<YangRangeInterval> llIt = lenRes
+                .getAscendingRangeIntervals().listIterator();
 
-        YangRangeInterval rangeInterval = lengthListIterator.next();
+        YangRangeInterval range = llIt.next();
 
-        assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
-        assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+        assertThat(((YangUint64) range.getStartValue()).getValue(),
+                   is(valueOf(0)));
+        assertThat(((YangUint64) range.getEndValue()).getValue(),
+                   is(valueOf(100)));
     }
 
     /**
@@ -306,29 +349,33 @@
     @Test
     public void processLengthStatementWithSpace() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/LengthStatementWithSpace.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/LengthStatementWithSpace.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
-        YangLeaf leafInfo = leafIterator.next();
+        ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+        YangLeaf leaf = it.next();
+        YangType<?> type = leaf.getDataType();
 
-        assertThat(leafInfo.getName(), is("invalid-interval"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        YangStringRestriction stringRestriction = (YangStringRestriction) leafInfo
-                .getDataType().getDataTypeExtendedInfo();
-        YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
+        assertThat(leaf.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("string"));
+        assertThat(type.getDataType(), is(STRING));
+        YangStringRestriction strRes = (YangStringRestriction) type
+                .getDataTypeExtendedInfo();
+        YangRangeRestriction lenRes = strRes.getLengthRestriction();
 
-        ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
-                .listIterator();
+        ListIterator<YangRangeInterval> llIt = lenRes
+                .getAscendingRangeIntervals().listIterator();
 
-        YangRangeInterval rangeInterval = lengthListIterator.next();
+        YangRangeInterval range = llIt.next();
 
-        assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
-        assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+        assertThat(((YangUint64) range.getStartValue()).getValue(),
+                   is(valueOf(0)));
+        assertThat(((YangUint64) range.getEndValue()).getValue(),
+                   is(valueOf(100)));
     }
 }
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListenerTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListenerTest.java
index ce63ef2..c0f0c5b 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListenerTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListenerTest.java
@@ -31,6 +31,7 @@
 import org.onosproject.yang.compiler.parser.impl.YangUtilsParserManager;
 
 import java.io.IOException;
+import java.util.List;
 import java.util.ListIterator;
 
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -49,35 +50,35 @@
     @Test
     public void processValidPatternStatement() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/ValidPatternStatement.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/ValidPatternStatement.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), Is.is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
-        YangLeaf leafInfo = leafIterator.next();
+        ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+        YangLeaf leaf = it.next();
 
-        assertThat(leafInfo.getName(), is("invalid-interval"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        YangStringRestriction stringRestriction = (YangStringRestriction) leafInfo
+        assertThat(leaf.getName(), is("invalid-interval"));
+        assertThat(leaf.getDataType().getDataTypeName(), is("string"));
+        assertThat(leaf.getDataType().getDataType(), is(YangDataTypes.STRING));
+        YangStringRestriction strRes = (YangStringRestriction) leaf
                 .getDataType().getDataTypeExtendedInfo();
-        ListIterator<String> patternListIterator = stringRestriction.getPatternRestriction()
-                .getPatternList().listIterator();
-        assertThat(patternListIterator.next(), is("[a-zA-Z]"));
+        ListIterator<YangPatternRestriction> patIt = strRes
+                .getPatternResList().listIterator();
+        assertThat(patIt.next().getPattern(), is("[a-zA-Z]"));
 
-        leafInfo = leafIterator.next();
+        leaf = it.next();
 
-        assertThat(leafInfo.getName(), is("ipv4-address"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        stringRestriction = (YangStringRestriction) leafInfo
-                .getDataType().getDataTypeExtendedInfo();
-        patternListIterator = stringRestriction.getPatternRestriction()
-                .getPatternList().listIterator();
-        assertThat(patternListIterator.next(), is(
+        assertThat(leaf.getName(), is("ipv4-address"));
+        assertThat(leaf.getDataType().getDataTypeName(), is("string"));
+        assertThat(leaf.getDataType().getDataType(), is(YangDataTypes.STRING));
+        strRes = (YangStringRestriction) leaf.getDataType()
+                .getDataTypeExtendedInfo();
+        patIt = strRes.getPatternResList().listIterator();
+        assertThat(patIt.next().getPattern(), is(
                 "(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}" +
                         "([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])" +
                         "(%[\\p{N}\\p{L}]+)?"));
@@ -89,24 +90,26 @@
     @Test
     public void processPatternStatementInsideLeafList() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/PatternStatementInsideLeafList.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/PatternStatementInsideLeafList.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
-        YangLeafList leafListInfo = leafListIterator.next();
+        ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
+                .listIterator();
+        YangLeafList ll = it.next();
 
-        assertThat(leafListInfo.getName(), is("invalid-interval"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
+        assertThat(ll.getName(), is("invalid-interval"));
+        assertThat(ll.getDataType().getDataTypeName(), is("string"));
+        assertThat(ll.getDataType().getDataType(), is(YangDataTypes.STRING));
+        YangStringRestriction strRes = (YangStringRestriction) ll
                 .getDataType().getDataTypeExtendedInfo();
-        ListIterator<String> patternListIterator = stringRestriction.getPatternRestriction()
-                .getPatternList().listIterator();
-        assertThat(patternListIterator.next(), is("[a-zA-Z]"));
+        ListIterator<YangPatternRestriction> patIt = strRes.getPatternResList()
+                .listIterator();
+        assertThat(patIt.next().getPattern(), is("[a-zA-Z]"));
     }
 
     /**
@@ -115,7 +118,8 @@
     @Test
     public void processPatternStatementInsideTypeDef() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/PatternStatementInsideTypeDef.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/PatternStatementInsideTypeDef.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
@@ -123,11 +127,11 @@
         assertThat(yangNode.getName(), is("Test"));
 
         YangTypeDef typedef = (YangTypeDef) yangNode.getChild();
-        YangStringRestriction stringRestriction = (YangStringRestriction) typedef.getTypeDefBaseType()
-                .getDataTypeExtendedInfo();
+        YangStringRestriction strRes = (YangStringRestriction) typedef
+                .getTypeDefBaseType().getDataTypeExtendedInfo();
 
-        YangPatternRestriction yangPatternRestriction = stringRestriction.getPatternRestriction();
-        assertThat(yangPatternRestriction.getPatternList().listIterator().next(), is("[a-zA-Z]"));
+        List<YangPatternRestriction> patRes = strRes.getPatternResList();
+        assertThat(patRes.listIterator().next().getPattern(), is("[a-zA-Z]"));
     }
 
     /**
@@ -136,24 +140,26 @@
     @Test
     public void processMultiplePatternStatement() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/MultiplePatternStatement.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/MultiplePatternStatement.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
-        YangLeafList leafListInfo = leafListIterator.next();
+        ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
+                .listIterator();
+        YangLeafList ll = it.next();
 
-        assertThat(leafListInfo.getName(), is("invalid-interval"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
-                .getDataType().getDataTypeExtendedInfo();
-        ListIterator<String> patternListIterator = stringRestriction.getPatternRestriction()
-                .getPatternList().listIterator();
-        assertThat(patternListIterator.next(), is("[a-zA-Z]"));
+        assertThat(ll.getName(), is("invalid-interval"));
+        assertThat(ll.getDataType().getDataTypeName(), is("string"));
+        assertThat(ll.getDataType().getDataType(), is(YangDataTypes.STRING));
+        YangStringRestriction strRes = (YangStringRestriction) ll.getDataType()
+                .getDataTypeExtendedInfo();
+        ListIterator<YangPatternRestriction> patIt = strRes.getPatternResList()
+                .listIterator();
+        assertThat(patIt.next().getPattern(), is("[a-zA-Z]"));
     }
 
     /**
@@ -162,23 +168,25 @@
     @Test
     public void processPatternStatementWithPlus() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/PatternStatementWithPlus.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/PatternStatementWithPlus.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
-        YangLeafList leafListInfo = leafListIterator.next();
+        ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
+                .listIterator();
+        YangLeafList ll = it.next();
 
-        assertThat(leafListInfo.getName(), is("invalid-interval"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
-                .getDataType().getDataTypeExtendedInfo();
-        ListIterator<String> patternListIterator = stringRestriction.getPatternRestriction()
-                .getPatternList().listIterator();
+        assertThat(ll.getName(), is("invalid-interval"));
+        assertThat(ll.getDataType().getDataTypeName(), is("string"));
+        assertThat(ll.getDataType().getDataType(), is(YangDataTypes.STRING));
+        YangStringRestriction strRes = (YangStringRestriction) ll.getDataType()
+                .getDataTypeExtendedInfo();
+        ListIterator<YangPatternRestriction> patIt = strRes.getPatternResList()
+                .listIterator();
         //FIXME: + should not be remove from the end.
         //assertThat(patternListIterator.next(), is("-[0-9]+|[0-9]+"));
     }
@@ -189,26 +197,28 @@
     @Test
     public void processPatternSubStatements() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/PatternSubStatements.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/PatternSubStatements.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
-        YangLeaf leafInfo = leafIterator.next();
+        ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+        YangLeaf leaf = it.next();
 
-        assertThat(leafInfo.getName(), is("invalid-interval"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
-        YangStringRestriction stringRestriction = (YangStringRestriction) leafInfo
+        assertThat(leaf.getName(), is("invalid-interval"));
+        assertThat(leaf.getDataType().getDataTypeName(), is("string"));
+        assertThat(leaf.getDataType().getDataType(), is(YangDataTypes.STRING));
+        YangStringRestriction strRes = (YangStringRestriction) leaf
                 .getDataType().getDataTypeExtendedInfo();
-        assertThat(stringRestriction.getDescription(), is("\"pattern description\""));
-        assertThat(stringRestriction.getReference(), is("\"pattern reference\""));
-        ListIterator<String> patternListIterator = stringRestriction.getPatternRestriction()
-                .getPatternList().listIterator();
-        assertThat(patternListIterator.next(), is("[a-zA-Z]"));
+        ListIterator<YangPatternRestriction> patIt = strRes.getPatternResList()
+                .listIterator();
+        YangPatternRestriction pat = patIt.next();
+        assertThat(pat.getDescription(), is("\"pattern description\""));
+        assertThat(pat.getReference(), is("\"pattern reference\""));
+        assertThat(pat.getPattern(), is("[a-zA-Z]"));
     }
 
     /**
@@ -216,6 +226,7 @@
      */
     @Test(expected = ParserException.class)
     public void processInvalidPatternSubStatements() throws IOException, ParserException {
-        YangNode node = manager.getDataModel("src/test/resources/InvalidPatternSubStatements.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/InvalidPatternSubStatements.yang");
     }
 }
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListenerTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListenerTest.java
index ab3cc4c..370514d 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListenerTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListenerTest.java
@@ -19,6 +19,7 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
+import org.onosproject.yang.compiler.datamodel.YangDerivedInfo;
 import org.onosproject.yang.compiler.datamodel.YangLeaf;
 import org.onosproject.yang.compiler.datamodel.YangLeafList;
 import org.onosproject.yang.compiler.datamodel.YangModule;
@@ -26,8 +27,10 @@
 import org.onosproject.yang.compiler.datamodel.YangNodeType;
 import org.onosproject.yang.compiler.datamodel.YangRangeInterval;
 import org.onosproject.yang.compiler.datamodel.YangRangeRestriction;
-import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
+import org.onosproject.yang.compiler.datamodel.YangType;
+import org.onosproject.yang.compiler.datamodel.YangTypeDef;
 import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangInt32;
+import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangUint8;
 import org.onosproject.yang.compiler.parser.exceptions.ParserException;
 import org.onosproject.yang.compiler.parser.impl.YangUtilsParserManager;
 
@@ -36,44 +39,48 @@
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.DERIVED;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.INT32;
 
 /**
  * Test cases for range restriction listener.
  */
 public class RangeRestrictionListenerTest {
 
+    private final YangUtilsParserManager manager = new YangUtilsParserManager();
     @Rule
     public ExpectedException thrown = ExpectedException.none();
 
-    private final YangUtilsParserManager manager = new YangUtilsParserManager();
-
     /**
      * Checks valid range statement as sub-statement of leaf statement.
      */
     @Test
     public void processValidRangeStatement() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/ValidRangeStatement.yang");
+        YangNode node = manager.getDataModel("src/test/resources/ValidRange" +
+                                                     "Statement.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
-        YangLeaf leafInfo = leafIterator.next();
+        ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+        YangLeaf leaf = it.next();
 
-        assertThat(leafInfo.getName(), is("invalid-interval"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("int32"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
-        YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafInfo
-                .getDataType().getDataTypeExtendedInfo();
+        YangType<?> type = leaf.getDataType();
 
-        ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
-                .listIterator();
-        YangRangeInterval rangeInterval = rangeListIterator.next();
-        assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(1));
-        assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(4));
+        assertThat(leaf.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("int32"));
+        assertThat(type.getDataType(), is(INT32));
+        YangRangeRestriction ranRes = (YangRangeRestriction) type
+                .getDataTypeExtendedInfo();
+
+        ListIterator<YangRangeInterval> rlIt = ranRes
+                .getAscendingRangeIntervals().listIterator();
+        YangRangeInterval range = rlIt.next();
+        assertThat(((YangInt32) range.getStartValue()).getValue(), is(1));
+        assertThat(((YangInt32) range.getEndValue()).getValue(), is(4));
     }
 
     /**
@@ -82,28 +89,32 @@
     @Test
     public void processRangeStatementInsideLeafList() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/RangeStatementInsideLeafList.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/RangeStatementInsideLeafList.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
-        YangLeafList leafListInfo = leafListIterator.next();
-
-        assertThat(leafListInfo.getName(), is("invalid-interval"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("int32"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
-        YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafListInfo
-                .getDataType().getDataTypeExtendedInfo();
-
-        ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
+        ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
                 .listIterator();
-        YangRangeInterval rangeInterval = rangeListIterator.next();
+        YangLeafList ll = it.next();
 
-        assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(1));
-        assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(4));
+        YangType<?> type = ll.getDataType();
+
+        assertThat(ll.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("int32"));
+        assertThat(type.getDataType(), is(INT32));
+        YangRangeRestriction ranRes = (YangRangeRestriction) type
+                .getDataTypeExtendedInfo();
+
+        ListIterator<YangRangeInterval> rlIt = ranRes
+                .getAscendingRangeIntervals().listIterator();
+        YangRangeInterval range = rlIt.next();
+
+        assertThat(((YangInt32) range.getStartValue()).getValue(), is(1));
+        assertThat(((YangInt32) range.getEndValue()).getValue(), is(4));
     }
 
     /**
@@ -112,28 +123,32 @@
     @Test
     public void processRangeWithOneInterval() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/RangeWithOneInterval.yang");
+        YangNode node = manager.getDataModel(
+                "src/test/resources/RangeWithOneInterval.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
-        YangLeafList leafListInfo = leafListIterator.next();
-
-        assertThat(leafListInfo.getName(), is("invalid-interval"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("int32"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
-        YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafListInfo
-                .getDataType().getDataTypeExtendedInfo();
-
-        ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
+        ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
                 .listIterator();
-        YangRangeInterval rangeInterval = rangeListIterator.next();
+        YangLeafList ll = it.next();
 
-        assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(1));
-        assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(1));
+        YangType<?> type = ll.getDataType();
+
+        assertThat(ll.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("int32"));
+        assertThat(type.getDataType(), is(INT32));
+        YangRangeRestriction ranRes = (YangRangeRestriction) type
+                .getDataTypeExtendedInfo();
+
+        ListIterator<YangRangeInterval> rlIt = ranRes
+                .getAscendingRangeIntervals().listIterator();
+        YangRangeInterval range = rlIt.next();
+
+        assertThat(((YangInt32) range.getStartValue()).getValue(), is(1));
+        assertThat(((YangInt32) range.getEndValue()).getValue(), is(1));
     }
 
     /**
@@ -142,28 +157,34 @@
     @Test
     public void processRangeWithMinMax() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/RangeWithMinMax.yang");
+        YangNode node = manager.getDataModel("src/test/resources/RangeWithM" +
+                                                     "inMax.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
-        YangLeafList leafListInfo = leafListIterator.next();
-
-        assertThat(leafListInfo.getName(), is("invalid-interval"));
-        assertThat(leafListInfo.getDataType().getDataTypeName(), is("int32"));
-        assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
-        YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafListInfo
-                .getDataType().getDataTypeExtendedInfo();
-
-        ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
+        ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
                 .listIterator();
-        YangRangeInterval rangeInterval = rangeListIterator.next();
+        YangLeafList ll = it.next();
 
-        assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(-2147483648));
-        assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(2147483647));
+        YangType<?> type = ll.getDataType();
+
+        assertThat(ll.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("int32"));
+        assertThat(type.getDataType(), is(INT32));
+        YangRangeRestriction ranRes = (YangRangeRestriction) type
+                .getDataTypeExtendedInfo();
+
+        ListIterator<YangRangeInterval> rlIt = ranRes
+                .getAscendingRangeIntervals().listIterator();
+        YangRangeInterval range = rlIt.next();
+
+        assertThat(((YangInt32) range.getStartValue()).getValue(),
+                   is(-2147483648));
+        assertThat(((YangInt32) range.getEndValue()).getValue(),
+                   is(2147483647));
     }
 
     /**
@@ -172,8 +193,10 @@
     @Test
     public void processRangeWithInvalidIntegerPattern() throws IOException, ParserException {
         thrown.expect(ParserException.class);
-        thrown.expectMessage("YANG file error : Input value \"a\" is not a valid int32.");
-        YangNode node = manager.getDataModel("src/test/resources/RangeWithInvalidIntegerPattern.yang");
+        thrown.expectMessage("YANG file error : Input value \"a\" is not " +
+                                     "a valid int32.");
+        manager.getDataModel("src/test/resources/RangeWithInval" +
+                                     "idIntegerPattern.yang");
     }
 
     /**
@@ -182,31 +205,34 @@
     @Test
     public void processRangeSubStatements() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/RangeSubStatements.yang");
+        YangNode node = manager.getDataModel("src/test/resources/" +
+                                                     "RangeSubStatements.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
-        YangLeaf leafInfo = leafIterator.next();
+        ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+        YangLeaf leaf = it.next();
 
-        assertThat(leafInfo.getName(), is("invalid-interval"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("int32"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
-        YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafInfo
-                .getDataType().getDataTypeExtendedInfo();
+        YangType<?> type = leaf.getDataType();
 
-        assertThat(rangeRestriction.getDescription(), is("\"range description\""));
-        assertThat(rangeRestriction.getReference(), is("\"range reference\""));
+        assertThat(leaf.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("int32"));
+        assertThat(type.getDataType(), is(INT32));
+        YangRangeRestriction ranRes = (YangRangeRestriction) type
+                .getDataTypeExtendedInfo();
 
-        ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
-                .listIterator();
-        YangRangeInterval rangeInterval = rangeListIterator.next();
-        assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(1));
-        assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(4));
-        assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(4));
+        assertThat(ranRes.getDescription(), is("\"range description\""));
+        assertThat(ranRes.getReference(), is("\"range reference\""));
+
+        ListIterator<YangRangeInterval> rlIt = ranRes
+                .getAscendingRangeIntervals().listIterator();
+        YangRangeInterval range = rlIt.next();
+        assertThat(((YangInt32) range.getStartValue()).getValue(), is(1));
+        assertThat(((YangInt32) range.getEndValue()).getValue(), is(4));
+        assertThat(((YangInt32) range.getEndValue()).getValue(), is(4));
     }
 
     /**
@@ -215,26 +241,84 @@
     @Test
     public void processRangeStatementWithSpace() throws IOException, ParserException {
 
-        YangNode node = manager.getDataModel("src/test/resources/RangeStatementWithSpace.yang");
+        YangNode node = manager.getDataModel("src/test/resources/RangeSta" +
+                                                     "tementWithSpace.yang");
 
         assertThat((node instanceof YangModule), is(true));
         assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
         YangModule yangNode = (YangModule) node;
         assertThat(yangNode.getName(), is("Test"));
 
-        ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
-        YangLeaf leafInfo = leafIterator.next();
+        ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+        YangLeaf leaf = it.next();
 
-        assertThat(leafInfo.getName(), is("invalid-interval"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("int32"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
-        YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafInfo
-                .getDataType().getDataTypeExtendedInfo();
+        YangType<?> type = leaf.getDataType();
 
-        ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
-                .listIterator();
-        YangRangeInterval rangeInterval = rangeListIterator.next();
-        assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(1));
-        assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(4));
+        assertThat(leaf.getName(), is("invalid-interval"));
+        assertThat(type.getDataTypeName(), is("int32"));
+        assertThat(type.getDataType(), is(INT32));
+        YangRangeRestriction ranRes = (YangRangeRestriction) type
+                .getDataTypeExtendedInfo();
+
+        ListIterator<YangRangeInterval> rlIt = ranRes
+                .getAscendingRangeIntervals().listIterator();
+        YangRangeInterval range = rlIt.next();
+        assertThat(((YangInt32) range.getStartValue()).getValue(), is(1));
+        assertThat(((YangInt32) range.getEndValue()).getValue(), is(4));
     }
+
+    /**
+     * Checks range statement in typedef with description and reference.
+     *
+     * @throws IOException     when IO operation fails
+     * @throws ParserException when parsing fails
+     */
+    @Test
+    public void processRangeStatementInTypeDef() throws IOException, ParserException {
+        YangNode node = manager.getDataModel("src/test/resources/Range" +
+                                                     "WithTypedef.yang");
+        assertThat((node instanceof YangModule), is(true));
+        assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
+        YangModule yangNode = (YangModule) node;
+        assertThat(yangNode.getName(), is("Test"));
+
+        ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+        YangLeaf leaf = it.next();
+
+        YangType<?> type = leaf.getDataType();
+
+        assertThat(leaf.getName(), is("invalid-interval"));
+        assertThat(type.getDataType(), is(DERIVED));
+        YangDerivedInfo info = (YangDerivedInfo) type
+                .getDataTypeExtendedInfo();
+
+        YangRangeRestriction ranRes1 = info.getRangeRes();
+
+        assertThat(ranRes1.getDescription(), is("\"range description\""));
+        assertThat(ranRes1.getReference(), is("\"range reference\""));
+
+        ListIterator<YangRangeInterval> rlIt1 = ranRes1
+                .getAscendingRangeIntervals().listIterator();
+        YangRangeInterval range1 = rlIt1.next();
+        assertThat(((YangUint8) range1.getStartValue()).getValue(),
+                   is((short) 2));
+        assertThat(((YangUint8) range1.getEndValue()).getValue(),
+                   is((short) 100));
+
+        YangTypeDef typeDef = (YangTypeDef) yangNode.getChild();
+        YangRangeRestriction ranRes = (YangRangeRestriction) typeDef
+                .getTypeDefBaseType().getDataTypeExtendedInfo();
+        assertThat(ranRes.getDescription(),
+                   is("\"typedef description\""));
+        assertThat(ranRes.getReference(), is("\"typedef reference\""));
+
+        ListIterator<YangRangeInterval> rlIt2 = ranRes
+                .getAscendingRangeIntervals().listIterator();
+        YangRangeInterval range2 = rlIt2.next();
+        assertThat(((YangUint8) range2.getStartValue()).getValue(),
+                   is((short) 1));
+        assertThat(((YangUint8) range2.getEndValue()).getValue(),
+                   is((short) (100)));
+    }
+
 }
diff --git a/compiler/base/parser/src/test/resources/LengthStatementInsideTypeDef.yang b/compiler/base/parser/src/test/resources/LengthStatementInsideTypeDef.yang
index c1195dc..ad59080 100644
--- a/compiler/base/parser/src/test/resources/LengthStatementInsideTypeDef.yang
+++ b/compiler/base/parser/src/test/resources/LengthStatementInsideTypeDef.yang
@@ -4,12 +4,18 @@
     prefix Ant;
     typedef invalid-interval {
         type string {
-            length "1..100";
+            length "1..100" {
+                description "length-description typedef";
+                reference "reference typedef";
+            }
          }
     }
     leaf xyz {
        type invalid-interval {
-           length "2..100";
+           length "2..100"{
+                description "length-description type";
+                reference "reference type";
+            }
        }
     }
 }
diff --git a/compiler/base/parser/src/test/resources/RangeWithTypedef.yang b/compiler/base/parser/src/test/resources/RangeWithTypedef.yang
new file mode 100644
index 0000000..d885d8c
--- /dev/null
+++ b/compiler/base/parser/src/test/resources/RangeWithTypedef.yang
@@ -0,0 +1,22 @@
+module Test {
+    yang-version 1;
+    namespace http://huawei.com;
+    prefix Ant;
+
+    typedef value {
+        type uint8 {
+            range "1..100" {
+                description "typedef description";
+                reference "typedef reference";
+            }
+        }
+    }
+    leaf invalid-interval {
+        type value {
+            range "2..100" {
+                description "range description";
+                reference "range reference";
+            }
+         }
+    }
+}
diff --git a/compiler/base/parser/src/test/resources/ValidBinaryLengthStatement.yang b/compiler/base/parser/src/test/resources/ValidBinaryLengthStatement.yang
index 7182eb3..349181a 100644
--- a/compiler/base/parser/src/test/resources/ValidBinaryLengthStatement.yang
+++ b/compiler/base/parser/src/test/resources/ValidBinaryLengthStatement.yang
@@ -4,7 +4,10 @@
     prefix Ant;
     leaf message {
         type binary {
-            length "4";
+            length "4" {
+                description "binary description";
+                reference "binary reference";
+            }
         }
     }
 }