YANG: Restriction resolution implementation

Change-Id: I69503e8229def07b289a0c8c762bfe0ae5530232

+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.yangutils.datamodel;
+
+/**
+ * Abstraction of location information, this is used during resolution is
+ * carried out and line/character position in line is required to point
+ * out the error location in YANG file.
+ */
+public interface LocationInfo {
+
+    /**
+     * Returns the line number YANG construct in file.
+     *
+     * @return the line number YANG construct in file
+     */
+    int getLineNumber();
+
+    /**
+     * Returns the character position in line.
+     *
+     * @return the character position in line
+     */
+    int getCharPosition();
+
+    /**
+     * Sets line number of YANG construct.
+     *
+     * @param lineNumber the line number of YANG construct in file
+     */
+    void setLineNumber(int lineNumber);
+
+    /**
+     * Sets character position of YANG construct.
+     *
+     * @param charPositionInLine character position of YANG construct in file
+     */
+    void setCharPosition(int charPositionInLine);
+}

@@ -228,7 +228,7 @@ public enum YangDataTypes {
     public static YangDataTypes getType(String name) {
     public static YangDataTypes getType(String name) {
         name = name.replace("\"", "");
         name = name.replace("\"", "");
         for (YangDataTypes yangDataType : values()) {
         for (YangDataTypes yangDataType : values()) {
-            if (yangDataType.name().equalsIgnoreCase(name)) {
+            if (yangDataType.name().toLowerCase().equals(name)) {
                 return yangDataType;
                 return yangDataType;
             }
             }
         }
         }

@@ -16,12 +16,30 @@
 
 
 package org.onosproject.yangutils.datamodel;
 package org.onosproject.yangutils.datamodel;
 
 
+import org.onosproject.yangutils.datamodel.exceptions.DataModelException;
+import com.google.common.base.Strings;
+
+import static org.onosproject.yangutils.datamodel.ResolvableStatus.INTRA_FILE_RESOLVED;
+import static org.onosproject.yangutils.datamodel.ResolvableStatus.RESOLVED;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.BITS;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.BOOLEAN;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.DERIVED;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.EMPTY;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.ENUMERATION;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.IDENTITYREF;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.LEAFREF;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.STRING;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.UNION;
+import static org.onosproject.yangutils.utils.RestrictionResolver.isOfRangeRestrictedType;
+import static org.onosproject.yangutils.utils.RestrictionResolver.processLengthRestriction;
+import static org.onosproject.yangutils.utils.RestrictionResolver.processRangeRestriction;
+
 /**
 /**
  * Represents the derived information.
  * Represents the derived information.
  *
  *
  * @param <T> extended information.
  * @param <T> extended information.
  */
  */
-public class YangDerivedInfo<T> {
+public class YangDerivedInfo<T> implements LocationInfo {
 
 
     /**
     /**
      * YANG typedef reference.
      * YANG typedef reference.
@@ -36,11 +54,38 @@ public class YangDerivedInfo<T> {
     private T resolvedExtendedInfo;
     private T resolvedExtendedInfo;
 
 
     /**
     /**
-     * Additional information about data type, example restriction info, named
-     * values, etc. The extra information is based on the data type. Based on
-     * the data type, the extended info can vary.
+     * Line number of pattern restriction in YANG file.
+     */
+    private int lineNumber;
+
+    /**
+     * Position of pattern restriction in line.
+     */
+    private int charPositionInLine;
+
+    /**
+     * Effective built-in type, requried in case type of typedef is again a
+     * derived type. This information is to be added during linking.
+     */
+    private YangDataTypes effectiveBuiltInType;
+
+    /**
+     * Length restriction string to temporary store the length restriction when the type
+     * is derived.
      */
      */
-    private T extendedInfo;
+    private String lengthRestrictionString;
+
+    /**
+     * Range restriction string to temporary store the range restriction when the type
+     * is derived.
+     */
+    private String rangeRestrictionString;
+
+    /**
+     * Pattern restriction string to  temporary store the pattern restriction when the type
+     * is derived.
+     */
+    private YangPatternRestriction patternRestriction;
 
 
     /**
     /**
      * Returns the referred typedef reference.
      * Returns the referred typedef reference.
@@ -78,21 +123,503 @@ public class YangDerivedInfo<T> {
         this.resolvedExtendedInfo = resolvedExtendedInfo;
         this.resolvedExtendedInfo = resolvedExtendedInfo;
     }
     }
 
 
+    @Override
+    public int getLineNumber() {
+        return lineNumber;
+    }
+
+    @Override
+    public int getCharPosition() {
+        return charPositionInLine;
+    }
+
+    @Override
+    public void setLineNumber(int lineNumber) {
+        this.lineNumber = lineNumber;
+    }
+
+    @Override
+    public void setCharPosition(int charPositionInLine) {
+        this.charPositionInLine = charPositionInLine;
+    }
+
+    /**
+     * Returns the length restriction string.
+     *
+     * @return the length restriction string
+     */
+    public String getLengthRestrictionString() {
+        return lengthRestrictionString;
+    }
+
+    /**
+     * Sets the length restriction string.
+     *
+     * @param lengthRestrictionString the length restriction string
+     */
+    public void setLengthRestrictionString(String lengthRestrictionString) {
+        this.lengthRestrictionString = lengthRestrictionString;
+    }
+
+    /**
+     * Returns the range restriction string.
+     *
+     * @return the range restriction string
+     */
+    public String getRangeRestrictionString() {
+        return rangeRestrictionString;
+    }
+
+    /**
+     * Sets the range restriction string.
+     *
+     * @param rangeRestrictionString the range restriction string
+     */
+    public void setRangeRestrictionString(String rangeRestrictionString) {
+        this.rangeRestrictionString = rangeRestrictionString;
+    }
+
+    /**
+     * Returns the pattern restriction.
+     *
+     * @return the pattern restriction
+     */
+    public YangPatternRestriction getPatternRestriction() {
+        return patternRestriction;
+    }
+
+    /**
+     * Sets the pattern restriction.
+     *
+     * @param patternRestriction the pattern restriction
+     */
+    public void setPatternRestriction(YangPatternRestriction patternRestriction) {
+        this.patternRestriction = patternRestriction;
+    }
+
+    /**
+     * Returns effective built-in type.
+     *
+     * @return effective built-in type
+     */
+    public YangDataTypes getEffectiveBuiltInType() {
+        return effectiveBuiltInType;
+    }
+
+    /**
+     * Sets effective built-in type.
+     *
+     * @param effectiveBuiltInType effective built-in type
+     */
+    public void setEffectiveBuiltInType(YangDataTypes effectiveBuiltInType) {
+        this.effectiveBuiltInType = effectiveBuiltInType;
+    }
+
+    /**
+     * Resolves the type derived info, by obtaining the effective built-in type
+     * and resolving the restrictions.
+     *
+     * @return resolution status
+     * @throws DataModelException a violation in data mode rule
+     */
+    public ResolvableStatus resolve() throws DataModelException {
+
+        YangType<?> baseType = getReferredTypeDef().getTypeDefBaseType();
+
+        /*
+         * Checks the data type of the referred typedef, if it's derived,
+         * obtain effective built-in type and restrictions from it's derived
+         * info, otherwise take from the base type of type itself.
+         */
+        if (baseType.getDataType() == DERIVED) {
+            /*
+             * Check whether the referred typedef is resolved.
+             */
+            if (baseType.getResolvableStatus() != INTRA_FILE_RESOLVED && baseType.getResolvableStatus() != RESOLVED) {
+                throw new DataModelException("Linker Error: Referred typedef is not resolved.");
+            }
+
+            /*
+             * Check if the referred typedef is intra file resolved, if yes sets
+             * current status also to intra file resolved .
+             */
+            if (getReferredTypeDef().getTypeDefBaseType().getResolvableStatus() == INTRA_FILE_RESOLVED) {
+                return INTRA_FILE_RESOLVED;
+            }
+            setEffectiveBuiltInType(((YangDerivedInfo<?>) baseType.getDataTypeExtendedInfo())
+                    .getEffectiveBuiltInType());
+            YangDerivedInfo refDerivedInfo = ((YangDerivedInfo<?>) baseType.getDataTypeExtendedInfo());
+            /*
+             * Check whether the effective built-in type can have range
+             * restrictions, if yes call resolution of range.
+             */
+            if (isOfRangeRestrictedType(getEffectiveBuiltInType())) {
+                if (refDerivedInfo.getResolvedExtendedInfo() == null) {
+                    resolveRangeRestriction(null);
+                    /*
+                     * Return the resolution status as resolved, if it's not
+                     * resolve range/string restriction will throw exception
+                     * in previous function.
+                     */
+                    return RESOLVED;
+                } else {
+                    if (!(refDerivedInfo.getResolvedExtendedInfo() instanceof YangRangeRestriction)) {
+                        throw new DataModelException("Linker error: Referred typedef restriction info is of invalid " +
+                                "type.");
+                    }
+                    resolveRangeRestriction((YangRangeRestriction) refDerivedInfo.getResolvedExtendedInfo());
+                    /*
+                     * Return the resolution status as resolved, if it's not
+                     * resolve range/string restriction will throw exception
+                     * in previous function.
+                     */
+                    return RESOLVED;
+                }
+                /*
+                 * If the effective built-in type is of type string calls
+                 * for string resolution.
+                 */
+            } else if (getEffectiveBuiltInType() == STRING) {
+                if (refDerivedInfo.getResolvedExtendedInfo() == null) {
+                    resolveStringRestriction(null);
+                    /*
+                     * Return the resolution status as resolved, if it's not
+                     * resolve range/string restriction will throw exception
+                     * in previous function.
+                     */
+                    return RESOLVED;
+                } else {
+                    if (!(refDerivedInfo.getResolvedExtendedInfo() instanceof YangStringRestriction)) {
+                        throw new DataModelException("Linker error: Referred typedef restriction info is of invalid " +
+                                "type.");
+                    }
+                    resolveStringRestriction((YangStringRestriction) refDerivedInfo.getResolvedExtendedInfo());
+                    /*
+                     * Return the resolution status as resolved, if it's not
+                     * resolve range/string restriction will throw exception
+                     * in previous function.
+                     */
+                    return RESOLVED;
+                }
+            }
+        } else {
+            setEffectiveBuiltInType((baseType.getDataType()));
+            /*
+             * Check whether the effective built-in type can have range
+             * restrictions, if yes call resolution of range.
+             */
+            if (isOfRangeRestrictedType(getEffectiveBuiltInType())) {
+                if (baseType.getDataTypeExtendedInfo() == null) {
+                    resolveRangeRestriction(null);
+                    /*
+                     * Return the resolution status as resolved, if it's not
+                     * resolve range/string restriction will throw exception
+                     * in previous function.
+                     */
+                    return RESOLVED;
+                } else {
+                    if (!(baseType.getDataTypeExtendedInfo() instanceof YangRangeRestriction)) {
+                        throw new DataModelException("Linker error: Referred typedef restriction info is of invalid " +
+                                "type.");
+                    }
+                    resolveRangeRestriction((YangRangeRestriction) baseType.getDataTypeExtendedInfo());
+                    /*
+                     * Return the resolution status as resolved, if it's not
+                     * resolve range/string restriction will throw exception
+                     * in previous function.
+                     */
+                    return RESOLVED;
+                }
+                /*
+                 * If the effective built-in type is of type string calls
+                 * for string resolution.
+                 */
+            } else if (getEffectiveBuiltInType() == STRING) {
+                if (baseType.getDataTypeExtendedInfo() == null) {
+                    resolveStringRestriction(null);
+                    /*
+                     * Return the resolution status as resolved, if it's not
+                     * resolve range/string restriction will throw exception
+                     * in previous function.
+                     */
+                    return RESOLVED;
+                } else {
+                    if (!(baseType.getDataTypeExtendedInfo() instanceof YangStringRestriction)) {
+                        throw new DataModelException("Linker error: Referred typedef restriction info is of invalid " +
+                                "type.");
+                    }
+                    resolveStringRestriction((YangStringRestriction) baseType.getDataTypeExtendedInfo());
+                    /*
+                     * Return the resolution status as resolved, if it's not
+                     * resolve range/string restriction will throw exception
+                     * in previous function.
+                     */
+                    return RESOLVED;
+                }
+            }
+        }
+
+        /*
+         * Check if the data type is the one which can't be restricted, in
+         * this case check whether no self restrictions should be present.
+         */
+        if (isOfValidNonRestrictedType(getEffectiveBuiltInType())) {
+            if (Strings.isNullOrEmpty(getLengthRestrictionString())
+                    && Strings.isNullOrEmpty(getRangeRestrictionString())
+                    && getPatternRestriction() == null) {
+                return RESOLVED;
+            } else {
+                throw new DataModelException("YANG file error: Restrictions can't be applied to a given type");
+            }
+        }
+
+        // Throw exception for unsupported types
+        throw new DataModelException("Linker error: Unable to process the derived type.");
+    }
+
+    /**
+     * Resolves the string restrictions.
+     *
+     * @param refStringRestriction referred string restriction of typedef
+     * @throws DataModelException a violation in data model rule
+     */
+    private void resolveStringRestriction(YangStringRestriction refStringRestriction) throws DataModelException {
+        YangStringRestriction curStringRestriction = null;
+        YangRangeRestriction refRangeRestriction = null;
+        YangPatternRestriction refPatternRestriction = null;
+
+        /*
+         * Check that range restriction should be null when built-in type is
+         * string.
+         */
+        if (!(Strings.isNullOrEmpty(getRangeRestrictionString()))) {
+            DataModelException dataModelException = new DataModelException("YANG file error: Range restriction " +
+                    "should't be present for string data type.");
+            dataModelException.setLine(lineNumber);
+            dataModelException.setCharPosition(charPositionInLine);
+            throw dataModelException;
+        }
+
+        /*
+         * If referred restriction and self restriction both are null, no
+         * resolution is required.
+         */
+        if (refStringRestriction == null && Strings.isNullOrEmpty(getLengthRestrictionString())
+                && getPatternRestriction() == null) {
+            return;
+        }
+
+        /*
+         * If referred string restriction is not null, take value of length
+         * and pattern restriction and assign.
+         */
+        if (refStringRestriction != null) {
+            refRangeRestriction = refStringRestriction.getLengthRestriction();
+            refPatternRestriction = refStringRestriction.getPatternRestriction();
+        }
+
+        YangRangeRestriction lengthRestriction = resolveLengthRestriction(refRangeRestriction);
+        YangPatternRestriction patternRestriction = resolvePatternRestriction(refPatternRestriction);
+
+        /*
+         * Check if either of length or pattern restriction is present, if yes
+         * create string restriction and assign value.
+         */
+        if (lengthRestriction != null || patternRestriction != null) {
+            curStringRestriction = new YangStringRestriction();
+            curStringRestriction.setLengthRestriction(lengthRestriction);
+            curStringRestriction.setPatternRestriction(patternRestriction);
+        }
+        setResolvedExtendedInfo((T) curStringRestriction);
+    }
+
+    /**
+     * Resolves pattern restriction.
+     *
+     * @param refPatternRestriction referred pattern restriction of typedef
+     * @return resolved pattern restriction
+     */
+    private YangPatternRestriction resolvePatternRestriction(YangPatternRestriction refPatternRestriction) {
+        /*
+         * If referred restriction and self restriction both are null, no
+         * resolution is required.
+         */
+        if (refPatternRestriction == null && getPatternRestriction() == null) {
+            return null;
+        }
+
+        /*
+         * If self restriction is null, and referred restriction is present
+         * shallow copy the referred to self.
+         */
+        if (getPatternRestriction() == null) {
+            return refPatternRestriction;
+        }
+
+        /*
+         * If referred restriction is null, and self restriction is present
+         * carry out self resolution.
+         */
+        if (refPatternRestriction == null) {
+            return getPatternRestriction();
+        }
+
+        /*
+         * Get patterns of referred type and add it to current pattern
+         * restrictions.
+         */
+        for (String pattern : refPatternRestriction.getPatternList()) {
+            getPatternRestriction().addPattern(pattern);
+        }
+        return getPatternRestriction();
+    }
+
     /**
     /**
-     * Returns extended information.
+     * Resolves the length restrictions.
      *
      *
-     * @return extended information
+     * @param refLengthRestriction referred length restriction of typedef
+     * @return resolved length restriction
+     * @throws DataModelException a violation in data model rule
+     */
+    private YangRangeRestriction resolveLengthRestriction(YangRangeRestriction refLengthRestriction) throws
+            DataModelException {
+
+        /*
+         * If referred restriction and self restriction both are null, no
+         * resolution is required.
+         */
+        if (refLengthRestriction == null && Strings.isNullOrEmpty(getLengthRestrictionString())) {
+            return null;
+        }
+
+        /*
+         * If self restriction is null, and referred restriction is present
+         * shallow copy the referred to self.
          */
          */
-    public T getExtendedInfo() {
-        return extendedInfo;
+        if (Strings.isNullOrEmpty(getLengthRestrictionString())) {
+            return refLengthRestriction;
+        }
+
+        /*
+         * If referred restriction is null, and self restriction is present
+         * carry out self resolution.
+         */
+        if (refLengthRestriction == null) {
+            YangRangeRestriction curLengthRestriction = processLengthRestriction(null, lineNumber,
+                    charPositionInLine, false, getLengthRestrictionString());
+            return curLengthRestriction;
+        }
+
+        /*
+         * Carry out self resolution based with obtained effective built-in
+         * type and MIN/MAX values as per the referred typedef's values.
+         */
+        YangRangeRestriction curLengthRestriction = processLengthRestriction(refLengthRestriction, lineNumber,
+                charPositionInLine, true, getLengthRestrictionString());
+
+        // Resolve the range with referred typedef's restriction.
+        resolveLengthAndRangeRestriction(refLengthRestriction, curLengthRestriction);
+        return curLengthRestriction;
+    }
+
+    /**
+     * Resolves the length/range self and referred restriction, to check whether
+     * the all the range interval in self restriction is stricter than the
+     * referred typedef's restriction.
+     *
+     * @param refRestriction referred restriction
+     * @param curRestriction self restriction
+     */
+    private void resolveLengthAndRangeRestriction(YangRangeRestriction refRestriction,
+                                                  YangRangeRestriction curRestriction) throws DataModelException {
+        for (Object curInterval : curRestriction.getAscendingRangeIntervals()) {
+            if (!(curInterval instanceof YangRangeInterval)) {
+                throw new DataModelException("Linker error: Current range intervals not processed correctly.");
+            }
+            try {
+                refRestriction.isValidInterval((YangRangeInterval) curInterval);
+            } catch (DataModelException e) {
+                DataModelException dataModelException = new DataModelException(e);
+                dataModelException.setLine(lineNumber);
+                dataModelException.setCharPosition(charPositionInLine);
+                throw dataModelException;
+            }
+        }
+    }
+
+    /**
+     * Resolves the range restrictions.
+     *
+     * @param refRangeRestriction referred range restriction of typedef
+     * @throws DataModelException a violation in data model rule
+     */
+    private void resolveRangeRestriction(YangRangeRestriction refRangeRestriction) throws DataModelException {
+
+        /*
+         * Check that string restriction should be null when built-in type is
+         * of range type.
+         */
+        if (!(Strings.isNullOrEmpty(getLengthRestrictionString())) || getPatternRestriction() != null) {
+            DataModelException dataModelException = new DataModelException("YANG file error: Length/Pattern " +
+                    "restriction should't be present for int/uint/decimal data type.");
+            dataModelException.setLine(lineNumber);
+            dataModelException.setCharPosition(charPositionInLine);
+            throw dataModelException;
+        }
+
+        /*
+         * If referred restriction and self restriction both are null, no
+         * resolution is required.
+         */
+        if (refRangeRestriction == null && Strings.isNullOrEmpty(getRangeRestrictionString())) {
+            return;
+        }
+
+        /*
+         * If self restriction is null, and referred restriction is present
+         * shallow copy the referred to self.
+         */
+        if (Strings.isNullOrEmpty(getRangeRestrictionString())) {
+            setResolvedExtendedInfo((T) refRangeRestriction);
+            return;
+        }
+
+        /*
+         * If referred restriction is null, and self restriction is present
+         * carry out self resolution.
+         */
+        if (refRangeRestriction == null) {
+            YangRangeRestriction curRangeRestriction = processRangeRestriction(null, lineNumber,
+                    charPositionInLine, false, getRangeRestrictionString(), getEffectiveBuiltInType());
+            setResolvedExtendedInfo((T) curRangeRestriction);
+            return;
+        }
+
+        /*
+         * Carry out self resolution based with obtained effective built-in
+         * type and MIN/MAX values as per the referred typedef's values.
+         */
+        YangRangeRestriction curRangeRestriction = processRangeRestriction(refRangeRestriction, lineNumber,
+                charPositionInLine, true, getRangeRestrictionString(), getEffectiveBuiltInType());
+
+        // Resolve the range with referred typedef's restriction.
+        resolveLengthAndRangeRestriction(refRangeRestriction, curRangeRestriction);
+        setResolvedExtendedInfo((T) curRangeRestriction);
     }
     }
 
 
     /**
     /**
-     * Sets extended information.
+     * Returns whether the data type is of non restricted type.
      *
      *
-     * @param extendedInfo extended information
+     * @param dataType data type to be checked
+     * @return true, if data type can't be restricted, false otherwise
      */
      */
-    public void setExtendedInfo(T extendedInfo) {
-        this.extendedInfo = extendedInfo;
+    private boolean isOfValidNonRestrictedType(YangDataTypes dataType) {
+        return (dataType == BOOLEAN
+                || dataType == ENUMERATION
+                || dataType == BITS
+                || dataType == EMPTY
+                || dataType == UNION
+                || dataType == IDENTITYREF
+                || dataType == LEAFREF);
     }
     }
 }
 }

@@ -46,6 +46,7 @@ import java.util.List;
  *   | reference     | 7.19.4  | 0..1        |
  *   | reference     | 7.19.4  | 0..1        |
  *   +---------------+---------+-------------+
  *   +---------------+---------+-------------+
  */
  */
+
 /**
 /**
  * Represents pattern restriction information. The regular expression restriction on string
  * Represents pattern restriction information. The regular expression restriction on string
  * data type.
  * data type.
@@ -58,11 +59,6 @@ public class YangPatternRestriction {
     private List<String> patternList;
     private List<String> patternList;
 
 
     /**
     /**
-     * Effective pattern restriction that needs inherited from base type.
-     */
-    private List<String> basePattern;
-
-    /**
      * Creates a YANG pattern restriction object.
      * Creates a YANG pattern restriction object.
      */
      */
     public YangPatternRestriction() {
     public YangPatternRestriction() {
@@ -95,22 +91,4 @@ public class YangPatternRestriction {
     public void addPattern(String newPattern) {
     public void addPattern(String newPattern) {
         getPatternList().add(newPattern);
         getPatternList().add(newPattern);
     }
     }
-
-    /**
-     * Returns the pattern restriction defined in base type.
-     *
-     * @return pattern restriction defined in base type.
-     */
-    public List<String> getBasePattern() {
-        return basePattern;
-    }
-
-    /**
-     * Sets the pattern restriction defined in base type.
-     *
-     * @param basePattern pattern restriction defined in base type.
-     */
-    public void setBasePattern(List<String> basePattern) {
-        this.basePattern = basePattern;
-    }
 }
 }

@@ -18,7 +18,6 @@ package org.onosproject.yangutils.datamodel;
 
 
 import java.util.LinkedList;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.List;
-
 import org.onosproject.yangutils.datamodel.exceptions.DataModelException;
 import org.onosproject.yangutils.datamodel.exceptions.DataModelException;
 import org.onosproject.yangutils.utils.builtindatatype.YangBuiltInDataTypeInfo;
 import org.onosproject.yangutils.utils.builtindatatype.YangBuiltInDataTypeInfo;
 
 
@@ -111,8 +110,8 @@ public class YangRangeRestriction<T extends YangBuiltInDataTypeInfo<T>>
     /**
     /**
      * Returns the minimum valid value as per the restriction.
      * Returns the minimum valid value as per the restriction.
      *
      *
-     * @throws DataModelException data model exception for minimum restriction
      * @return minimum restricted value
      * @return minimum restricted value
+     * @throws DataModelException data model exception for minimum restriction
      */
      */
     public T getMinRestrictedvalue() throws DataModelException {
     public T getMinRestrictedvalue() throws DataModelException {
         if (getAscendingRangeIntervals() == null) {
         if (getAscendingRangeIntervals() == null) {
@@ -127,8 +126,8 @@ public class YangRangeRestriction<T extends YangBuiltInDataTypeInfo<T>>
     /**
     /**
      * Returns the maximum valid value as per the restriction.
      * Returns the maximum valid value as per the restriction.
      *
      *
-     * @throws DataModelException data model exception for maximum restriction
      * @return minimum maximum value
      * @return minimum maximum value
+     * @throws DataModelException data model exception for maximum restriction
      */
      */
     public T getMaxRestrictedvalue() throws DataModelException {
     public T getMaxRestrictedvalue() throws DataModelException {
         if (getAscendingRangeIntervals() == null) {
         if (getAscendingRangeIntervals() == null) {
@@ -175,7 +174,7 @@ public class YangRangeRestriction<T extends YangBuiltInDataTypeInfo<T>>
     }
     }
 
 
     /**
     /**
-     * Check if the given value is correct as per the restriction.
+     * Validates if the given value is correct as per the restriction.
      *
      *
      * @param valueInString value
      * @param valueInString value
      * @return true, if the value is confirming to restriction, false otherwise
      * @return true, if the value is confirming to restriction, false otherwise
@@ -206,6 +205,32 @@ public class YangRangeRestriction<T extends YangBuiltInDataTypeInfo<T>>
     }
     }
 
 
     /**
     /**
+     * Validates if the given interval is correct as per the restriction.
+     *
+     * @param rangeInterval range interval
+     * @return true, if the interval is confirming to restriction, false otherwise
+     * @throws DataModelException data model error
+     */
+    public boolean isValidInterval(YangRangeInterval rangeInterval) throws DataModelException {
+
+        if (getAscendingRangeIntervals() == null
+                || getAscendingRangeIntervals().isEmpty()) {
+            // Throw exception, At least one default range needs to be set in constructor or in linker.
+            throw new DataModelException("Range interval missing in range restriction.");
+        }
+
+        for (YangRangeInterval<T> interval : getAscendingRangeIntervals()) {
+            int rangeStartCompareRes = interval.getStartValue().compareTo((T) rangeInterval.getStartValue());
+            int rangeEndCompareRes = interval.getEndValue().compareTo((T) rangeInterval.getEndValue());
+
+            if (rangeStartCompareRes <= 0 && rangeEndCompareRes >= 0) {
+                return true;
+            }
+        }
+        throw new DataModelException("Range interval doesn't fall within the referred restriction ranges");
+    }
+
+    /**
      * Returns the textual reference of the length restriction.
      * Returns the textual reference of the length restriction.
      *
      *
      * @return textual reference of the length restriction
      * @return textual reference of the length restriction

@@ -17,7 +17,6 @@
 package org.onosproject.yangutils.datamodel;
 package org.onosproject.yangutils.datamodel;
 
 
 import java.util.Stack;
 import java.util.Stack;
-
 import org.onosproject.yangutils.datamodel.exceptions.DataModelException;
 import org.onosproject.yangutils.datamodel.exceptions.DataModelException;
 
 
 import static org.onosproject.yangutils.datamodel.ResolvableStatus.INTRA_FILE_RESOLVED;
 import static org.onosproject.yangutils.datamodel.ResolvableStatus.INTRA_FILE_RESOLVED;
@@ -30,7 +29,7 @@ import static org.onosproject.yangutils.datamodel.ResolvableStatus.UNRESOLVED;
  *
  *
  * @param <T> type of resolution entity uses / type
  * @param <T> type of resolution entity uses / type
  */
  */
-public class YangResolutionInfo<T> {
+public class YangResolutionInfo<T> implements LocationInfo {
 
 
     /**
     /**
      * Information about the entity that needs to be resolved.
      * Information about the entity that needs to be resolved.
@@ -193,7 +192,6 @@ public class YangResolutionInfo<T> {
     private void resolveTopOfStack()
     private void resolveTopOfStack()
             throws DataModelException {
             throws DataModelException {
         ((Resolvable) getCurrentEntityToResolveFromStack()).resolve();
         ((Resolvable) getCurrentEntityToResolveFromStack()).resolve();
-
         if (((Resolvable) getCurrentEntityToResolveFromStack()).getResolvableStatus()
         if (((Resolvable) getCurrentEntityToResolveFromStack()).getResolvableStatus()
                 != INTRA_FILE_RESOLVED) {
                 != INTRA_FILE_RESOLVED) {
             // Sets the resolution status in inside the type/uses.
             // Sets the resolution status in inside the type/uses.
@@ -453,42 +451,6 @@ public class YangResolutionInfo<T> {
     }
     }
 
 
     /**
     /**
-     * Returns error position.
-     *
-     * @return error position
-     */
-    public int getCharPosition() {
-        return charPosition;
-    }
-
-    /**
-     * Sets error position.
-     *
-     * @param charPosition position of error
-     */
-    public void setCharPosition(int charPosition) {
-        this.charPosition = charPosition;
-    }
-
-    /**
-     * Returns error character position in line.
-     *
-     * @return error character position in line
-     */
-    public int getLineNumber() {
-        return lineNumber;
-    }
-
-    /**
-     * Sets error character position in line.
-     *
-     * @param lineNumber error character position in line
-     */
-    public void setLineNumber(int lineNumber) {
-        this.lineNumber = lineNumber;
-    }
-
-    /**
      * Returns stack of YANG type with partially resolved YANG construct
      * Returns stack of YANG type with partially resolved YANG construct
      * hierarchy.
      * hierarchy.
      *
      *
@@ -544,4 +506,24 @@ public class YangResolutionInfo<T> {
     public void setEntityToResolveInfo(YangEntityToResolveInfo<T> entityToResolveInfo) {
     public void setEntityToResolveInfo(YangEntityToResolveInfo<T> entityToResolveInfo) {
         this.entityToResolveInfo = entityToResolveInfo;
         this.entityToResolveInfo = entityToResolveInfo;
     }
     }
+
+    @Override
+    public int getLineNumber() {
+        return lineNumber;
+    }
+
+    @Override
+    public int getCharPosition() {
+        return charPosition;
+    }
+
+    @Override
+    public void setLineNumber(int lineNumber) {
+        this.lineNumber = lineNumber;
+    }
+
+    @Override
+    public void setCharPosition(int charPositionInLine) {
+        this.charPosition = charPositionInLine;
+    }
 }
 }

@@ -24,6 +24,7 @@ import org.onosproject.yangutils.utils.builtindatatype.YangUint64;
  * A string can be restricted with the "length" and "pattern" statements.
  * A string can be restricted with the "length" and "pattern" statements.
  *
  *
  */
  */
+
 /**
 /**
  * Represents the restriction for string data type.
  * Represents the restriction for string data type.
  */
  */
@@ -113,7 +114,7 @@ public class YangStringRestriction {
      *
      *
      * @param patternRestriction pattern restriction for the type
      * @param patternRestriction pattern restriction for the type
      */
      */
-    private void setPatternRestriction(YangPatternRestriction patternRestriction) {
+    public void setPatternRestriction(YangPatternRestriction patternRestriction) {
         this.patternRestriction = patternRestriction;
         this.patternRestriction = patternRestriction;
     }
     }
 
 

@@ -20,7 +20,6 @@ import org.onosproject.yangutils.datamodel.exceptions.DataModelException;
 import org.onosproject.yangutils.parser.Parsable;
 import org.onosproject.yangutils.parser.Parsable;
 import org.onosproject.yangutils.utils.YangConstructType;
 import org.onosproject.yangutils.utils.YangConstructType;
 
 
-import static org.onosproject.yangutils.datamodel.ResolvableStatus.INTRA_FILE_RESOLVED;
 import static org.onosproject.yangutils.datamodel.YangDataTypes.DERIVED;
 import static org.onosproject.yangutils.datamodel.YangDataTypes.DERIVED;
 
 
 /*
 /*
@@ -78,18 +77,6 @@ public class YangType<T>
     private T dataTypeExtendedInfo;
     private T dataTypeExtendedInfo;
 
 
     /**
     /**
-     * Effective built-in type, requried in case type of typedef is again a
-     * derived type. This information is to be added during linking.
-     */
-    private YangDataTypes effectiveBuiltInType;
-
-    /**
-     * Effective pattern restriction, requried in case type of typedef is again
-     * a derived type. This information is to be added during linking.
-     */
-    private YangPatternRestriction effectivePatternRestriction;
-
-    /**
      * Status of resolution. If completely resolved enum value is "RESOLVED",
      * Status of resolution. If completely resolved enum value is "RESOLVED",
      * if not enum value is "UNRESOLVED", in case reference of grouping/typedef
      * if not enum value is "UNRESOLVED", in case reference of grouping/typedef
      * is added to uses/type but it's not resolved value of enum should be
      * is added to uses/type but it's not resolved value of enum should be
@@ -215,42 +202,6 @@ public class YangType<T>
     }
     }
 
 
     /**
     /**
-     * Return effective built-in type.
-     *
-     * @return effective built-in type
-     */
-    public YangDataTypes getEffectiveBuiltInType() {
-        return effectiveBuiltInType;
-    }
-
-    /**
-     * Sets effective built-in type.
-     *
-     * @param effectiveBuiltInType effective built-in type
-     */
-    public void setEffectiveBuiltInType(YangDataTypes effectiveBuiltInType) {
-        this.effectiveBuiltInType = effectiveBuiltInType;
-    }
-
-    /**
-     * Returns effective pattern restriction.
-     *
-     * @return effective pattern restriction
-     */
-    public YangPatternRestriction getEffectivePatternRestriction() {
-        return effectivePatternRestriction;
-    }
-
-    /**
-     * Sets effective pattern restriction.
-     *
-     * @param effectivePatternRestriction effective pattern restriction
-     */
-    public void setEffectivePatternRestriction(YangPatternRestriction effectivePatternRestriction) {
-        this.effectivePatternRestriction = effectivePatternRestriction;
-    }
-
-    /**
      * Returns the type of the parsed data.
      * Returns the type of the parsed data.
      *
      *
      * @return returns TYPE_DATA
      * @return returns TYPE_DATA
@@ -269,7 +220,6 @@ public class YangType<T>
     public void validateDataOnEntry()
     public void validateDataOnEntry()
             throws DataModelException {
             throws DataModelException {
         // TODO auto-generated method stub, to be implemented by parser
         // TODO auto-generated method stub, to be implemented by parser
-
     }
     }
 
 
     /**
     /**
@@ -281,7 +231,6 @@ public class YangType<T>
     public void validateDataOnExit()
     public void validateDataOnExit()
             throws DataModelException {
             throws DataModelException {
         // TODO auto-generated method stub, to be implemented by parser
         // TODO auto-generated method stub, to be implemented by parser
-
     }
     }
 
 
     @Override
     @Override
@@ -297,17 +246,19 @@ public class YangType<T>
     @Override
     @Override
     public void resolve() throws DataModelException {
     public void resolve() throws DataModelException {
        /*
        /*
-       Inherit the Restriction from the referred typedef definition.
+        * Check whether the data type is derived.
         */
         */
         if (getDataType() != DERIVED) {
         if (getDataType() != DERIVED) {
-            throw new DataModelException("Resolve should only be called for derived data types");
+            throw new DataModelException("Linker Error: Resolve should only be called for derived data types.");
         }
         }
 
 
-        YangDerivedInfo<?> derrivedInfo = (YangDerivedInfo<?>) getDataTypeExtendedInfo();
-        YangType<?> baseType = derrivedInfo.getReferredTypeDef().getTypeDefBaseType();
-        if (DERIVED == baseType.getDataType() && baseType.getResolvableStatus() == INTRA_FILE_RESOLVED) {
-                setResolvableStatus(INTRA_FILE_RESOLVED);
+        // Check if the derived info is present.
+        YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) getDataTypeExtendedInfo();
+        if (derivedInfo == null) {
+            throw new DataModelException("Linker Error: Derived information is missing.");
         }
         }
-        //TODO:
+
+        // Initiate the resolution
+        setResolvableStatus(derivedInfo.resolve());
     }
     }
 }
 }

@@ -83,11 +83,6 @@ public class YangTypeDef extends YangNode implements YangCommonInfo, Parsable, Y
     private String name;
     private String name;
 
 
     /**
     /**
-     * Maintain the data type information.
-     */
-    private YangType<?> dataType;
-
-    /**
      * Units of the data type.
      * Units of the data type.
      */
      */
     private String units;
     private String units;

 /*
 /*
- * Copyright 2016 Open Networking Laboratory
+ * Copyright 2016-present Open Networking Laboratory
  *
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * you may not use this file except in compliance with the License.
@@ -16,34 +16,26 @@
 
 
 package org.onosproject.yangutils.parser.impl.listeners;
 package org.onosproject.yangutils.parser.impl.listeners;
 
 
-import java.util.regex.Pattern;
-
+import org.onosproject.yangutils.datamodel.YangDataTypes;
+import org.onosproject.yangutils.datamodel.YangDerivedInfo;
 import org.onosproject.yangutils.datamodel.YangRangeRestriction;
 import org.onosproject.yangutils.datamodel.YangRangeRestriction;
-import org.onosproject.yangutils.datamodel.YangRangeInterval;
 import org.onosproject.yangutils.datamodel.YangStringRestriction;
 import org.onosproject.yangutils.datamodel.YangStringRestriction;
 import org.onosproject.yangutils.datamodel.YangType;
 import org.onosproject.yangutils.datamodel.YangType;
-import org.onosproject.yangutils.datamodel.YangDataTypes;
-import org.onosproject.yangutils.datamodel.YangDerivedInfo;
-import org.onosproject.yangutils.datamodel.exceptions.DataModelException;
 import org.onosproject.yangutils.parser.Parsable;
 import org.onosproject.yangutils.parser.Parsable;
 import org.onosproject.yangutils.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yangutils.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.impl.TreeWalkListener;
 import org.onosproject.yangutils.parser.impl.TreeWalkListener;
 import org.onosproject.yangutils.utils.YangConstructType;
 import org.onosproject.yangutils.utils.YangConstructType;
-import org.onosproject.yangutils.utils.builtindatatype.DataTypeException;
-import org.onosproject.yangutils.utils.builtindatatype.YangBuiltInDataTypeInfo;
 
 
-import static org.onosproject.yangutils.parser.impl.parserutils.ListenerUtil.removeQuotesAndHandleConcat;
-import static org.onosproject.yangutils.utils.YangConstructType.LENGTH_DATA;
-import static org.onosproject.yangutils.utils.YangConstructType.TYPE_DATA;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.DERIVED;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
-import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
-import static org.onosproject.yangutils.utils.builtindatatype.BuiltInTypeObjectFactory.getDataObjectFromString;
+import static org.onosproject.yangutils.utils.RestrictionResolver.processLengthRestriction;
+import static org.onosproject.yangutils.utils.YangConstructType.LENGTH_DATA;
+import static org.onosproject.yangutils.utils.YangConstructType.TYPE_DATA;
 
 
 /*
 /*
  * Reference: RFC6020 and YANG ANTLR Grammar
  * Reference: RFC6020 and YANG ANTLR Grammar
@@ -71,11 +63,6 @@ import static org.onosproject.yangutils.utils.builtindatatype.BuiltInTypeObjectF
  */
  */
 public final class LengthRestrictionListener {
 public final class LengthRestrictionListener {
 
 
-    private static final String PIPE = "|";
-    private static final String LENGTH_INTERVAL = "..";
-    private static final int MAX_RANGE_BOUNDARY = 2;
-    private static final int MIN_RANGE_BOUNDARY = 1;
-
     /**
     /**
      * Creates a new length restriction listener.
      * Creates a new length restriction listener.
      */
      */
@@ -115,13 +102,17 @@ public final class LengthRestrictionListener {
     private static void setLengthRestriction(YangType type,
     private static void setLengthRestriction(YangType type,
                                              GeneratedYangParser.LengthStatementContext ctx) {
                                              GeneratedYangParser.LengthStatementContext ctx) {
 
 
-        YangStringRestriction stringRestriction;
-        YangBuiltInDataTypeInfo<?> startValue;
-        YangBuiltInDataTypeInfo<?> endValue;
-        YangRangeRestriction lengthRestriction = new YangRangeRestriction<>();
-
-        if (type.getDataType() != YangDataTypes.STRING && type.getDataType() != YangDataTypes.DERIVED) {
+        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());
+            return;
+        }
 
 
+        if (type.getDataType() != YangDataTypes.STRING) {
             ParserException parserException = new ParserException("YANG file error : " +
             ParserException parserException = new ParserException("YANG file error : " +
                     YangConstructType.getYangConstructType(LENGTH_DATA) + " name " + ctx.length().getText() +
                     YangConstructType.getYangConstructType(LENGTH_DATA) + " name " + ctx.length().getText() +
                     " can be used to restrict the built-in type string or types derived from string.");
                     " can be used to restrict the built-in type string or types derived from string.");
@@ -130,71 +121,14 @@ public final class LengthRestrictionListener {
             throw parserException;
             throw parserException;
         }
         }
 
 
-        if (type.getDataType() == YangDataTypes.STRING) {
-            stringRestriction = (YangStringRestriction) type.getDataTypeExtendedInfo();
-        } else {
-            stringRestriction = (YangStringRestriction) ((YangDerivedInfo<?>) type
-                    .getDataTypeExtendedInfo()).getExtendedInfo();
-        }
+        YangRangeRestriction lengthRestriction = processLengthRestriction(null, ctx.getStart().getLine(),
+                ctx.getStart().getCharPositionInLine(), false, ctx.length().getText());
+
+        YangStringRestriction stringRestriction = (YangStringRestriction) type.getDataTypeExtendedInfo();
 
 
         if (stringRestriction == null) {
         if (stringRestriction == null) {
             stringRestriction = new YangStringRestriction();
             stringRestriction = new YangStringRestriction();
-            if (type.getDataType() == YangDataTypes.STRING) {
             type.setDataTypeExtendedInfo(stringRestriction);
             type.setDataTypeExtendedInfo(stringRestriction);
-            } else {
-                ((YangDerivedInfo<YangStringRestriction>) type.getDataTypeExtendedInfo())
-                        .setExtendedInfo(stringRestriction);
-            }
-        }
-
-        String rangeArgument = removeQuotesAndHandleConcat(ctx.length().getText());
-        String[] rangeArguments = rangeArgument.trim().split(Pattern.quote(PIPE));
-
-        for (String rangePart : rangeArguments) {
-            String startInterval;
-            String endInterval;
-            YangRangeInterval rangeInterval = new YangRangeInterval<>();
-            String[] rangeBoundary = rangePart.trim().split(Pattern.quote(LENGTH_INTERVAL));
-
-            if (rangeBoundary.length > MAX_RANGE_BOUNDARY) {
-                ParserException parserException = new ParserException("YANG file error : " +
-                        YangConstructType.getYangConstructType(LENGTH_DATA) + " " + rangeArgument +
-                        " is not valid.");
-                parserException.setLine(ctx.getStart().getLine());
-                parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
-                throw parserException;
-            }
-
-            if (rangeBoundary.length == MIN_RANGE_BOUNDARY) {
-                startInterval = rangeBoundary[0];
-                endInterval = rangeBoundary[0];
-            } else {
-                startInterval = rangeBoundary[0];
-                endInterval = rangeBoundary[1];
-            }
-
-            try {
-                startValue = getDataObjectFromString(startInterval, YangDataTypes.UINT64);
-                endValue = getDataObjectFromString(endInterval, YangDataTypes.UINT64);
-            } catch (DataTypeException e) {
-                ParserException parserException = new ParserException(e.getMessage());
-                parserException.setLine(ctx.getStart().getLine());
-                parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
-                throw parserException;
-            }
-
-            rangeInterval.setStartValue(startValue);
-            rangeInterval.setEndValue(endValue);
-
-            try {
-                lengthRestriction.addRangeRestrictionInterval(rangeInterval);
-            } catch (DataModelException e) {
-                ParserException parserException = new ParserException(constructExtendedListenerErrorMessage(
-                        UNHANDLED_PARSED_DATA, LENGTH_DATA, rangeArgument, ENTRY, e.getMessage()));
-                parserException.setLine(ctx.getStart().getLine());
-                parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
-                throw parserException;
-            }
         }
         }
 
 
         stringRestriction.setLengthRestriction(lengthRestriction);
         stringRestriction.setLengthRestriction(lengthRestriction);

 /*
 /*
- * Copyright 2016 Open Networking Laboratory
+ * Copyright 2016-present Open Networking Laboratory
  *
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * you may not use this file except in compliance with the License.
@@ -16,23 +16,24 @@
 
 
 package org.onosproject.yangutils.parser.impl.listeners;
 package org.onosproject.yangutils.parser.impl.listeners;
 
 
+import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.datamodel.YangDerivedInfo;
 import org.onosproject.yangutils.datamodel.YangDerivedInfo;
-import org.onosproject.yangutils.datamodel.YangType;
+import org.onosproject.yangutils.datamodel.YangPatternRestriction;
 import org.onosproject.yangutils.datamodel.YangStringRestriction;
 import org.onosproject.yangutils.datamodel.YangStringRestriction;
-import org.onosproject.yangutils.datamodel.YangDataTypes;
+import org.onosproject.yangutils.datamodel.YangType;
 import org.onosproject.yangutils.parser.Parsable;
 import org.onosproject.yangutils.parser.Parsable;
 import org.onosproject.yangutils.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yangutils.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.impl.TreeWalkListener;
 import org.onosproject.yangutils.parser.impl.TreeWalkListener;
 import org.onosproject.yangutils.utils.YangConstructType;
 import org.onosproject.yangutils.utils.YangConstructType;
 
 
-import static org.onosproject.yangutils.utils.YangConstructType.PATTERN_DATA;
-import static org.onosproject.yangutils.utils.YangConstructType.TYPE_DATA;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
+import static org.onosproject.yangutils.utils.YangConstructType.PATTERN_DATA;
+import static org.onosproject.yangutils.utils.YangConstructType.TYPE_DATA;
 
 
 /*
 /*
  * Reference: RFC6020 and YANG ANTLR Grammar
  * Reference: RFC6020 and YANG ANTLR Grammar
@@ -99,8 +100,6 @@ public final class PatternRestrictionListener {
     private static void setPatternRestriction(YangType type,
     private static void setPatternRestriction(YangType type,
                                               GeneratedYangParser.PatternStatementContext ctx) {
                                               GeneratedYangParser.PatternStatementContext ctx) {
 
 
-        YangStringRestriction stringRestriction;
-
         if (type.getDataType() != YangDataTypes.STRING && type.getDataType() != YangDataTypes.DERIVED) {
         if (type.getDataType() != YangDataTypes.STRING && type.getDataType() != YangDataTypes.DERIVED) {
 
 
             ParserException parserException = new ParserException("YANG file error : " +
             ParserException parserException = new ParserException("YANG file error : " +
@@ -111,24 +110,28 @@ public final class PatternRestrictionListener {
             throw parserException;
             throw parserException;
         }
         }
 
 
-        if (type.getDataType() == YangDataTypes.STRING) {
-            stringRestriction = (YangStringRestriction) type.getDataTypeExtendedInfo();
-        } else {
-            stringRestriction = (YangStringRestriction) ((YangDerivedInfo<?>) type
-                    .getDataTypeExtendedInfo()).getExtendedInfo();
-        }
+        String patternArgument = ctx.string().getText().replace("\"", EMPTY_STRING);
 
 
+        if (type.getDataType() == YangDataTypes.STRING) {
+            YangStringRestriction stringRestriction = (YangStringRestriction) type.getDataTypeExtendedInfo();
             if (stringRestriction == null) {
             if (stringRestriction == null) {
                 stringRestriction = new YangStringRestriction();
                 stringRestriction = new YangStringRestriction();
-            if (type.getDataType() == YangDataTypes.STRING) {
                 type.setDataTypeExtendedInfo(stringRestriction);
                 type.setDataTypeExtendedInfo(stringRestriction);
+                stringRestriction.addPattern(patternArgument);
             } else {
             } else {
-                ((YangDerivedInfo<YangStringRestriction>) type.getDataTypeExtendedInfo())
-                        .setExtendedInfo(stringRestriction);
+                stringRestriction.addPattern(patternArgument);
+            }
+        } else {
+            YangPatternRestriction patternRestriction = (YangPatternRestriction) ((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);
             }
             }
         }
         }
-
-        String patternArgument = ctx.string().getText().replace("\"", EMPTY_STRING);
-        stringRestriction.addPattern(patternArgument);
     }
     }
 }
 }

@@ -16,33 +16,24 @@
 
 
 package org.onosproject.yangutils.parser.impl.listeners;
 package org.onosproject.yangutils.parser.impl.listeners;
 
 
-import java.util.regex.Pattern;
-
-import org.onosproject.yangutils.datamodel.YangRangeInterval;
+import org.onosproject.yangutils.datamodel.YangDerivedInfo;
 import org.onosproject.yangutils.datamodel.YangRangeRestriction;
 import org.onosproject.yangutils.datamodel.YangRangeRestriction;
 import org.onosproject.yangutils.datamodel.YangType;
 import org.onosproject.yangutils.datamodel.YangType;
-import org.onosproject.yangutils.datamodel.YangDerivedInfo;
-import org.onosproject.yangutils.datamodel.exceptions.DataModelException;
-import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.parser.Parsable;
 import org.onosproject.yangutils.parser.Parsable;
 import org.onosproject.yangutils.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yangutils.parser.antlrgencode.GeneratedYangParser;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.impl.TreeWalkListener;
 import org.onosproject.yangutils.parser.impl.TreeWalkListener;
-import org.onosproject.yangutils.utils.YangConstructType;
-import org.onosproject.yangutils.utils.builtindatatype.DataTypeException;
-import org.onosproject.yangutils.utils.builtindatatype.YangBuiltInDataTypeInfo;
 
 
+import static org.onosproject.yangutils.datamodel.YangDataTypes.DERIVED;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
-import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorMessageConstruction.constructListenerErrorMessage;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.INVALID_HOLDER;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
-import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
-import static org.onosproject.yangutils.parser.impl.parserutils.ListenerUtil.removeQuotesAndHandleConcat;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
 import static org.onosproject.yangutils.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
-import static org.onosproject.yangutils.utils.YangConstructType.TYPE_DATA;
+import static org.onosproject.yangutils.utils.RestrictionResolver.isOfRangeRestrictedType;
+import static org.onosproject.yangutils.utils.RestrictionResolver.processRangeRestriction;
 import static org.onosproject.yangutils.utils.YangConstructType.RANGE_DATA;
 import static org.onosproject.yangutils.utils.YangConstructType.RANGE_DATA;
-import static org.onosproject.yangutils.utils.builtindatatype.BuiltInTypeObjectFactory.getDataObjectFromString;
+import static org.onosproject.yangutils.utils.YangConstructType.TYPE_DATA;
 
 
 /*
 /*
  * Reference: RFC6020 and YANG ANTLR Grammar
  * Reference: RFC6020 and YANG ANTLR Grammar
@@ -68,11 +59,6 @@ import static org.onosproject.yangutils.utils.builtindatatype.BuiltInTypeObjectF
  */
  */
 public final class RangeRestrictionListener {
 public final class RangeRestrictionListener {
 
 
-    private static final String PIPE = "|";
-    private static final String RANGE_INTERVAL = "..";
-    private static final int MAX_RANGE_BOUNDARY = 2;
-    private static final int MIN_RANGE_BOUNDARY = 1;
-
     /**
     /**
      * Creates a new range restriction listener.
      * Creates a new range restriction listener.
      */
      */
@@ -112,68 +98,29 @@ public final class RangeRestrictionListener {
     private static void setRangeRestriction(YangType type,
     private static void setRangeRestriction(YangType type,
                                             GeneratedYangParser.RangeStatementContext ctx) {
                                             GeneratedYangParser.RangeStatementContext ctx) {
 
 
-        YangBuiltInDataTypeInfo<?> startValue;
-        YangBuiltInDataTypeInfo<?> endValue;
-        YangRangeRestriction rangeRestriction = new YangRangeRestriction();
-
-        String rangeArgument = removeQuotesAndHandleConcat(ctx.range().getText());
-        String[] rangeArguments = rangeArgument.trim().split(Pattern.quote(PIPE));
-
-        for (String rangePart : rangeArguments) {
-            String startInterval;
-            String endInterval;
-            YangRangeInterval rangeInterval = new YangRangeInterval();
-            String[] rangeBoundary = rangePart.trim().split(Pattern.quote(RANGE_INTERVAL));
-
-            if (rangeBoundary.length > MAX_RANGE_BOUNDARY) {
-                ParserException parserException = new ParserException("YANG file error : " +
-                        YangConstructType.getYangConstructType(RANGE_DATA) + " " + rangeArgument +
-                        " is not valid.");
-                parserException.setLine(ctx.getStart().getLine());
-                parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
-                throw parserException;
-            }
-
-            if (rangeBoundary.length == MIN_RANGE_BOUNDARY) {
-                startInterval = rangeBoundary[0];
-                endInterval = rangeBoundary[0];
-            } else {
-                startInterval = rangeBoundary[0];
-                endInterval = rangeBoundary[1];
+        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());
+            return;
         }
         }
 
 
-            try {
-                startValue = getDataObjectFromString(startInterval, type.getDataType());
-                endValue = getDataObjectFromString(endInterval, type.getDataType());
-            } catch (DataTypeException e) {
-                ParserException parserException = new ParserException(e.getMessage());
+        if (!(isOfRangeRestrictedType(type.getDataType()))) {
+            ParserException parserException = new ParserException("YANG file error: Range restriction can't be " +
+                    "applied to a given type");
             parserException.setLine(ctx.getStart().getLine());
             parserException.setLine(ctx.getStart().getLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
             parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
             throw parserException;
             throw parserException;
         }
         }
 
 
-            rangeInterval.setStartValue(startValue);
-            rangeInterval.setEndValue(endValue);
-
-            try {
-                rangeRestriction.addRangeRestrictionInterval(rangeInterval);
-            } catch (DataModelException e) {
-                ParserException parserException = new ParserException(constructExtendedListenerErrorMessage(
-                        UNHANDLED_PARSED_DATA, RANGE_DATA, rangeArgument, ENTRY, e.getMessage()));
-                parserException.setLine(ctx.getStart().getLine());
-                parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
-                throw parserException;
-            }
-        }
+        YangRangeRestriction rangeRestriction = processRangeRestriction(null, ctx.getStart().getLine(),
+                ctx.getStart().getCharPositionInLine(), false, ctx.range().getText(), type.getDataType());
 
 
         if (rangeRestriction != null) {
         if (rangeRestriction != null) {
-            if (type.getDataType() == YangDataTypes.DERIVED) {
-                ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
-                        .setExtendedInfo(rangeRestriction);
-            } else {
             type.setDataTypeExtendedInfo(rangeRestriction);
             type.setDataTypeExtendedInfo(rangeRestriction);
         }
         }
     }
     }
-
-    }
 }
 }
\ No newline at end of file

+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.yangutils.utils;
+
+import java.util.regex.Pattern;
+import org.onosproject.yangutils.datamodel.YangDataTypes;
+import org.onosproject.yangutils.datamodel.YangRangeInterval;
+import org.onosproject.yangutils.datamodel.YangRangeRestriction;
+import org.onosproject.yangutils.datamodel.exceptions.DataModelException;
+import org.onosproject.yangutils.parser.exceptions.ParserException;
+import org.onosproject.yangutils.utils.builtindatatype.DataTypeException;
+import org.onosproject.yangutils.utils.builtindatatype.YangBuiltInDataTypeInfo;
+
+import static org.onosproject.yangutils.datamodel.YangDataTypes.DECIMAL64;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.INT16;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.INT32;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.INT64;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.INT8;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.UINT16;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.UINT32;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.UINT64;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.UINT8;
+import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
+import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorMessageConstruction.constructExtendedListenerErrorMessage;
+import static org.onosproject.yangutils.parser.impl.parserutils.ListenerErrorType.UNHANDLED_PARSED_DATA;
+import static org.onosproject.yangutils.parser.impl.parserutils.ListenerUtil.removeQuotesAndHandleConcat;
+import static org.onosproject.yangutils.utils.YangConstructType.LENGTH_DATA;
+import static org.onosproject.yangutils.utils.YangConstructType.RANGE_DATA;
+import static org.onosproject.yangutils.utils.builtindatatype.BuiltInTypeObjectFactory.getDataObjectFromString;
+
+/**
+ * Represents restriction resolver which provide common utility used by parser
+ * and during linking for restriction resolution.
+ */
+public final class RestrictionResolver {
+
+    private static final String PIPE = "|";
+    private static final String INTERVAL = "..";
+    private static final int MAX_RANGE_BOUNDARY = 2;
+    private static final int MIN_RANGE_BOUNDARY = 1;
+    private static final String MIN_KEYWORD = "min";
+    private static final String MAX_KEYWORD = "max";
+
+    /**
+     * Creates a restriction resolver.
+     */
+    private RestrictionResolver() {
+    }
+
+    /**
+     * Processes the range restriction for parser and linker.
+     *
+     * @param refRangeRestriction    range restriction of referred typedef
+     * @param lineNumber             error line number
+     * @param charPositionInLine     error character position in line
+     * @param hasReferredRestriction whether has referred restriction
+     * @param curRangeString         caller type's range string
+     * @param effectiveType          effective type, when called from linker
+     * @return YANG range restriction
+     */
+    public static YangRangeRestriction processRangeRestriction(YangRangeRestriction refRangeRestriction,
+                                                               int lineNumber, int charPositionInLine,
+                                                               boolean hasReferredRestriction,
+                                                               String curRangeString, YangDataTypes effectiveType) {
+        YangBuiltInDataTypeInfo<?> startValue;
+        YangBuiltInDataTypeInfo<?> endValue;
+        YangRangeRestriction rangeRestriction = new YangRangeRestriction();
+
+        String rangeArgument = removeQuotesAndHandleConcat(curRangeString);
+        String[] rangeArguments = rangeArgument.trim().split(Pattern.quote(PIPE));
+
+        for (String rangePart : rangeArguments) {
+            String startInterval;
+            String endInterval;
+            YangRangeInterval rangeInterval = new YangRangeInterval();
+            String[] rangeBoundary = rangePart.trim().split(Pattern.quote(INTERVAL));
+
+            if (rangeBoundary.length > MAX_RANGE_BOUNDARY) {
+                ParserException parserException = new ParserException("YANG file error : " +
+                        YangConstructType.getYangConstructType(RANGE_DATA) + " " + rangeArgument +
+                        " is not valid.");
+                parserException.setLine(lineNumber);
+                parserException.setCharPosition(charPositionInLine);
+                throw parserException;
+            }
+
+            if (rangeBoundary.length == MIN_RANGE_BOUNDARY) {
+                startInterval = rangeBoundary[0];
+                endInterval = rangeBoundary[0];
+            } else {
+                startInterval = rangeBoundary[0];
+                endInterval = rangeBoundary[1];
+            }
+
+            try {
+                if (hasReferredRestriction && startInterval.equals(MIN_KEYWORD)
+                        && refRangeRestriction.getMinRestrictedvalue() != null) {
+                    startValue = refRangeRestriction.getMinRestrictedvalue();
+                } else if (hasReferredRestriction && startInterval.equals(MAX_KEYWORD)
+                        && refRangeRestriction.getMaxRestrictedvalue() != null) {
+                    startValue = refRangeRestriction.getMaxRestrictedvalue();
+                } else {
+                    startValue = getDataObjectFromString(startInterval, effectiveType);
+                }
+                if (hasReferredRestriction && endInterval.equals(MIN_KEYWORD)
+                        && refRangeRestriction.getMinRestrictedvalue() != null) {
+                    endValue = refRangeRestriction.getMinRestrictedvalue();
+                } else if (hasReferredRestriction && endInterval.equals(MAX_KEYWORD)
+                        && refRangeRestriction.getMaxRestrictedvalue() != null) {
+                    endValue = refRangeRestriction.getMaxRestrictedvalue();
+                } else {
+                    endValue = getDataObjectFromString(endInterval, effectiveType);
+                }
+            } catch (DataTypeException | DataModelException e) {
+                ParserException parserException = new ParserException(e.getMessage());
+                parserException.setLine(lineNumber);
+                parserException.setCharPosition(charPositionInLine);
+                throw parserException;
+            }
+
+            rangeInterval.setStartValue(startValue);
+            rangeInterval.setEndValue(endValue);
+
+            try {
+                rangeRestriction.addRangeRestrictionInterval(rangeInterval);
+            } catch (DataModelException e) {
+                ParserException parserException = new ParserException(constructExtendedListenerErrorMessage(
+                        UNHANDLED_PARSED_DATA, RANGE_DATA, rangeArgument, ENTRY, e.getMessage()));
+                parserException.setLine(lineNumber);
+                parserException.setCharPosition(charPositionInLine);
+                throw parserException;
+            }
+        }
+        return rangeRestriction;
+    }
+
+    /**
+     * Processes the length restriction for parser and linker.
+     *
+     * @param refLengthRestriction   length restriction of referred typedef
+     * @param lineNumber             error line number
+     * @param charPositionInLine     error character position in line
+     * @param hasReferredRestriction whether has referred restriction
+     * @param curLengthString        caller type's length string
+     * @return YANG range restriction
+     */
+    public static YangRangeRestriction processLengthRestriction(YangRangeRestriction refLengthRestriction,
+                                                                int lineNumber, int charPositionInLine,
+                                                                boolean hasReferredRestriction,
+                                                                String curLengthString) {
+
+        YangBuiltInDataTypeInfo<?> startValue;
+        YangBuiltInDataTypeInfo<?> endValue;
+        YangRangeRestriction lengthRestriction = new YangRangeRestriction<>();
+
+        String rangeArgument = removeQuotesAndHandleConcat(curLengthString);
+        String[] rangeArguments = rangeArgument.trim().split(Pattern.quote(PIPE));
+
+        for (String rangePart : rangeArguments) {
+            String startInterval;
+            String endInterval;
+            YangRangeInterval rangeInterval = new YangRangeInterval<>();
+            String[] rangeBoundary = rangePart.trim().split(Pattern.quote(INTERVAL));
+
+            if (rangeBoundary.length > MAX_RANGE_BOUNDARY) {
+                ParserException parserException = new ParserException("YANG file error : " +
+                        YangConstructType.getYangConstructType(LENGTH_DATA) + " " + rangeArgument +
+                        " is not valid.");
+                parserException.setLine(lineNumber);
+                parserException.setCharPosition(charPositionInLine);
+                throw parserException;
+            }
+
+            if (rangeBoundary.length == MIN_RANGE_BOUNDARY) {
+                startInterval = rangeBoundary[0];
+                endInterval = rangeBoundary[0];
+            } else {
+                startInterval = rangeBoundary[0];
+                endInterval = rangeBoundary[1];
+            }
+
+            try {
+                if (hasReferredRestriction && startInterval.equals(MIN_KEYWORD)
+                        && refLengthRestriction.getMinRestrictedvalue() != null) {
+                    startValue = refLengthRestriction.getMinRestrictedvalue();
+                } else if (hasReferredRestriction && startInterval.equals(MAX_KEYWORD)
+                        && refLengthRestriction.getMaxRestrictedvalue() != null) {
+                    startValue = refLengthRestriction.getMaxRestrictedvalue();
+                } else {
+                    startValue = getDataObjectFromString(startInterval, YangDataTypes.UINT64);
+                }
+                if (hasReferredRestriction && endInterval.equals(MIN_KEYWORD)
+                        && refLengthRestriction.getMinRestrictedvalue() != null) {
+                    endValue = refLengthRestriction.getMinRestrictedvalue();
+                } else if (hasReferredRestriction && endInterval.equals(MAX_KEYWORD)
+                        && refLengthRestriction.getMaxRestrictedvalue() != null) {
+                    endValue = refLengthRestriction.getMaxRestrictedvalue();
+                } else {
+                    endValue = getDataObjectFromString(endInterval, YangDataTypes.UINT64);
+                }
+            } catch (DataTypeException | DataModelException e) {
+                ParserException parserException = new ParserException(e.getMessage());
+                parserException.setLine(lineNumber);
+                parserException.setCharPosition(charPositionInLine);
+                throw parserException;
+            }
+
+            rangeInterval.setStartValue(startValue);
+            rangeInterval.setEndValue(endValue);
+
+            try {
+                lengthRestriction.addRangeRestrictionInterval(rangeInterval);
+            } catch (DataModelException e) {
+                ParserException parserException = new ParserException(constructExtendedListenerErrorMessage(
+                        UNHANDLED_PARSED_DATA, LENGTH_DATA, rangeArgument, ENTRY, e.getMessage()));
+                parserException.setLine(lineNumber);
+                parserException.setCharPosition(charPositionInLine);
+                throw parserException;
+            }
+        }
+        return lengthRestriction;
+    }
+
+    /**
+     * Returns whether the data type is of range restricted type.
+     *
+     * @param dataType data type to be checked
+     * @return true, if data type can have range restrictions, false otherwise
+     */
+    public static boolean isOfRangeRestrictedType(YangDataTypes dataType) {
+        return (dataType == INT8
+                || dataType == INT16
+                || dataType == INT32
+                || dataType == INT64
+                || dataType == UINT8
+                || dataType == UINT16
+                || dataType == UINT32
+                || dataType == UINT64
+                || dataType == DECIMAL64);
+    }
+}

 /*
 /*
- * Copyright 2016 Open Networking Laboratory
+ * Copyright 2016-present Open Networking Laboratory
  *
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * you may not use this file except in compliance with the License.
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
+
 package org.onosproject.yangutils.utils.builtindatatype;
 package org.onosproject.yangutils.utils.builtindatatype;
 
 
 import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.datamodel.YangDataTypes;
@@ -66,7 +67,8 @@ public class YangInt16 implements YangBuiltInDataTypeInfo<YangInt16> {
             try {
             try {
                 value = Short.parseShort(valueInString);
                 value = Short.parseShort(valueInString);
             } catch (Exception e) {
             } catch (Exception e) {
-                throw new DataTypeException("YANG file error : " + valueInString + " is not valid.");
+                throw new DataTypeException("YANG file error : Input value \"" + valueInString + "\" is not a valid " +
+                        "int16.");
             }
             }
         }
         }
     }
     }

 /*
 /*
- * Copyright 2016 Open Networking Laboratory
+ * Copyright 2016-present Open Networking Laboratory
  *
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * you may not use this file except in compliance with the License.
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
+
 package org.onosproject.yangutils.utils.builtindatatype;
 package org.onosproject.yangutils.utils.builtindatatype;
 
 
 import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.datamodel.YangDataTypes;
@@ -65,7 +66,8 @@ public class YangInt32 implements YangBuiltInDataTypeInfo<YangInt32> {
             try {
             try {
                 value = Integer.parseInt(valueInString);
                 value = Integer.parseInt(valueInString);
             } catch (Exception e) {
             } catch (Exception e) {
-                throw new DataTypeException("YANG file error : " + valueInString + " is not valid.");
+                throw new DataTypeException("YANG file error : Input value \"" + valueInString + "\" is not a valid " +
+                        "int32.");
             }
             }
         }
         }
     }
     }

 /*
 /*
- * Copyright 2016 Open Networking Laboratory
+ * Copyright 2016-present Open Networking Laboratory
  *
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * you may not use this file except in compliance with the License.
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
+
 package org.onosproject.yangutils.utils.builtindatatype;
 package org.onosproject.yangutils.utils.builtindatatype;
 
 
 import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.datamodel.YangDataTypes;
@@ -65,7 +66,8 @@ public class YangInt64 implements YangBuiltInDataTypeInfo<YangInt64> {
             try {
             try {
                 value = Long.parseLong(valueInString);
                 value = Long.parseLong(valueInString);
             } catch (Exception e) {
             } catch (Exception e) {
-                throw new DataTypeException("YANG file error : " + valueInString + " is not valid.");
+                throw new DataTypeException("YANG file error : Input value \"" + valueInString + "\" is not a valid " +
+                        "int64.");
             }
             }
         }
         }
     }
     }

 /*
 /*
- * Copyright 2016 Open Networking Laboratory
+ * Copyright 2016-present Open Networking Laboratory
  *
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * you may not use this file except in compliance with the License.
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
+
 package org.onosproject.yangutils.utils.builtindatatype;
 package org.onosproject.yangutils.utils.builtindatatype;
 
 
 import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.datamodel.YangDataTypes;
@@ -65,7 +66,8 @@ public class YangInt8 implements YangBuiltInDataTypeInfo<YangInt8> {
             try {
             try {
                 value = Byte.parseByte(valueInString);
                 value = Byte.parseByte(valueInString);
             } catch (Exception e) {
             } catch (Exception e) {
-                throw new DataTypeException("YANG file error : " + valueInString + " is not valid.");
+                throw new DataTypeException("YANG file error : Input value \"" + valueInString + "\" is not a valid " +
+                        "int8.");
             }
             }
         }
         }
     }
     }

 /*
 /*
- * Copyright 2016 Open Networking Laboratory
+ * Copyright 2016-present Open Networking Laboratory
  *
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * you may not use this file except in compliance with the License.
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
+
 package org.onosproject.yangutils.utils.builtindatatype;
 package org.onosproject.yangutils.utils.builtindatatype;
 
 
 import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.datamodel.YangDataTypes;
@@ -65,7 +66,8 @@ public class YangUint16 implements YangBuiltInDataTypeInfo<YangUint16> {
             try {
             try {
                 value = Integer.parseInt(valueInString);
                 value = Integer.parseInt(valueInString);
             } catch (Exception e) {
             } catch (Exception e) {
-                throw new DataTypeException("YANG file error : " + valueInString + " is not valid.");
+                throw new DataTypeException("YANG file error : Input value \"" + valueInString + "\" is not a valid " +
+                        "uint16.");
             }
             }
         }
         }
 
 

 /*
 /*
- * Copyright 2016 Open Networking Laboratory
+ * Copyright 2016-present Open Networking Laboratory
  *
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * you may not use this file except in compliance with the License.
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
+
 package org.onosproject.yangutils.utils.builtindatatype;
 package org.onosproject.yangutils.utils.builtindatatype;
 
 
 import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.datamodel.YangDataTypes;
@@ -58,7 +59,8 @@ public class YangUint32 implements YangBuiltInDataTypeInfo<YangUint32> {
             try {
             try {
                 value = Long.parseLong(valueInString);
                 value = Long.parseLong(valueInString);
             } catch (Exception e) {
             } catch (Exception e) {
-                throw new DataTypeException("YANG file error : " + valueInString + " is not valid.");
+                throw new DataTypeException("YANG file error : Input value \"" + valueInString + "\" is not a valid " +
+                        "uint32.");
             }
             }
         }
         }
 
 

 /*
 /*
- * Copyright 2016 Open Networking Laboratory
+ * Copyright 2016-present Open Networking Laboratory
  *
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * you may not use this file except in compliance with the License.
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
+
 package org.onosproject.yangutils.utils.builtindatatype;
 package org.onosproject.yangutils.utils.builtindatatype;
 
 
 import java.math.BigInteger;
 import java.math.BigInteger;
@@ -71,7 +72,8 @@ public class YangUint64 implements YangBuiltInDataTypeInfo<YangUint64> {
         } else if (NON_NEGATIVE_INTEGER_PATTERN.matcher(valueInString).matches()) {
         } else if (NON_NEGATIVE_INTEGER_PATTERN.matcher(valueInString).matches()) {
             value = new BigInteger(valueInString);
             value = new BigInteger(valueInString);
         } else {
         } else {
-            throw new DataTypeException("YANG file error : " + valueInString + " is not valid.");
+            throw new DataTypeException("YANG file error : Input value \"" + valueInString + "\" is not a valid " +
+                    "uint64.");
         }
         }
 
 
         if (value.compareTo(MIN_VALUE) < 0) {
         if (value.compareTo(MIN_VALUE) < 0) {

 /*
 /*
- * Copyright 2016 Open Networking Laboratory
+ * Copyright 2016-present Open Networking Laboratory
  *
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * you may not use this file except in compliance with the License.
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
+
 package org.onosproject.yangutils.utils.builtindatatype;
 package org.onosproject.yangutils.utils.builtindatatype;
 
 
 import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.datamodel.YangDataTypes;
@@ -65,7 +66,8 @@ public class YangUint8 implements YangBuiltInDataTypeInfo<YangUint8> {
             try {
             try {
                 value = Short.parseShort(valueInString);
                 value = Short.parseShort(valueInString);
             } catch (Exception e) {
             } catch (Exception e) {
-                throw new DataTypeException("YANG file error : " + valueInString + " is not valid.");
+                throw new DataTypeException("YANG file error : Input value \"" + valueInString + "\" is not a valid " +
+                        "uint8.");
             }
             }
         }
         }
 
 

@@ -18,23 +18,26 @@ package org.onosproject.yangutils.linker;
 
 
 import java.io.IOException;
 import java.io.IOException;
 import java.util.ListIterator;
 import java.util.ListIterator;
-
 import org.junit.Test;
 import org.junit.Test;
-import org.onosproject.yangutils.datamodel.ResolvableStatus;
 import org.onosproject.yangutils.datamodel.YangContainer;
 import org.onosproject.yangutils.datamodel.YangContainer;
-import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.datamodel.YangDerivedInfo;
 import org.onosproject.yangutils.datamodel.YangDerivedInfo;
 import org.onosproject.yangutils.datamodel.YangLeaf;
 import org.onosproject.yangutils.datamodel.YangLeaf;
 import org.onosproject.yangutils.datamodel.YangList;
 import org.onosproject.yangutils.datamodel.YangList;
 import org.onosproject.yangutils.datamodel.YangModule;
 import org.onosproject.yangutils.datamodel.YangModule;
 import org.onosproject.yangutils.datamodel.YangNode;
 import org.onosproject.yangutils.datamodel.YangNode;
-import org.onosproject.yangutils.datamodel.YangNodeType;
 import org.onosproject.yangutils.datamodel.YangTypeDef;
 import org.onosproject.yangutils.datamodel.YangTypeDef;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.impl.YangUtilsParserManager;
 import org.onosproject.yangutils.parser.impl.YangUtilsParserManager;
 
 
+import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.core.Is.is;
+import static org.onosproject.yangutils.datamodel.ResolvableStatus.INTRA_FILE_RESOLVED;
+import static org.onosproject.yangutils.datamodel.ResolvableStatus.RESOLVED;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.DERIVED;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.INT32;
+import static org.onosproject.yangutils.datamodel.YangDataTypes.STRING;
+import static org.onosproject.yangutils.datamodel.YangNodeType.MODULE_NODE;
 
 
 /**
 /**
  * Test cases for testing "type" intra file linking.
  * Test cases for testing "type" intra file linking.
@@ -56,7 +59,7 @@ public class IntraFileTypeLinkingTest {
         assertThat(node instanceof YangModule, is(true));
         assertThat(node instanceof YangModule, is(true));
 
 
         // Check whether the node type is set properly to module.
         // Check whether the node type is set properly to module.
-        assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
+        assertThat(node.getNodeType(), is(MODULE_NODE));
 
 
         // Check whether the module name is set correctly.
         // Check whether the module name is set correctly.
         YangModule yangNode = (YangModule) node;
         YangModule yangNode = (YangModule) node;
@@ -67,13 +70,23 @@ public class IntraFileTypeLinkingTest {
 
 
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.DERIVED));
+        assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
 
 
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) node.getChild()));
                 is((YangTypeDef) node.getChild()));
 
 
-        assertThat(leafInfo.getDataType().getResolvableStatus(),
-                is(ResolvableStatus.RESOLVED));
+        assertThat(leafInfo.getDataType().getResolvableStatus(), is(RESOLVED));
+
+        YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+
+        // Check for the effective built-in type.
+        assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+
+        // Check for the restriction.
+        assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+        assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
     }
     }
 
 
     /**
     /**
@@ -91,7 +104,7 @@ public class IntraFileTypeLinkingTest {
         assertThat((node instanceof YangModule), is(true));
         assertThat((node instanceof YangModule), is(true));
 
 
         // Check whether the node type is set properly to module.
         // Check whether the node type is set properly to module.
-        assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
+        assertThat(node.getNodeType(), is(MODULE_NODE));
 
 
         // Check whether the module name is set correctly.
         // Check whether the module name is set correctly.
         YangModule yangNode = (YangModule) node;
         YangModule yangNode = (YangModule) node;
@@ -106,13 +119,23 @@ public class IntraFileTypeLinkingTest {
 
 
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.DERIVED));
+        assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
 
 
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) node.getChild()));
                 is((YangTypeDef) node.getChild()));
 
 
-        assertThat(leafInfo.getDataType().getResolvableStatus(),
-                is(ResolvableStatus.RESOLVED));
+        assertThat(leafInfo.getDataType().getResolvableStatus(), is(RESOLVED));
+
+        YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+
+        // Check for the effective built-in type.
+        assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+
+        // Check for the restriction.
+        assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+        assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
     }
     }
 
 
     /**
     /**
@@ -131,7 +154,7 @@ public class IntraFileTypeLinkingTest {
         assertThat((node instanceof YangModule), is(true));
         assertThat((node instanceof YangModule), is(true));
 
 
         // Check whether the node type is set properly to module.
         // Check whether the node type is set properly to module.
-        assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
+        assertThat(node.getNodeType(), is(MODULE_NODE));
 
 
         // Check whether the module name is set correctly.
         // Check whether the module name is set correctly.
         YangModule yangNode = (YangModule) node;
         YangModule yangNode = (YangModule) node;
@@ -146,13 +169,23 @@ public class IntraFileTypeLinkingTest {
 
 
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.DERIVED));
+        assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
 
 
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) node.getChild().getNextSibling()));
                 is((YangTypeDef) node.getChild().getNextSibling()));
 
 
-        assertThat(leafInfo.getDataType().getResolvableStatus(),
-                is(ResolvableStatus.RESOLVED));
+        assertThat(leafInfo.getDataType().getResolvableStatus(), is(RESOLVED));
+
+        YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+
+        // Check for the effective built-in type.
+        assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+
+        // Check for the restriction.
+        assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+        assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
     }
     }
 
 
     /**
     /**
@@ -171,7 +204,7 @@ public class IntraFileTypeLinkingTest {
         assertThat((node instanceof YangModule), is(true));
         assertThat((node instanceof YangModule), is(true));
 
 
         // Check whether the node type is set properly to module.
         // Check whether the node type is set properly to module.
-        assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
+        assertThat(node.getNodeType(), is(MODULE_NODE));
 
 
         // Check whether the module name is set correctly.
         // Check whether the module name is set correctly.
         YangModule yangNode = (YangModule) node;
         YangModule yangNode = (YangModule) node;
@@ -186,13 +219,23 @@ public class IntraFileTypeLinkingTest {
 
 
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.DERIVED));
+        assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
 
 
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) yangContainer.getChild().getNextSibling()));
                 is((YangTypeDef) yangContainer.getChild().getNextSibling()));
 
 
-        assertThat(leafInfo.getDataType().getResolvableStatus(),
-                is(ResolvableStatus.RESOLVED));
+        assertThat(leafInfo.getDataType().getResolvableStatus(), is(RESOLVED));
+
+        YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+
+        // Check for the effective built-in type.
+        assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+
+        // Check for the restriction.
+        assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+        assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
     }
     }
 
 
     /**
     /**
@@ -209,7 +252,7 @@ public class IntraFileTypeLinkingTest {
         assertThat((node instanceof YangModule), is(true));
         assertThat((node instanceof YangModule), is(true));
 
 
         // Check whether the node type is set properly to module.
         // Check whether the node type is set properly to module.
-        assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
+        assertThat(node.getNodeType(), is(MODULE_NODE));
 
 
         // Check whether the module name is set correctly.
         // Check whether the module name is set correctly.
         YangModule yangNode = (YangModule) node;
         YangModule yangNode = (YangModule) node;
@@ -224,26 +267,37 @@ public class IntraFileTypeLinkingTest {
 
 
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("FirstClass"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("FirstClass"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.DERIVED));
+        assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
 
 
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) yangList.getChild()));
                 is((YangTypeDef) yangList.getChild()));
         assertThat(leafInfo.getDataType().getResolvableStatus(),
         assertThat(leafInfo.getDataType().getResolvableStatus(),
-                is(ResolvableStatus.RESOLVED));
+                is(RESOLVED));
 
 
         YangTypeDef typeDef1 = (YangTypeDef) yangList.getChild();
         YangTypeDef typeDef1 = (YangTypeDef) yangList.getChild();
 
 
         assertThat(((YangDerivedInfo<?>) typeDef1.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) typeDef1.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) yangContainer.getChild().getNextSibling()));
                 is((YangTypeDef) yangContainer.getChild().getNextSibling()));
         assertThat(typeDef1.getTypeDefBaseType().getResolvableStatus(),
         assertThat(typeDef1.getTypeDefBaseType().getResolvableStatus(),
-                is(ResolvableStatus.RESOLVED));
+                is(RESOLVED));
 
 
         YangTypeDef typeDef2 = (YangTypeDef) yangContainer.getChild().getNextSibling();
         YangTypeDef typeDef2 = (YangTypeDef) yangContainer.getChild().getNextSibling();
 
 
         assertThat(((YangDerivedInfo<?>) typeDef2.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) typeDef2.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) node.getChild()));
                 is((YangTypeDef) node.getChild()));
         assertThat(typeDef2.getTypeDefBaseType().getResolvableStatus(),
         assertThat(typeDef2.getTypeDefBaseType().getResolvableStatus(),
-                is(ResolvableStatus.RESOLVED));
+                is(RESOLVED));
+
+        YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+
+        // Check for the effective built-in type.
+        assertThat(derivedInfo.getEffectiveBuiltInType(), is(INT32));
+
+        // Check for the restriction.
+        assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+        assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
     }
     }
 
 
     /**
     /**
@@ -261,7 +315,7 @@ public class IntraFileTypeLinkingTest {
         assertThat((node instanceof YangModule), is(true));
         assertThat((node instanceof YangModule), is(true));
 
 
         // Check whether the node type is set properly to module.
         // Check whether the node type is set properly to module.
-        assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
+        assertThat(node.getNodeType(), is(MODULE_NODE));
 
 
         // Check whether the module name is set correctly.
         // Check whether the module name is set correctly.
         YangModule yangNode = (YangModule) node;
         YangModule yangNode = (YangModule) node;
@@ -276,26 +330,37 @@ public class IntraFileTypeLinkingTest {
 
 
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("FirstClass"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("FirstClass"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.DERIVED));
+        assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
 
 
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) yangList.getChild()));
                 is((YangTypeDef) yangList.getChild()));
         assertThat(leafInfo.getDataType().getResolvableStatus(),
         assertThat(leafInfo.getDataType().getResolvableStatus(),
-                is(ResolvableStatus.INTRA_FILE_RESOLVED));
+                is(INTRA_FILE_RESOLVED));
 
 
         YangTypeDef typeDef1 = (YangTypeDef) yangList.getChild();
         YangTypeDef typeDef1 = (YangTypeDef) yangList.getChild();
 
 
         assertThat(((YangDerivedInfo<?>) typeDef1.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) typeDef1.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) yangContainer.getChild().getNextSibling()));
                 is((YangTypeDef) yangContainer.getChild().getNextSibling()));
         assertThat(typeDef1.getTypeDefBaseType().getResolvableStatus(),
         assertThat(typeDef1.getTypeDefBaseType().getResolvableStatus(),
-                is(ResolvableStatus.INTRA_FILE_RESOLVED));
+                is(INTRA_FILE_RESOLVED));
 
 
         YangTypeDef typeDef2 = (YangTypeDef) yangContainer.getChild().getNextSibling();
         YangTypeDef typeDef2 = (YangTypeDef) yangContainer.getChild().getNextSibling();
 
 
         assertThat(((YangDerivedInfo<?>) typeDef2.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) typeDef2.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) node.getChild()));
                 is((YangTypeDef) node.getChild()));
         assertThat(typeDef2.getTypeDefBaseType().getResolvableStatus(),
         assertThat(typeDef2.getTypeDefBaseType().getResolvableStatus(),
-                is(ResolvableStatus.INTRA_FILE_RESOLVED));
+                is(INTRA_FILE_RESOLVED));
+
+        YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+
+        // Check for the effective built-in type.
+        assertThat(derivedInfo.getEffectiveBuiltInType(), is(nullValue()));
+
+        // Check for the restriction.
+        assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+        assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
     }
     }
 
 
     /**
     /**
@@ -312,7 +377,7 @@ public class IntraFileTypeLinkingTest {
         assertThat((node instanceof YangModule), is(true));
         assertThat((node instanceof YangModule), is(true));
 
 
         // Check whether the node type is set properly to module.
         // Check whether the node type is set properly to module.
-        assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
+        assertThat(node.getNodeType(), is(MODULE_NODE));
 
 
         // Check whether the module name is set correctly.
         // Check whether the module name is set correctly.
         YangModule yangNode = (YangModule) node;
         YangModule yangNode = (YangModule) node;
@@ -327,26 +392,37 @@ public class IntraFileTypeLinkingTest {
 
 
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("FirstClass"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("FirstClass"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.DERIVED));
+        assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
 
 
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) yangList.getChild()));
                 is((YangTypeDef) yangList.getChild()));
         assertThat(leafInfo.getDataType().getResolvableStatus(),
         assertThat(leafInfo.getDataType().getResolvableStatus(),
-                is(ResolvableStatus.RESOLVED));
+                is(RESOLVED));
 
 
         YangTypeDef typeDef1 = (YangTypeDef) yangList.getChild();
         YangTypeDef typeDef1 = (YangTypeDef) yangList.getChild();
 
 
         assertThat(((YangDerivedInfo<?>) typeDef1.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) typeDef1.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) yangContainer.getChild().getNextSibling()));
                 is((YangTypeDef) yangContainer.getChild().getNextSibling()));
         assertThat(typeDef1.getTypeDefBaseType().getResolvableStatus(),
         assertThat(typeDef1.getTypeDefBaseType().getResolvableStatus(),
-                is(ResolvableStatus.RESOLVED));
+                is(RESOLVED));
 
 
         YangTypeDef typeDef2 = (YangTypeDef) yangContainer.getChild().getNextSibling();
         YangTypeDef typeDef2 = (YangTypeDef) yangContainer.getChild().getNextSibling();
 
 
         assertThat(((YangDerivedInfo<?>) typeDef2.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) typeDef2.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) node.getChild()));
                 is((YangTypeDef) node.getChild()));
         assertThat(typeDef2.getTypeDefBaseType().getResolvableStatus(),
         assertThat(typeDef2.getTypeDefBaseType().getResolvableStatus(),
-                is(ResolvableStatus.RESOLVED));
+                is(RESOLVED));
+
+        YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+
+        // Check for the effective built-in type.
+        assertThat(derivedInfo.getEffectiveBuiltInType(), is(INT32));
+
+        // Check for the restriction.
+        assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+        assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
     }
     }
 
 
     /**
     /**
@@ -364,7 +440,7 @@ public class IntraFileTypeLinkingTest {
         assertThat((node instanceof YangModule), is(true));
         assertThat((node instanceof YangModule), is(true));
 
 
         // Check whether the node type is set properly to module.
         // Check whether the node type is set properly to module.
-        assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
+        assertThat(node.getNodeType(), is(MODULE_NODE));
 
 
         // Check whether the module name is set correctly.
         // Check whether the module name is set correctly.
         YangModule yangNode = (YangModule) node;
         YangModule yangNode = (YangModule) node;
@@ -379,12 +455,12 @@ public class IntraFileTypeLinkingTest {
 
 
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getName(), is("invalid-interval"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("FirstClass"));
         assertThat(leafInfo.getDataType().getDataTypeName(), is("FirstClass"));
-        assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.DERIVED));
+        assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
 
 
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) yangList.getChild()));
                 is((YangTypeDef) yangList.getChild()));
         assertThat(leafInfo.getDataType().getResolvableStatus(),
         assertThat(leafInfo.getDataType().getResolvableStatus(),
-                is(ResolvableStatus.INTRA_FILE_RESOLVED));
+                is(INTRA_FILE_RESOLVED));
 
 
         YangTypeDef typeDef1 = (YangTypeDef) yangList.getChild();
         YangTypeDef typeDef1 = (YangTypeDef) yangList.getChild();
 
 
@@ -393,7 +469,18 @@ public class IntraFileTypeLinkingTest {
         assertThat(((YangDerivedInfo<?>) typeDef2.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
         assertThat(((YangDerivedInfo<?>) typeDef2.getTypeDefBaseType().getDataTypeExtendedInfo()).getReferredTypeDef(),
                 is((YangTypeDef) node.getChild()));
                 is((YangTypeDef) node.getChild()));
         assertThat(typeDef2.getTypeDefBaseType().getResolvableStatus(),
         assertThat(typeDef2.getTypeDefBaseType().getResolvableStatus(),
-                is(ResolvableStatus.RESOLVED));
+                is(RESOLVED));
+
+        YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+
+        // Check for the effective built-in type.
+        assertThat(derivedInfo.getEffectiveBuiltInType(), is(nullValue()));
+
+        // Check for the restriction.
+        assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
+        assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+        assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
     }
     }
 
 
     /**
     /**

@@ -18,7 +18,6 @@ package org.onosproject.yangutils.linker;
 
 
 import java.io.IOException;
 import java.io.IOException;
 import java.util.ListIterator;
 import java.util.ListIterator;
-
 import org.junit.Rule;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.rules.ExpectedException;
@@ -81,7 +80,7 @@ public class IntraFileUsesLinkingTest {
 
 
         // Check whether the information in the leaf is correct under grouping.
         // Check whether the information in the leaf is correct under grouping.
         assertThat(leafInfo.getName(), is("hello"));
         assertThat(leafInfo.getName(), is("hello"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("String"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
 
 
         // Check whether uses is module's child.
         // Check whether uses is module's child.
@@ -97,7 +96,7 @@ public class IntraFileUsesLinkingTest {
 
 
         // Check whether the information in the leaf is correct under module.
         // Check whether the information in the leaf is correct under module.
         assertThat(leafInfo.getName(), is("hello"));
         assertThat(leafInfo.getName(), is("hello"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("String"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
 
 
     }
     }
@@ -135,7 +134,7 @@ public class IntraFileUsesLinkingTest {
 
 
         // Check whether the information in the leaf is correct under grouping.
         // Check whether the information in the leaf is correct under grouping.
         assertThat(leafInfo.getName(), is("treat"));
         assertThat(leafInfo.getName(), is("treat"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("String"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
 
 
         // Check whether container is the child of grouping.
         // Check whether container is the child of grouping.
@@ -150,7 +149,7 @@ public class IntraFileUsesLinkingTest {
 
 
         // Check whether the information in the leaf is correct under container which is under grouping.
         // Check whether the information in the leaf is correct under container which is under grouping.
         assertThat(leafInfo.getName(), is("leaf2"));
         assertThat(leafInfo.getName(), is("leaf2"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("String"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
 
 
         // Check whether uses is module's child.
         // Check whether uses is module's child.
@@ -166,7 +165,7 @@ public class IntraFileUsesLinkingTest {
 
 
         // Check whether the information in the leaf is correct under module.
         // Check whether the information in the leaf is correct under module.
         assertThat(leafInfo.getName(), is("treat"));
         assertThat(leafInfo.getName(), is("treat"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("String"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
 
 
         // Check whether container is the child of module.
         // Check whether container is the child of module.
@@ -181,7 +180,7 @@ public class IntraFileUsesLinkingTest {
 
 
         // Check whether the information in the leaf is correct under container which is under module.
         // Check whether the information in the leaf is correct under container which is under module.
         assertThat(leafInfo.getName(), is("leaf2"));
         assertThat(leafInfo.getName(), is("leaf2"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("String"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
     }
     }
 
 
@@ -688,7 +687,7 @@ public class IntraFileUsesLinkingTest {
 
 
         // Check whether the information in the leaf is correct under grouping.
         // Check whether the information in the leaf is correct under grouping.
         assertThat(leafInfo.getName(), is("hello"));
         assertThat(leafInfo.getName(), is("hello"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("String"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
 
 
     }
     }
@@ -762,7 +761,7 @@ public class IntraFileUsesLinkingTest {
 
 
         // Check whether the information in the leaf is correct under grouping.
         // Check whether the information in the leaf is correct under grouping.
         assertThat(leafInfo.getName(), is("hello"));
         assertThat(leafInfo.getName(), is("hello"));
-        assertThat(leafInfo.getDataType().getDataTypeName(), is("String"));
+        assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
         assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
     }
     }
 
 

@@ -19,20 +19,18 @@ package org.onosproject.yangutils.parser.impl.listeners;
 import java.io.IOException;
 import java.io.IOException;
 import java.math.BigInteger;
 import java.math.BigInteger;
 import java.util.ListIterator;
 import java.util.ListIterator;
-
 import org.junit.Rule;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.Test;
-
 import org.junit.rules.ExpectedException;
 import org.junit.rules.ExpectedException;
-import org.onosproject.yangutils.datamodel.YangNode;
-import org.onosproject.yangutils.datamodel.YangModule;
-import org.onosproject.yangutils.datamodel.YangNodeType;
+import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.datamodel.YangLeaf;
 import org.onosproject.yangutils.datamodel.YangLeaf;
 import org.onosproject.yangutils.datamodel.YangLeafList;
 import org.onosproject.yangutils.datamodel.YangLeafList;
-import org.onosproject.yangutils.datamodel.YangDataTypes;
-import org.onosproject.yangutils.datamodel.YangStringRestriction;
+import org.onosproject.yangutils.datamodel.YangModule;
+import org.onosproject.yangutils.datamodel.YangNode;
+import org.onosproject.yangutils.datamodel.YangNodeType;
 import org.onosproject.yangutils.datamodel.YangRangeInterval;
 import org.onosproject.yangutils.datamodel.YangRangeInterval;
 import org.onosproject.yangutils.datamodel.YangRangeRestriction;
 import org.onosproject.yangutils.datamodel.YangRangeRestriction;
+import org.onosproject.yangutils.datamodel.YangStringRestriction;
 import org.onosproject.yangutils.datamodel.YangTypeDef;
 import org.onosproject.yangutils.datamodel.YangTypeDef;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.impl.YangUtilsParserManager;
 import org.onosproject.yangutils.parser.impl.YangUtilsParserManager;
@@ -220,7 +218,7 @@ public class LengthRestrictionListenerTest {
     @Test
     @Test
     public void processLengthWithInvalidIntegerPattern() throws IOException, ParserException {
     public void processLengthWithInvalidIntegerPattern() throws IOException, ParserException {
         thrown.expect(ParserException.class);
         thrown.expect(ParserException.class);
-        thrown.expectMessage("YANG file error : a is not valid.");
+        thrown.expectMessage("YANG file error : Input value \"a\" is not a valid uint64.");
         YangNode node = manager.getDataModel("src/test/resources/LengthWithInvalidIntegerPattern.yang");
         YangNode node = manager.getDataModel("src/test/resources/LengthWithInvalidIntegerPattern.yang");
     }
     }
 
 

@@ -18,18 +18,17 @@ package org.onosproject.yangutils.parser.impl.listeners;
 
 
 import java.io.IOException;
 import java.io.IOException;
 import java.util.ListIterator;
 import java.util.ListIterator;
-
 import org.junit.Rule;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.rules.ExpectedException;
-import org.onosproject.yangutils.datamodel.YangNode;
+import org.onosproject.yangutils.datamodel.YangDataTypes;
 import org.onosproject.yangutils.datamodel.YangLeaf;
 import org.onosproject.yangutils.datamodel.YangLeaf;
 import org.onosproject.yangutils.datamodel.YangLeafList;
 import org.onosproject.yangutils.datamodel.YangLeafList;
-import org.onosproject.yangutils.datamodel.YangRangeRestriction;
-import org.onosproject.yangutils.datamodel.YangRangeInterval;
 import org.onosproject.yangutils.datamodel.YangModule;
 import org.onosproject.yangutils.datamodel.YangModule;
+import org.onosproject.yangutils.datamodel.YangNode;
 import org.onosproject.yangutils.datamodel.YangNodeType;
 import org.onosproject.yangutils.datamodel.YangNodeType;
-import org.onosproject.yangutils.datamodel.YangDataTypes;
+import org.onosproject.yangutils.datamodel.YangRangeInterval;
+import org.onosproject.yangutils.datamodel.YangRangeRestriction;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.exceptions.ParserException;
 import org.onosproject.yangutils.parser.impl.YangUtilsParserManager;
 import org.onosproject.yangutils.parser.impl.YangUtilsParserManager;
 import org.onosproject.yangutils.utils.builtindatatype.YangInt32;
 import org.onosproject.yangutils.utils.builtindatatype.YangInt32;
@@ -172,7 +171,7 @@ public class RangeRestrictionListenerTest {
     @Test
     @Test
     public void processRangeWithInvalidIntegerPattern() throws IOException, ParserException {
     public void processRangeWithInvalidIntegerPattern() throws IOException, ParserException {
         thrown.expect(ParserException.class);
         thrown.expect(ParserException.class);
-        thrown.expectMessage("YANG file error : a is not valid.");
+        thrown.expectMessage("YANG file error : Input value \"a\" is not a valid int32.");
         YangNode node = manager.getDataModel("src/test/resources/RangeWithInvalidIntegerPattern.yang");
         YangNode node = manager.getDataModel("src/test/resources/RangeWithInvalidIntegerPattern.yang");
     }
     }
 }
 }

@@ -10,7 +10,7 @@ module Test {
             }
             }
         }
         }
         typedef hello {
         typedef hello {
-            type String;
+            type string;
         }
         }
     }
     }
 }
 }

@@ -11,6 +11,6 @@ module Test {
         }
         }
     }
     }
     typedef hello {
     typedef hello {
-        type String;
+        type string;
     }
     }
 }
 }

@@ -3,7 +3,7 @@ module Test {
     namespace http://huawei.com;
     namespace http://huawei.com;
     prefix Ant;
     prefix Ant;
     typedef hello {
     typedef hello {
-        type String;
+        type string;
     }
     }
     container ospf {
     container ospf {
         list valid {
         list valid {

@@ -7,14 +7,14 @@ module Test {
     }
     }
     grouping Percentage {
     grouping Percentage {
         leaf hello{
         leaf hello{
-            type String;
+            type string;
         }
         }
     }
     }
     container ospf {
     container ospf {
         list valid {
         list valid {
             key "invalid";
             key "invalid";
             leaf invalid{
             leaf invalid{
-                type String;
+                type string;
             }
             }
             uses Ant:FirstClass;
             uses Ant:FirstClass;
             grouping FirstClass {
             grouping FirstClass {

@@ -4,14 +4,14 @@ module Test {
     prefix Ant;
     prefix Ant;
     grouping Percentage {
     grouping Percentage {
         leaf hello{
         leaf hello{
-            type String;
+            type string;
         }
         }
     }
     }
     container ospf {
     container ospf {
         list valid {
         list valid {
             key "invalid";
             key "invalid";
             leaf invalid{
             leaf invalid{
-                type String;
+                type string;
             }
             }
             uses Ant:FirstClass;
             uses Ant:FirstClass;
             grouping FirstClass {
             grouping FirstClass {

@@ -6,6 +6,6 @@ module Test {
         type hello;
         type hello;
     }
     }
     typedef hello {
     typedef hello {
-        type String;
+        type string;
     }
     }
 }
 }

@@ -5,7 +5,7 @@ module Test {
     uses hello;
     uses hello;
     grouping hello {
     grouping hello {
         leaf hello{
         leaf hello{
-            type String;
+            type string;
         }
         }
     }
     }
 }
 }

@@ -5,11 +5,11 @@ module Test {
     uses treat;
     uses treat;
     grouping treat {
     grouping treat {
         leaf treat{
         leaf treat{
-            type String;
+            type string;
         }
         }
         container test{
         container test{
             leaf leaf2{
             leaf leaf2{
-                type String;
+                type string;
             }
             }
         }
         }
     }
     }