[ONOS-6677] Description in pattern statement
Change-Id: Iacdd3ac0cafe6b39eaa4ba463d5c25a72aa50549
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangDecimal64.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangDecimal64.java
index 56ae4f3..d491076 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangDecimal64.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangDecimal64.java
@@ -326,7 +326,7 @@
* @throws DataModelException a violation of data model rules
*/
public YangRangeRestriction getDefaultRangeRestriction() throws DataModelException {
- YangRangeRestriction refRangeRestriction = new YangRangeRestriction();
+ YangRangeRestriction refRangeRestriction = new YangRangeRestriction(null);
YangRangeInterval rangeInterval = new YangRangeInterval<>();
rangeInterval.setCharPosition(getCharPosition());
rangeInterval.setLineNumber(getLineNumber());
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangDerivedInfo.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangDerivedInfo.java
index 88adac0..7b955e5 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangDerivedInfo.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangDerivedInfo.java
@@ -21,12 +21,13 @@
import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
import java.io.Serializable;
+import java.util.LinkedList;
+import java.util.List;
-import static com.google.common.base.Strings.isNullOrEmpty;
import static org.onosproject.yang.compiler.datamodel.exceptions.ErrorMessages.getErrorMsg;
import static org.onosproject.yang.compiler.datamodel.utils.ResolvableStatus.INTRA_FILE_RESOLVED;
import static org.onosproject.yang.compiler.datamodel.utils.ResolvableStatus.RESOLVED;
-import static org.onosproject.yang.compiler.datamodel.utils.RestrictionResolver.processLengthRestriction;
+import static org.onosproject.yang.compiler.datamodel.utils.RestrictionResolver.processLengthRes;
import static org.onosproject.yang.compiler.datamodel.utils.RestrictionResolver.processRangeRestriction;
import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypeUtils.isOfRangeRestrictedType;
import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.BINARY;
@@ -65,22 +66,22 @@
private YangDataTypes effectiveBuiltInType;
/**
- * Length restriction string to temporary store the length restriction when the type
+ * Length restriction string to store the length restriction when the type
* is derived.
*/
- private String lengthRestrictionString;
+ private YangRangeRestriction lengthRes;
/**
- * Range restriction string to temporary store the range restriction when the type
+ * Range restriction string to store the range restriction when the type
* is derived.
*/
- private String rangeRestrictionString;
+ private YangRangeRestriction rangeRes;
/**
- * Pattern restriction string to temporary store the pattern restriction when the type
- * is derived.
+ * Pattern restriction list to store the pattern restriction when the
+ * type is derived.
*/
- private YangPatternRestriction patternRestriction;
+ private List<YangPatternRestriction> patternResList;
/**
* Returns the referred typedef reference.
@@ -110,57 +111,60 @@
}
/**
- * Returns the length restriction string.
+ * Returns the length restriction.
*
- * @return the length restriction string
+ * @return length restriction
*/
- public String getLengthRestrictionString() {
- return lengthRestrictionString;
+ public YangRangeRestriction getLengthRes() {
+ return lengthRes;
}
/**
- * Sets the length restriction string.
+ * Sets the length restriction.
*
- * @param lengthRestrictionString the length restriction string
+ * @param lr length restriction
*/
- public void setLengthRestrictionString(String lengthRestrictionString) {
- this.lengthRestrictionString = lengthRestrictionString;
+ public void setLengthRes(YangRangeRestriction lr) {
+ lengthRes = lr;
}
/**
- * Returns the range restriction string.
+ * Returns the range restriction.
*
- * @return the range restriction string
+ * @return range restriction
*/
- public String getRangeRestrictionString() {
- return rangeRestrictionString;
+ public YangRangeRestriction getRangeRes() {
+ return rangeRes;
}
/**
- * Sets the range restriction string.
+ * Sets the range restriction.
*
- * @param rangeRestrictionString the range restriction string
+ * @param rr range restriction
*/
- public void setRangeRestrictionString(String rangeRestrictionString) {
- this.rangeRestrictionString = rangeRestrictionString;
+ public void setRangeRes(YangRangeRestriction rr) {
+ rangeRes = rr;
}
/**
- * Returns the pattern restriction.
+ * Returns the pattern restriction list.
*
- * @return the pattern restriction
+ * @return pattern restriction list
*/
- public YangPatternRestriction getPatternRestriction() {
- return patternRestriction;
+ public List<YangPatternRestriction> getPatternResList() {
+ return patternResList;
}
/**
- * Sets the pattern restriction.
+ * Adds the pattern to the pattern restriction list.
*
- * @param patternRestriction the pattern restriction
+ * @param pr pattern restriction
*/
- public void setPatternRestriction(YangPatternRestriction patternRestriction) {
- this.patternRestriction = patternRestriction;
+ public void addPatternRes(YangPatternRestriction pr) {
+ if (patternResList == null) {
+ patternResList = new LinkedList<>();
+ }
+ patternResList.add(pr);
}
/**
@@ -219,9 +223,8 @@
* case check whether no self restrictions should be present.
*/
if (effectiveBuiltInType.isNonRestrictedType()) {
- if (isNullOrEmpty(getLengthRestrictionString()) &&
- isNullOrEmpty(getRangeRestrictionString()) &&
- getPatternRestriction() == null) {
+ if (lengthRes == null && rangeRes == null && (
+ patternResList == null || patternResList.isEmpty())) {
return RESOLVED;
} else {
throw new DataModelException(getErrorMsg(
@@ -426,13 +429,13 @@
throws DataModelException {
YangStringRestriction curSr = null;
YangRangeRestriction refRr = null;
- YangPatternRestriction refPr = null;
+ List<YangPatternRestriction> refPr = null;
/*
* Check that range restriction should be null when built-in type is
* string.
*/
- if (!isNullOrEmpty(getRangeRestrictionString())) {
+ if (rangeRes != null) {
throw new DataModelException(getErrorMsg(
"YANG file error: Range restriction should't be present for" +
" string data type.", ".", getLineNumber(),
@@ -443,8 +446,8 @@
* If referred restriction and self restriction both are null, no
* resolution is required.
*/
- if (refSr == null && isNullOrEmpty(getLengthRestrictionString()) &&
- getPatternRestriction() == null) {
+ if (refSr == null && lengthRes == null && (patternResList == null ||
+ patternResList.isEmpty())) {
return;
}
@@ -454,11 +457,11 @@
*/
if (refSr != null) {
refRr = refSr.getLengthRestriction();
- refPr = refSr.getPatternRestriction();
+ refPr = refSr.getPatternResList();
}
YangRangeRestriction lr = resolveLengthRestriction(refRr);
- YangPatternRestriction pr = resolvePatternRestriction(refPr);
+ List<YangPatternRestriction> pr = resolvePatternRestriction(refPr);
/*
* Check if either of length or pattern restriction is present, if yes
@@ -470,7 +473,7 @@
curSr.setFileName(getFileName());
curSr.setLineNumber(getLineNumber());
curSr.setLengthRestriction(lr);
- curSr.setPatternRestriction(pr);
+ curSr.setPatternResList(pr);
}
resolvedExtendedInfo = (T) curSr;
}
@@ -484,10 +487,11 @@
private void resolveBinaryRestriction(YangRangeRestriction refLr)
throws DataModelException {
- if (rangeRestrictionString != null || patternRestriction != null) {
+ if (rangeRes != null || !(patternResList == null ||
+ patternResList.isEmpty())) {
throw new DataModelException(getErrorMsg(
- "YANG file error: for binary range restriction or pattern " +
- "restriction is not allowed.", "type.",
+ "YANG file error: for binary range restriction or " +
+ "pattern restriction is not allowed.", "type.",
getLineNumber(), getCharPosition(), getFileName()));
}
@@ -503,12 +507,13 @@
* @param refPr referred pattern restriction of typedef
* @return resolved pattern restriction
*/
- private YangPatternRestriction resolvePatternRestriction(YangPatternRestriction refPr) {
+ private List<YangPatternRestriction> resolvePatternRestriction(List<YangPatternRestriction> refPr) {
/*
* If referred restriction and self restriction both are null, no
* resolution is required.
*/
- if (refPr == null && getPatternRestriction() == null) {
+ if ((refPr == null || refPr.isEmpty()) && (patternResList == null ||
+ patternResList.isEmpty())) {
return null;
}
@@ -516,7 +521,7 @@
* If self restriction is null, and referred restriction is present
* shallow copy the referred to self.
*/
- if (getPatternRestriction() == null) {
+ if (patternResList == null || patternResList.isEmpty()) {
return refPr;
}
@@ -524,35 +529,35 @@
* If referred restriction is null, and self restriction is present
* carry out self resolution.
*/
- if (refPr == null) {
- return getPatternRestriction();
+ if (refPr == null || refPr.isEmpty()) {
+ return patternResList;
}
/*
* Get patterns of referred type and add it to current pattern
* restrictions.
*/
- for (String pattern : refPr.getPatternList()) {
- getPatternRestriction().addPattern(pattern);
+ for (YangPatternRestriction pattern : refPr) {
+ addPatternRes(pattern);
}
- return getPatternRestriction();
+ return patternResList;
}
/**
* Resolves the length restrictions.
*
- * @param refLenRestriction referred length restriction of typedef
+ * @param refLr referred length restriction of typedef
* @return resolved length restriction
* @throws DataModelException a violation in data model rule
*/
- private YangRangeRestriction resolveLengthRestriction(
- YangRangeRestriction refLenRestriction) throws DataModelException {
+ private YangRangeRestriction resolveLengthRestriction(YangRangeRestriction refLr)
+ throws DataModelException {
/*
* If referred restriction and self restriction both are null, no
* resolution is required.
*/
- if (refLenRestriction == null && isNullOrEmpty(getLengthRestrictionString())) {
+ if (refLr == null && lengthRes == null) {
return null;
}
@@ -560,32 +565,30 @@
* If self restriction is null, and referred restriction is present
* shallow copy the referred to self.
*/
- if (isNullOrEmpty(getLengthRestrictionString())) {
- return refLenRestriction;
+ if (lengthRes == null) {
+ return refLr;
}
/*
* If referred restriction is null, and self restriction is present
* carry out self resolution.
*/
- if (refLenRestriction == null) {
- return processLengthRestriction(
- null, getLineNumber(), getCharPosition(), false,
- getLengthRestrictionString(), getFileName());
+ if (refLr == null) {
+ return processLengthRes(null, getLineNumber(), getCharPosition(),
+ false, lengthRes, getFileName());
}
/*
* 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(refLenRestriction, getLineNumber(),
- getCharPosition(), true,
- getLengthRestrictionString(), getFileName());
+ YangRangeRestriction curLr = processLengthRes(
+ refLr, getLineNumber(), getCharPosition(), true,
+ lengthRes, getFileName());
// Resolve the range with referred typedef's restriction.
- resolveLengthAndRangeRestriction(refLenRestriction, curLengthRestriction);
- return curLengthRestriction;
+ resolveLengthAndRangeRestriction(refLr, curLr);
+ return curLr;
}
/**
@@ -629,19 +632,19 @@
* Check that string restriction should be null when built-in type is of
* range type.
*/
- if (!isNullOrEmpty(getLengthRestrictionString())
- || getPatternRestriction() != null) {
+ if (lengthRes != null || !(patternResList == null ||
+ patternResList.isEmpty())) {
throw new DataModelException(getErrorMsg(
- "YANG file error: Length/Pattern restriction should't be present" +
- " for int/uint/decimal data type.", "type.", getLineNumber(),
- getCharPosition(), getFileName()));
+ "YANG file error: Length/Pattern restriction should't be " +
+ "present for int/uint/decimal data type.", "type.",
+ getLineNumber(), getCharPosition(), getFileName()));
}
/*
* If referred restriction and self restriction both are null, no
* resolution is required.
*/
- if (refRangeRestriction == null && isNullOrEmpty(getRangeRestrictionString())) {
+ if (refRangeRestriction == null && rangeRes == null) {
return;
}
@@ -649,7 +652,7 @@
* If self restriction is null, and referred restriction is present
* shallow copy the referred to self.
*/
- if (isNullOrEmpty(getRangeRestrictionString())) {
+ if (rangeRes == null) {
resolvedExtendedInfo = (T) refRangeRestriction;
return;
}
@@ -661,7 +664,7 @@
if (refRangeRestriction == null) {
YangRangeRestriction curRangeRestriction =
processRangeRestriction(null, getLineNumber(),
- getCharPosition(), false, getRangeRestrictionString(),
+ getCharPosition(), false, rangeRes,
effectiveBuiltInType, getFileName());
resolvedExtendedInfo = (T) curRangeRestriction;
return;
@@ -673,8 +676,7 @@
*/
YangRangeRestriction curRangeRestriction =
processRangeRestriction(refRangeRestriction, getLineNumber(),
- getCharPosition(), true,
- getRangeRestrictionString(),
+ getCharPosition(), true, rangeRes,
effectiveBuiltInType, getFileName());
// Resolve the range with referred typedef's restriction.
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangLengthRestriction.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangLengthRestriction.java
index 797d1a3..cc0f572 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangLengthRestriction.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangLengthRestriction.java
@@ -100,7 +100,7 @@
* Creates a YANG length restriction object.
*/
public YangLengthRestriction() {
- setLengthRestriction(new YangRangeRestriction<>());
+ setLengthRestriction(new YangRangeRestriction<>(null));
yangAppErrorInfo = new YangAppErrorInfo();
}
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangPatternRestriction.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangPatternRestriction.java
index 3e0363b..dbccae4 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangPatternRestriction.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangPatternRestriction.java
@@ -16,11 +16,13 @@
package org.onosproject.yang.compiler.datamodel;
-import java.io.Serializable;
-import java.util.LinkedList;
-import java.util.List;
+import org.onosproject.yang.compiler.datamodel.exceptions.DataModelException;
+import org.onosproject.yang.compiler.datamodel.utils.Parsable;
+import org.onosproject.yang.compiler.datamodel.utils.YangConstructType;
-import static java.util.Collections.unmodifiableList;
+import java.io.Serializable;
+
+import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.PATTERN_DATA;
/*-
* Reference RFC 6020.
@@ -55,14 +57,15 @@
* data type.
*/
public class YangPatternRestriction extends DefaultLocationInfo
- implements Serializable, YangAppErrorHolder {
+ implements Serializable, YangAppErrorHolder, YangReference, YangDesc,
+ Parsable {
private static final long serialVersionUID = 806201649L;
/**
- * Pattern restriction defined for the current type.
+ * Pattern restriction.
*/
- private final List<String> patternList;
+ private final String pattern;
/**
* YANG application error information.
@@ -70,29 +73,37 @@
private YangAppErrorInfo yangAppErrorInfo;
/**
- * Creates a YANG pattern restriction object.
+ * Textual reference.
*/
- public YangPatternRestriction() {
- patternList = new LinkedList<>();
+ private String reference;
+
+ /**
+ * Textual description.
+ */
+ private String description;
+
+ /**
+ * Creates a YANG pattern restriction object.
+ *
+ * @param p pattern
+ */
+ public YangPatternRestriction(String p) {
+ pattern = p;
yangAppErrorInfo = new YangAppErrorInfo();
}
/**
* Returns the pattern restriction defined for the current type.
*
- * @return pattern restriction defined for the current type.
+ * @return pattern restriction
*/
- public List<String> getPatternList() {
- return unmodifiableList(patternList);
+ public String getPattern() {
+ return pattern;
}
- /**
- * Adds a new pattern to the list of pattern restriction.
- *
- * @param newPattern pattern restriction.
- */
- public void addPattern(String newPattern) {
- patternList.add(newPattern);
+ @Override
+ public YangAppErrorInfo getAppErrorInfo() {
+ return yangAppErrorInfo;
}
@Override
@@ -101,7 +112,37 @@
}
@Override
- public YangAppErrorInfo getAppErrorInfo() {
- return yangAppErrorInfo;
+ public String getDescription() {
+ return description;
+ }
+
+ @Override
+ public void setDescription(String d) {
+ description = d;
+ }
+
+ @Override
+ public String getReference() {
+ return reference;
+ }
+
+ @Override
+ public void setReference(String r) {
+ reference = r;
+ }
+
+ @Override
+ public YangConstructType getYangConstructType() {
+ return PATTERN_DATA;
+ }
+
+ @Override
+ public void validateDataOnEntry() throws DataModelException {
+ // TODO auto-generated method stub
+ }
+
+ @Override
+ public void validateDataOnExit() throws DataModelException {
+ // TODO auto-generated method stub
}
}
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangRangeRestriction.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangRangeRestriction.java
index f9f0da7..b0f9270 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangRangeRestriction.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangRangeRestriction.java
@@ -89,9 +89,21 @@
private YangAppErrorInfo yangAppErrorInfo;
/**
+ * Range value in YANG file.
+ */
+ private String rangeValue;
+
+ /**
* Creates YANG range restriction object.
*/
- public YangRangeRestriction() {
+
+ /**
+ * Creates YANG range restriction object with range value.
+ *
+ * @param r range value
+ */
+ public YangRangeRestriction(String r) {
+ rangeValue = r;
yangAppErrorInfo = new YangAppErrorInfo();
}
@@ -305,4 +317,13 @@
public YangAppErrorInfo getAppErrorInfo() {
return yangAppErrorInfo;
}
+
+ /**
+ * Returns the range value.
+ *
+ * @return range value
+ */
+ public String getRangeValue() {
+ return rangeValue;
+ }
}
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangStringRestriction.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangStringRestriction.java
index 1934e8d..8b643df 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangStringRestriction.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/YangStringRestriction.java
@@ -16,17 +16,14 @@
package org.onosproject.yang.compiler.datamodel;
-import org.onosproject.yang.compiler.datamodel.exceptions.DataModelException;
-import org.onosproject.yang.compiler.datamodel.utils.Parsable;
-import org.onosproject.yang.compiler.datamodel.utils.YangConstructType;
import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangUint64;
import java.io.Serializable;
import java.math.BigInteger;
+import java.util.LinkedList;
+import java.util.List;
import java.util.ListIterator;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.PATTERN_DATA;
-
/*-
* Reference RFC 6020.
*
@@ -38,7 +35,7 @@
* Represents the restriction for string data type.
*/
public class YangStringRestriction extends DefaultLocationInfo
- implements YangDesc, YangReference, Parsable, Serializable {
+ implements YangDesc, YangReference, Serializable {
/*-
* Reference RFC 6020.
@@ -84,9 +81,9 @@
private YangRangeRestriction<YangUint64> lengthRestriction;
/**
- * Effective pattern restriction for the type.
+ * Effective pattern restriction list for the type.
*/
- private YangPatternRestriction patternRestriction;
+ private List<YangPatternRestriction> patternResList;
/**
* Textual reference.
@@ -123,33 +120,33 @@
}
/**
- * Returns the pattern restriction for the type.
+ * Returns the pattern restriction list for the type.
*
- * @return pattern restriction for the type
+ * @return pattern restriction list
*/
- public YangPatternRestriction getPatternRestriction() {
- return patternRestriction;
+ public List<YangPatternRestriction> getPatternResList() {
+ return patternResList;
}
/**
- * Sets the pattern restriction for the type.
+ * Sets the pattern restriction list for the type.
*
- * @param rest pattern restriction for the type
+ * @param restList pattern restriction list
*/
- void setPatternRestriction(YangPatternRestriction rest) {
- patternRestriction = rest;
+ void setPatternResList(List<YangPatternRestriction> restList) {
+ patternResList = restList;
}
/**
* Adds a new pattern restriction for the type.
*
- * @param newPattern new pattern restriction for the type
+ * @param patRes pattern restriction
*/
- public void addPattern(String newPattern) {
- if (patternRestriction == null) {
- patternRestriction = new YangPatternRestriction();
+ public void addPaternRes(YangPatternRestriction patRes) {
+ if (patternResList == null) {
+ patternResList = new LinkedList<>();
}
- patternRestriction.addPattern(newPattern);
+ patternResList.add(patRes);
}
/**
@@ -193,11 +190,6 @@
}
- @Override
- public YangConstructType getYangConstructType() {
- return PATTERN_DATA;
- }
-
/**
* Validates if the given value is correct as per the length restriction.
*
@@ -235,34 +227,23 @@
* Validates if the given value is correct as per the pattern restriction.
*
* @param valueInString value
- * @return true, if the value is confirming to pattern restriction, false otherwise
+ * @return true if the value is confirming to pattern restriction; false
+ * otherwise
*/
boolean isValidStringOnPatternRestriction(String valueInString) {
- if (patternRestriction == null
- || patternRestriction.getPatternList().isEmpty()) {
+ if (patternResList == null || patternResList.isEmpty()) {
// Pattern restriction is optional
return true;
}
- ListIterator<String> patternListIterator =
- patternRestriction.getPatternList().listIterator();
+ ListIterator<YangPatternRestriction> it = patternResList.listIterator();
boolean isMatched = false;
- while (patternListIterator.hasNext()) {
- if (valueInString.matches(patternListIterator.next())) {
+ while (it.hasNext()) {
+ if (valueInString.matches(it.next().getPattern())) {
isMatched = true;
break;
}
}
return isMatched;
}
-
- @Override
- public void validateDataOnEntry() throws DataModelException {
- // TODO: implement the method.
- }
-
- @Override
- public void validateDataOnExit() throws DataModelException {
- // TODO: implement the method.
- }
}
diff --git a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/utils/RestrictionResolver.java b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/utils/RestrictionResolver.java
index bed39cd..c3f91c1 100644
--- a/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/utils/RestrictionResolver.java
+++ b/compiler/base/datamodel/src/main/java/org/onosproject/yang/compiler/datamodel/utils/RestrictionResolver.java
@@ -59,36 +59,42 @@
* @param line error line number
* @param position error character position in line
* @param hasRefR whether has referred restriction
- * @param curRange caller type's range string
+ * @param curRr caller type's range restriction
* @param type effective type, when called from linker
* @param fileName file name
* @return YANG range restriction
* @throws DataModelException a violation in data model rule
*/
- public static YangRangeRestriction processRangeRestriction(
- YangRangeRestriction refRr, int line, int position,
- boolean hasRefR, String curRange, YangDataTypes type, String fileName)
+ public static YangRangeRestriction processRangeRestriction(YangRangeRestriction refRr,
+ int line, int position,
+ boolean hasRefR,
+ YangRangeRestriction curRr,
+ YangDataTypes type,
+ String fileName)
throws DataModelException {
- return getRestriction(refRr, line, position, hasRefR, curRange, fileName,
+ return getRestriction(refRr, line, position, hasRefR, curRr, fileName,
type, RANGE_DATA);
}
/**
* Processes the length restriction for parser and linker.
*
- * @param refLr length restriction of referred typedef
- * @param line error line number
- * @param position error character position in line
- * @param hasRefR whether has referred restriction
- * @param curLenStr caller type's length string
- * @param fileName file name
+ * @param refLr length restriction of referred typedef
+ * @param line error line number
+ * @param position error character position in line
+ * @param hasRefR whether has referred restriction
+ * @param curLr caller type's length restriction
+ * @param fileName file name
* @return YANG range restriction
* @throws DataModelException a violation in data model rule
*/
- public static YangRangeRestriction processLengthRestriction(
- YangRangeRestriction refLr, int line, int position, boolean hasRefR,
- String curLenStr, String fileName) throws DataModelException {
- return getRestriction(refLr, line, position, hasRefR, curLenStr, fileName,
+ public static YangRangeRestriction processLengthRes(YangRangeRestriction refLr,
+ int line, int position,
+ boolean hasRefR,
+ YangRangeRestriction curLr,
+ String fileName)
+ throws DataModelException {
+ return getRestriction(refLr, line, position, hasRefR, curLr, fileName,
UINT64, LENGTH_DATA);
}
@@ -99,23 +105,24 @@
* @param line error line number
* @param position error character position in line
* @param hasRefR whether has referred restriction
- * @param curRange caller type's range string
+ * @param curR caller type's range restriction
* @param type effective type, when called from linker
* @param fileName file name
* @param conType construct type
* @return YANG range restriction
* @throws DataModelException a violation in data model rule
*/
- private static YangRangeRestriction getRestriction(
- YangRangeRestriction refR, int line, int position, boolean hasRefR,
- String curRange, String fileName, YangDataTypes type,
- YangConstructType conType) throws
- DataModelException {
+ private static YangRangeRestriction getRestriction(YangRangeRestriction refR,
+ int line, int position,
+ boolean hasRefR,
+ YangRangeRestriction curR,
+ String fileName, YangDataTypes type,
+ YangConstructType conType)
+ throws DataModelException {
YangBuiltInDataTypeInfo<?> startValue;
YangBuiltInDataTypeInfo<?> endValue;
- YangRangeRestriction rr = new YangRangeRestriction();
- String rangeArg = removeQuotesAndHandleConcat(curRange);
+ String rangeArg = removeQuotesAndHandleConcat(curR.getRangeValue());
String[] rangeArguments = rangeArg.trim().split(quote(PIPE));
for (String rangePart : rangeArguments) {
@@ -174,7 +181,7 @@
rangeInterval.setStartValue(startValue);
rangeInterval.setEndValue(endValue);
try {
- rr.addRangeRestrictionInterval(rangeInterval);
+ curR.addRangeRestrictionInterval(rangeInterval);
} catch (DataModelException ex) {
ex.setLine(line);
ex.setCharPosition(position);
@@ -182,7 +189,7 @@
throw ex;
}
}
- return rr;
+ return curR;
}
/**
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListener.java
index ec20614..e1fd462 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListener.java
@@ -22,14 +22,14 @@
import org.onosproject.yang.compiler.datamodel.YangType;
import org.onosproject.yang.compiler.datamodel.exceptions.DataModelException;
import org.onosproject.yang.compiler.datamodel.utils.Parsable;
-import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser;
+import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
+import org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.LengthStatementContext;
import org.onosproject.yang.compiler.parser.exceptions.ParserException;
import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
-import static org.onosproject.yang.compiler.datamodel.utils.RestrictionResolver.processLengthRestriction;
+import static org.onosproject.yang.compiler.datamodel.utils.RestrictionResolver.processLengthRes;
import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.LENGTH_DATA;
import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.TYPE_DATA;
-import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.getYangConstructType;
import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.BINARY;
import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.DERIVED;
import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.STRING;
@@ -57,8 +57,8 @@
*
*
* ANTLR grammar rule
- * lengthStatement : LENGTH_KEYWORD length
- * (STMTEND | LEFT_CURLY_BRACE commonStatements RIGHT_CURLY_BRACE);
+ * lengthStatement : LENGTH_KEYWORD length (STMTEND | LEFT_CURLY_BRACE
+ * commonStatements RIGHT_CURLY_BRACE);
*/
/**
@@ -67,6 +67,10 @@
*/
public final class LengthRestrictionListener {
+ private static final String E_INVALID_TYPE = "YANG file error : Length can" +
+ " only be used to restrict the built-in type string/binary or " +
+ "types derived from string/binary.";
+
/**
* Creates a new length restriction listener.
*/
@@ -74,114 +78,115 @@
}
/**
- * It is called when parser receives an input matching the grammar
- * rule (length), performs validation and updates the data model
- * tree.
+ * Processes pattern restriction, when parser receives an input matching
+ * the grammar rule (length), performs validation and updates the data
+ * model tree.
*
- * @param listener listener's object
- * @param ctx context object of the grammar rule
+ * @param lis listener object
+ * @param ctx context object
*/
- public static void processLengthRestrictionEntry(TreeWalkListener listener,
- GeneratedYangParser.LengthStatementContext ctx) {
+ public static void processLengthRestrictionEntry(TreeWalkListener lis,
+ LengthStatementContext ctx) {
// Check for stack to be non empty.
- checkStackIsNotEmpty(listener, MISSING_HOLDER, LENGTH_DATA, ctx.length().getText(), ENTRY);
+ checkStackIsNotEmpty(lis, MISSING_HOLDER, LENGTH_DATA,
+ ctx.length().getText(), ENTRY);
- Parsable tmpData = listener.getParsedDataStack().peek();
+ Parsable tmpData = lis.getParsedDataStack().peek();
if (tmpData.getYangConstructType() == TYPE_DATA) {
YangType type = (YangType) tmpData;
- setLengthRestriction(listener, type, ctx);
+ setLengthRestriction(lis, type, ctx);
} else {
- throw new ParserException(constructListenerErrorMessage(INVALID_HOLDER, LENGTH_DATA,
- ctx.length().getText(), ENTRY));
+ throw new ParserException(constructListenerErrorMessage(
+ INVALID_HOLDER, LENGTH_DATA,
+ ctx.length().getText(), ENTRY));
}
}
/**
* Sets the length restriction to type.
*
- * @param listener listener's object
- * @param type Yang type for which length restriction to be set
- * @param ctx context object of the grammar rule
+ * @param lis listener object
+ * @param type YANG type
+ * @param ctx context object
*/
- private static void setLengthRestriction(TreeWalkListener listener, YangType type,
- GeneratedYangParser.LengthStatementContext ctx) {
+ private static void setLengthRestriction(TreeWalkListener lis,
+ YangType type,
+ LengthStatementContext ctx) {
- if (type.getDataType() == DERIVED) {
- ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
- .setLengthRestrictionString(ctx.length().getText());
- ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
- .setLineNumber(ctx.getStart().getLine());
- ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
- .setCharPosition(ctx.getStart().getCharPositionInLine());
+ int line = ctx.getStart().getLine();
+ int pos = ctx.getStart().getCharPositionInLine();
+ String txt = ctx.length().getText();
+ YangDataTypes dataType = type.getDataType();
+
+ YangRangeRestriction lenRes = new YangRangeRestriction(txt);
+ lenRes.setFileName(lis.getFileName());
+ lenRes.setCharPosition(pos);
+ lenRes.setLineNumber(line);
+ lis.getParsedDataStack().push(lenRes);
+
+ if (dataType == DERIVED) {
+ YangDerivedInfo info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
+ info.setLengthRes(lenRes);
+ info.setFileName(lis.getFileName());
+ info.setCharPosition(pos);
+ info.setLineNumber(line);
return;
}
- if (type.getDataType() != STRING && type.getDataType() != BINARY) {
- ParserException parserException =
- new ParserException(
- "YANG file error : " +
- getYangConstructType(LENGTH_DATA) +
- " name " + ctx.length().getText() +
- " can be used to restrict the built-in type string/binary" +
- " or types derived from string/binary.");
- parserException.setLine(ctx.getStart().getLine());
- parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
- throw parserException;
+ if (dataType != STRING && dataType != BINARY) {
+ ParserException exc = new ParserException(E_INVALID_TYPE);
+ exc.setLine(line);
+ exc.setCharPosition(pos);
+ throw exc;
}
-
- YangRangeRestriction lengthRestriction = null;
try {
- lengthRestriction = processLengthRestriction(null, ctx.getStart().getLine(),
- ctx.getStart().getCharPositionInLine(), false,
- ctx.length().getText(), listener.getFileName());
+ lenRes = processLengthRes(null, line, pos, false, lenRes,
+ lis.getFileName());
} catch (DataModelException e) {
- ParserException parserException = new ParserException(e.getMessage());
- parserException.setCharPosition(e.getCharPositionInLine());
- parserException.setLine(e.getLineNumber());
- throw parserException;
+ ParserException exc = new ParserException(e.getMessage());
+ exc.setCharPosition(e.getCharPositionInLine());
+ exc.setLine(e.getLineNumber());
+ throw exc;
}
- if (type.getDataType() == STRING) {
- YangStringRestriction stringRestriction = (YangStringRestriction) type.getDataTypeExtendedInfo();
- if (stringRestriction == null) {
- stringRestriction = new YangStringRestriction();
- stringRestriction.setFileName(listener.getFileName());
- stringRestriction.setCharPosition(ctx.getStart().getCharPositionInLine());
- stringRestriction.setLineNumber(ctx.getStart().getLine());
- type.setDataTypeExtendedInfo(stringRestriction);
+ if (dataType == STRING) {
+ YangStringRestriction strRes = (YangStringRestriction) type
+ .getDataTypeExtendedInfo();
+ if (strRes == null) {
+ strRes = new YangStringRestriction();
+ strRes.setFileName(lis.getFileName());
+ strRes.setCharPosition(ctx.getStart().getCharPositionInLine());
+ strRes.setLineNumber(ctx.getStart().getLine());
+ type.setDataTypeExtendedInfo(strRes);
}
-
- stringRestriction.setLengthRestriction(lengthRestriction);
+ strRes.setLengthRestriction(lenRes);
} else {
- type.setDataTypeExtendedInfo(lengthRestriction);
+ type.setDataTypeExtendedInfo(lenRes);
}
-
- listener.getParsedDataStack().push(lengthRestriction);
}
/**
* Performs validation and updates the data model tree.
* It is called when parser exits from grammar rule (length).
*
- * @param listener listener's object
- * @param ctx context object of the grammar rule
+ * @param lis listener object
+ * @param ctx context object
*/
- public static void processLengthRestrictionExit(TreeWalkListener listener,
- GeneratedYangParser.LengthStatementContext ctx) {
+ public static void processLengthRestrictionExit(TreeWalkListener lis,
+ LengthStatementContext ctx) {
+
+ String txt = ctx.length().getText();
// Check for stack to be non empty.
- checkStackIsNotEmpty(listener, MISSING_HOLDER, LENGTH_DATA, ctx.length().getText(), EXIT);
+ checkStackIsNotEmpty(lis, MISSING_HOLDER, LENGTH_DATA, txt, EXIT);
- Parsable tmpData = listener.getParsedDataStack().peek();
- if (tmpData instanceof YangRangeRestriction) {
- listener.getParsedDataStack().pop();
- } else if (tmpData instanceof YangType
- && ((YangType) tmpData).getDataType() == DERIVED) {
- // TODO : need to handle in linker
- } else {
- throw new ParserException(constructListenerErrorMessage(MISSING_CURRENT_HOLDER, LENGTH_DATA,
- ctx.length().getText(), EXIT));
+ Parsable tmpData = lis.getParsedDataStack().peek();
+ if (!(tmpData instanceof YangRangeRestriction)) {
+ throw new ParserException(constructListenerErrorMessage(
+ MISSING_CURRENT_HOLDER, LENGTH_DATA, txt, EXIT));
}
+ lis.getParsedDataStack().pop();
}
}
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListener.java
index 65db33f..4fdc648 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListener.java
@@ -22,7 +22,6 @@
import org.onosproject.yang.compiler.datamodel.YangStringRestriction;
import org.onosproject.yang.compiler.datamodel.YangType;
import org.onosproject.yang.compiler.datamodel.utils.Parsable;
-import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
import org.onosproject.yang.compiler.parser.exceptions.ParserException;
import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
@@ -34,6 +33,7 @@
import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.TYPE_DATA;
import static org.onosproject.yang.compiler.datamodel.utils.YangConstructType.getYangConstructType;
import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.DERIVED;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.STRING;
import static org.onosproject.yang.compiler.parser.antlrgencode.GeneratedYangParser.PatternStatementContext;
import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.ENTRY;
import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorLocation.EXIT;
@@ -42,6 +42,7 @@
import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_CURRENT_HOLDER;
import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerErrorType.MISSING_HOLDER;
import static org.onosproject.yang.compiler.parser.impl.parserutils.ListenerValidation.checkStackIsNotEmpty;
+import static org.onosproject.yang.compiler.utils.UtilConstants.EMPTY_STRING;
/*
* Reference: RFC6020 and YANG ANTLR Grammar
@@ -58,7 +59,8 @@
* "}")
*
* ANTLR grammar rule
- * patternStatement : PATTERN_KEYWORD string (STMTEND | LEFT_CURLY_BRACE commonStatements RIGHT_CURLY_BRACE);
+ * patternStatement : PATTERN_KEYWORD string (STMTEND |
+ * LEFT_CURLY_BRACE commonStatements RIGHT_CURLY_BRACE);
*/
/**
@@ -67,7 +69,9 @@
*/
public final class PatternRestrictionListener {
- private static final String EMPTY_STRING = "";
+ private static final String E_INVALID_TYPE = "YANG file error : Pattern " +
+ "can only be used to restrict the built-in type string or types" +
+ " derived from string.";
/**
* Creates a new pattern restriction listener.
@@ -76,128 +80,123 @@
}
/**
- * It is called when parser receives an input matching the grammar
- * rule (pattern), performs validation and updates the data model
- * tree.
+ * Processes pattern restriction, when parser receives an input matching
+ * the grammar rule (pattern), performs validation and updates the data
+ * model tree.
*
- * @param listener listener's object
- * @param ctx context object of the grammar rule
+ * @param lis listener object
+ * @param ctx context object
*/
- public static void processPatternRestrictionEntry(TreeWalkListener listener,
+ public static void processPatternRestrictionEntry(TreeWalkListener lis,
PatternStatementContext ctx) {
// Check for stack to be non empty.
- checkStackIsNotEmpty(listener, MISSING_HOLDER, PATTERN_DATA, ctx.string().getText(), ENTRY);
+ checkStackIsNotEmpty(lis, MISSING_HOLDER, PATTERN_DATA,
+ ctx.string().getText(), ENTRY);
- Parsable tmpData = listener.getParsedDataStack().peek();
+ Parsable tmpData = lis.getParsedDataStack().peek();
if (tmpData.getYangConstructType() == TYPE_DATA) {
YangType type = (YangType) tmpData;
- setPatternRestriction(listener, type, ctx);
+ setPatternRestriction(lis, type, ctx);
} else {
- throw new ParserException(constructListenerErrorMessage(INVALID_HOLDER, PATTERN_DATA,
- ctx.string().getText(), ENTRY));
+ throw new ParserException(constructListenerErrorMessage(
+ INVALID_HOLDER, PATTERN_DATA,
+ ctx.string().getText(), ENTRY));
}
}
/**
* Sets the pattern restriction to type.
*
- * @param listener listener's object
- * @param type Yang type for which pattern restriction to be set
- * @param ctx context object of the grammar rule
+ * @param lis listener object
+ * @param type YANG type
+ * @param ctx context object
*/
- private static void setPatternRestriction(TreeWalkListener listener, YangType type,
+ private static void setPatternRestriction(TreeWalkListener lis,
+ YangType type,
PatternStatementContext ctx) {
- if (type.getDataType() != YangDataTypes.STRING && type.getDataType() != YangDataTypes.DERIVED) {
-
- ParserException parserException =
- new ParserException("YANG file error : " + getYangConstructType(PATTERN_DATA) + " name " +
- ctx.string().getText() + " can be used to restrict the built-in " +
- "type string or types derived from string.");
- parserException.setLine(ctx.getStart().getLine());
- parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
- throw parserException;
+ if (type.getDataType() != STRING && type.getDataType() != DERIVED) {
+ ParserException exc = new ParserException(E_INVALID_TYPE);
+ exc.setLine(ctx.getStart().getLine());
+ exc.setCharPosition(ctx.getStart().getCharPositionInLine());
+ throw exc;
}
// Validate and get valid pattern restriction string.
- String patternArgument = getValidPattern(ctx);
+ String pattern = getValidPattern(ctx);
- if (type.getDataType() == YangDataTypes.STRING) {
- YangStringRestriction stringRestriction = (YangStringRestriction) type.getDataTypeExtendedInfo();
- if (stringRestriction == null) {
- stringRestriction = new YangStringRestriction();
- stringRestriction.setFileName(listener.getFileName());
- stringRestriction.setCharPosition(ctx.getStart().getCharPositionInLine());
- stringRestriction.setLineNumber(ctx.getStart().getLine());
- type.setDataTypeExtendedInfo(stringRestriction);
- stringRestriction.addPattern(patternArgument);
- } else {
- stringRestriction.addPattern(patternArgument);
+ YangPatternRestriction patRes = new YangPatternRestriction(pattern);
+ patRes.setFileName(lis.getFileName());
+ patRes.setCharPosition(ctx.getStart().getCharPositionInLine());
+ patRes.setLineNumber(ctx.getStart().getLine());
+
+ if (type.getDataType() == STRING) {
+ YangStringRestriction strRes = (YangStringRestriction) type
+ .getDataTypeExtendedInfo();
+ if (strRes == null) {
+ strRes = new YangStringRestriction();
+ strRes.setFileName(lis.getFileName());
+ strRes.setCharPosition(ctx.getStart().getCharPositionInLine());
+ strRes.setLineNumber(ctx.getStart().getLine());
+ type.setDataTypeExtendedInfo(strRes);
}
- listener.getParsedDataStack().push(stringRestriction);
+ strRes.addPaternRes(patRes);
} else {
- YangPatternRestriction patternRestriction = ((YangDerivedInfo<?>) type
- .getDataTypeExtendedInfo()).getPatternRestriction();
- if (patternRestriction == null) {
- patternRestriction = new YangPatternRestriction();
- ((YangDerivedInfo<?>) type.getDataTypeExtendedInfo()).setPatternRestriction(patternRestriction);
- patternRestriction.addPattern(patternArgument);
- } else {
- ((YangDerivedInfo<?>) type.getDataTypeExtendedInfo()).setPatternRestriction(patternRestriction);
- patternRestriction.addPattern(patternArgument);
- }
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
+ info.addPatternRes(patRes);
}
+ lis.getParsedDataStack().push(patRes);
}
/**
* Performs validation and updates the data model tree.
* It is called when parser exits from grammar rule (pattern).
*
- * @param listener listener's object
- * @param ctx context object of the grammar rule
+ * @param listener listener object
+ * @param ctx context object
*/
public static void processPatternRestrictionExit(TreeWalkListener listener,
PatternStatementContext ctx) {
+ String txt = ctx.string().getText();
+
// Check for stack to be non empty.
- checkStackIsNotEmpty(listener, MISSING_HOLDER, PATTERN_DATA, ctx.string().getText(), EXIT);
+ checkStackIsNotEmpty(listener, MISSING_HOLDER, PATTERN_DATA, txt, EXIT);
Parsable tmpData = listener.getParsedDataStack().peek();
- if (tmpData instanceof YangStringRestriction) {
- listener.getParsedDataStack().pop();
- } else if (tmpData instanceof YangType
- && ((YangType) tmpData).getDataType() == DERIVED) {
- // TODO : need to handle in linker
- } else {
- throw new ParserException(constructListenerErrorMessage(MISSING_CURRENT_HOLDER, PATTERN_DATA,
- ctx.string().getText(), EXIT));
+ if (!(tmpData instanceof YangPatternRestriction)) {
+ throw new ParserException(constructListenerErrorMessage(
+ MISSING_CURRENT_HOLDER, PATTERN_DATA, txt, EXIT));
}
+ listener.getParsedDataStack().pop();
}
/**
* Validates and return the valid pattern.
*
- * @param ctx context object of the grammar rule
+ * @param ctx context object
* @return validated string
*/
private static String getValidPattern(PatternStatementContext ctx) {
List<TerminalNode> patternList = ctx.string().STRING();
- StringBuilder userInputPattern = new StringBuilder();
+ StringBuilder inputPat = new StringBuilder();
String compile;
for (TerminalNode pattern : patternList) {
- userInputPattern.append(pattern.getText());
+ inputPat.append(pattern.getText());
}
- compile = userInputPattern.toString().replaceAll("[\'\"]", EMPTY_STRING);
+ compile = inputPat.toString().replaceAll("[\'\"]", EMPTY_STRING);
try {
Pattern.compile(compile);
- } catch (PatternSyntaxException exception) {
- ParserException parserException =
- new ParserException("YANG file error : " + getYangConstructType(PATTERN_DATA) + " name " +
- ctx.string().getText() + " is not a valid regular expression");
- parserException.setLine(ctx.getStart().getLine());
- parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
- throw parserException;
+ } catch (PatternSyntaxException e) {
+ ParserException exc = new ParserException(
+ "YANG file error : " + getYangConstructType(PATTERN_DATA)
+ + " name " + ctx.string().getText()
+ + " is not a valid regular expression");
+ exc.setLine(ctx.getStart().getLine());
+ exc.setCharPosition(ctx.getStart().getCharPositionInLine());
+ throw exc;
}
return compile;
}
diff --git a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListener.java b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListener.java
index 418482f..9eb2597 100644
--- a/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListener.java
+++ b/compiler/base/parser/src/main/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListener.java
@@ -22,6 +22,7 @@
import org.onosproject.yang.compiler.datamodel.YangType;
import org.onosproject.yang.compiler.datamodel.exceptions.DataModelException;
import org.onosproject.yang.compiler.datamodel.utils.Parsable;
+import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
import org.onosproject.yang.compiler.parser.exceptions.ParserException;
import org.onosproject.yang.compiler.parser.impl.TreeWalkListener;
@@ -55,7 +56,8 @@
* "}")
*
* ANTLR grammar rule
- * rangeStatement : RANGE_KEYWORD range (STMTEND | LEFT_CURLY_BRACE commonStatements RIGHT_CURLY_BRACE);
+ * rangeStatement : RANGE_KEYWORD range (STMTEND | LEFT_CURLY_BRACE
+ * commonStatements RIGHT_CURLY_BRACE);
*/
/**
@@ -64,6 +66,9 @@
*/
public final class RangeRestrictionListener {
+ private static final String E_INVALID_TYPE = "YANG file error: Range " +
+ "restriction can't be applied to a given type";
+
/**
* Creates a new range restriction listener.
*/
@@ -71,116 +76,115 @@
}
/**
- * It is called when parser receives an input matching the grammar
- * rule (range), performs validation and updates the data model
+ * Processes pattern restriction, when parser receives an input matching
+ * the grammar rule (range), performs validation and updates the data model
* tree.
*
- * @param listener listener's object
- * @param ctx context object of the grammar rule
+ * @param lis listener object
+ * @param ctx context object
*/
- public static void processRangeRestrictionEntry(TreeWalkListener listener,
+ public static void processRangeRestrictionEntry(TreeWalkListener lis,
RangeStatementContext ctx) {
// Check for stack to be non empty.
- checkStackIsNotEmpty(listener, MISSING_HOLDER, RANGE_DATA, ctx.range().getText(), ENTRY);
+ checkStackIsNotEmpty(lis, MISSING_HOLDER, RANGE_DATA,
+ ctx.range().getText(), ENTRY);
- Parsable tmpData = listener.getParsedDataStack().peek();
+ Parsable tmpData = lis.getParsedDataStack().peek();
if (tmpData.getYangConstructType() == TYPE_DATA) {
YangType type = (YangType) tmpData;
- setRangeRestriction(listener, type, ctx);
+ setRangeRestriction(lis, type, ctx);
} else {
- throw new ParserException(constructListenerErrorMessage(INVALID_HOLDER, RANGE_DATA,
- ctx.range().getText(), ENTRY));
+ throw new ParserException(constructListenerErrorMessage(
+ INVALID_HOLDER, RANGE_DATA, ctx.range().getText(), ENTRY));
}
}
/**
* Sets the range restriction to type.
*
- * @param listener listener's object
- * @param type YANG type for which range restriction to be added
- * @param ctx context object of the grammar rule
+ * @param lis listener's object
+ * @param type YANG type
+ * @param ctx context object
*/
- private static void setRangeRestriction(TreeWalkListener listener, YangType type,
+ private static void setRangeRestriction(TreeWalkListener lis, YangType type,
RangeStatementContext ctx) {
+ String txt = ctx.range().getText();
+ int line = ctx.getStart().getLine();
+ int pos = ctx.getStart().getCharPositionInLine();
+ YangDataTypes dataType = type.getDataType();
- if (type.getDataType() == DERIVED) {
- ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
- .setRangeRestrictionString(ctx.range().getText());
- ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
- .setLineNumber(ctx.getStart().getLine());
- ((YangDerivedInfo<YangRangeRestriction>) type.getDataTypeExtendedInfo())
- .setCharPosition(ctx.getStart().getCharPositionInLine());
+ YangRangeRestriction ranRes = new YangRangeRestriction(txt);
+ ranRes.setFileName(lis.getFileName());
+ ranRes.setCharPosition(pos);
+ ranRes.setLineNumber(line);
+ lis.getParsedDataStack().push(ranRes);
+
+ if (dataType == DERIVED) {
+ YangDerivedInfo info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
+ info.setRangeRes(ranRes);
+ info.setFileName(lis.getFileName());
+ info.setCharPosition(pos);
+ info.setLineNumber(line);
return;
}
- if (!(isOfRangeRestrictedType(type.getDataType())) && (type.getDataType() != DECIMAL64)) {
- ParserException parserException = new ParserException("YANG file error: Range restriction can't be " +
- "applied to a given type");
- parserException.setLine(ctx.getStart().getLine());
- parserException.setCharPosition(ctx.getStart().getCharPositionInLine());
- throw parserException;
+ if (!(isOfRangeRestrictedType(dataType)) && (dataType != DECIMAL64)) {
+ ParserException exc = new ParserException(E_INVALID_TYPE);
+ exc.setLine(line);
+ exc.setCharPosition(pos);
+ throw exc;
}
-
- YangRangeRestriction rangeRestriction = null;
try {
- if (type.getDataType() == DECIMAL64) {
- YangDecimal64 yangDecimal64 = (YangDecimal64) type.getDataTypeExtendedInfo();
- rangeRestriction =
- processRangeRestriction(yangDecimal64.getDefaultRangeRestriction(),
- ctx.getStart().getLine(),
- ctx.getStart().getCharPositionInLine(),
- true, ctx.range().getText(),
- type.getDataType(), listener.getFileName());
+ if (dataType == DECIMAL64) {
+ YangDecimal64 deci64 = (YangDecimal64) type
+ .getDataTypeExtendedInfo();
+ ranRes = processRangeRestriction(
+ deci64.getDefaultRangeRestriction(), line, pos, true,
+ ranRes, dataType, lis.getFileName());
} else {
- rangeRestriction =
- processRangeRestriction(null, ctx.getStart().getLine(),
- ctx.getStart().getCharPositionInLine(),
- false, ctx.range()
- .getText(), type
- .getDataType(),
- listener.getFileName());
+ ranRes = processRangeRestriction(null, line, pos, false, ranRes,
+ dataType, lis.getFileName());
}
} catch (DataModelException e) {
- ParserException parserException = new ParserException(e.getMessage());
- parserException.setCharPosition(e.getCharPositionInLine());
- parserException.setLine(e.getLineNumber());
- throw parserException;
+ ParserException exc = new ParserException(e.getMessage());
+ exc.setCharPosition(e.getCharPositionInLine());
+ exc.setLine(e.getLineNumber());
+ throw exc;
}
- if (rangeRestriction != null) {
- if (type.getDataType() == DECIMAL64) {
- ((YangDecimal64<YangRangeRestriction>) type.getDataTypeExtendedInfo())
- .setRangeRestrictedExtendedInfo(rangeRestriction);
+ if (ranRes != null) {
+ if (dataType == DECIMAL64) {
+ ((YangDecimal64<YangRangeRestriction>) type
+ .getDataTypeExtendedInfo())
+ .setRangeRestrictedExtendedInfo(ranRes);
} else {
- type.setDataTypeExtendedInfo(rangeRestriction);
+ type.setDataTypeExtendedInfo(ranRes);
}
}
- listener.getParsedDataStack().push(rangeRestriction);
}
/**
* Performs validation and updates the data model tree.
* It is called when parser exits from grammar rule (range).
*
- * @param listener listener's object
- * @param ctx context object of the grammar rule
+ * @param lis listener object
+ * @param ctx context object
*/
- public static void processRangeRestrictionExit(TreeWalkListener listener,
+ public static void processRangeRestrictionExit(TreeWalkListener lis,
RangeStatementContext ctx) {
- // Check for stack to be non empty.
- checkStackIsNotEmpty(listener, MISSING_HOLDER, RANGE_DATA, ctx.range().getText(), EXIT);
+ String txt = ctx.range().getText();
- Parsable tmpData = listener.getParsedDataStack().peek();
- if (tmpData instanceof YangRangeRestriction) {
- listener.getParsedDataStack().pop();
- } else if (tmpData instanceof YangType
- && ((YangType) tmpData).getDataType() == DERIVED) {
- // TODO : need to handle in linker
- } else {
- throw new ParserException(constructListenerErrorMessage(MISSING_CURRENT_HOLDER, RANGE_DATA,
- ctx.range().getText(), EXIT));
+ // Check for stack to be non empty.
+ checkStackIsNotEmpty(lis, MISSING_HOLDER, RANGE_DATA, txt, EXIT);
+
+ Parsable tmpData = lis.getParsedDataStack().peek();
+ if (!(tmpData instanceof YangRangeRestriction)) {
+ throw new ParserException(constructListenerErrorMessage(
+ MISSING_CURRENT_HOLDER, RANGE_DATA, txt, EXIT));
}
+ lis.getParsedDataStack().pop();
}
}
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64ListenerTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64ListenerTest.java
index 8a54a51..3498273 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64ListenerTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/Decimal64ListenerTest.java
@@ -563,13 +563,15 @@
public void processDecimal64MultiTypedefMultiInvalidRangeStatement() throws IOException, LinkerException {
thrown.expect(LinkerException.class);
thrown.expectMessage(
- "Range interval doesn't fall within the referred restriction ranges" +
- " restriction ranges. in 0 at 0 in src/test/resources/decimal64/" +
- "Decimal64MultiTypedefMultiInvalidRangeStatement.yang\"type." +
- " in 19 at 12 in src/test/resources/decimal64/Decimal64MultiTypedef" +
- "MultiInvalidRangeStatement.yang");
+ "Range interval doesn't fall within the referred restriction" +
+ " ranges restriction ranges. in 9 at 12 in src/test/" +
+ "resources/decimal64/Decimal64MultiTypedefMultiInval" +
+ "idRangeStatement.yang\"type. in 19 at 12 in src/tes" +
+ "t/resources/decimal64/Decimal64MultiTypedefMultiInv" +
+ "alidRangeStatement.yang");
- manager.getDataModel("src/test/resources/decimal64/Decimal64MultiTypedefMultiInvalidRangeStatement.yang");
+ manager.getDataModel("src/test/resources/decimal64/Decimal64MultiTyp" +
+ "edefMultiInvalidRangeStatement.yang");
}
/**
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListenerTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListenerTest.java
index af9572f..bae9399 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListenerTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/LengthRestrictionListenerTest.java
@@ -27,8 +27,8 @@
import org.onosproject.yang.compiler.datamodel.YangRangeInterval;
import org.onosproject.yang.compiler.datamodel.YangRangeRestriction;
import org.onosproject.yang.compiler.datamodel.YangStringRestriction;
+import org.onosproject.yang.compiler.datamodel.YangType;
import org.onosproject.yang.compiler.datamodel.YangTypeDef;
-import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangUint64;
import org.onosproject.yang.compiler.parser.exceptions.ParserException;
import org.onosproject.yang.compiler.parser.impl.YangUtilsParserManager;
@@ -37,49 +37,55 @@
import java.math.BigInteger;
import java.util.ListIterator;
+import static java.math.BigInteger.valueOf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.BINARY;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.STRING;
/**
* Test cases for length restriction listener.
*/
public class LengthRestrictionListenerTest {
+ private final YangUtilsParserManager manager = new YangUtilsParserManager();
@Rule
public ExpectedException thrown = ExpectedException.none();
- private final YangUtilsParserManager manager = new YangUtilsParserManager();
-
/**
* Checks valid length statement as sub-statement of leaf statement.
*/
@Test
public void processValidLengthStatement() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/ValidLengthStatement.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/ValidLengthStatement.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
+ YangType<?> type = leaf.getDataType();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- YangStringRestriction stringRestriction = (YangStringRestriction) leafInfo
- .getDataType().getDataTypeExtendedInfo();
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("string"));
+ assertThat(type.getDataType(), is(STRING));
+ YangStringRestriction strRes = (YangStringRestriction) type
+ .getDataTypeExtendedInfo();
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
- .listIterator();
+ ListIterator<YangRangeInterval> lenIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
- YangRangeInterval rangeInterval = lengthListIterator.next();
+ YangRangeInterval range = lenIt.next();
- assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
- assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+ assertThat(((YangUint64) range.getStartValue()).getValue(),
+ is(valueOf(0)));
+ assertThat(((YangUint64) range.getEndValue()).getValue(),
+ is(valueOf(100)));
}
/**
@@ -88,29 +94,33 @@
@Test
public void processLengthStatementInsideLeafList() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/LengthStatementInsideLeafList.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/LengthStatementInsideLeafList.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
- YangLeafList leafListInfo = leafListIterator.next();
-
- assertThat(leafListInfo.getName(), is("invalid-interval"));
- assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
- .getDataType().getDataTypeExtendedInfo();
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
-
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
+ ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
.listIterator();
+ YangLeafList ll = it.next();
+ YangType<?> type = ll.getDataType();
+ assertThat(ll.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("string"));
+ assertThat(type.getDataType(), is(STRING));
+ YangStringRestriction strRes = (YangStringRestriction) type
+ .getDataTypeExtendedInfo();
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
- YangRangeInterval rangeInterval = lengthListIterator.next();
- assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(1)));
- assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+ ListIterator<YangRangeInterval> llIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
+
+ YangRangeInterval range = llIt.next();
+ assertThat(((YangUint64) range.getStartValue()).getValue(),
+ is(valueOf(1)));
+ assertThat(((YangUint64) range.getEndValue()).getValue(),
+ is(valueOf(100)));
}
/**
@@ -119,7 +129,8 @@
@Test
public void processLengthStatementInsideTypeDef() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/LengthStatementInsideTypeDef.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/LengthStatementInsideTypeDef.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
@@ -127,15 +138,20 @@
assertThat(yangNode.getName(), is("Test"));
YangTypeDef typedef = (YangTypeDef) yangNode.getChild();
- YangStringRestriction stringRestriction = (YangStringRestriction) typedef.getTypeDefBaseType()
- .getDataTypeExtendedInfo();
+ YangStringRestriction strRes = (YangStringRestriction) typedef
+ .getTypeDefBaseType().getDataTypeExtendedInfo();
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
+ assertThat(lenRes.getDescription(),
+ is("\"length-description typedef\""));
+ assertThat(lenRes.getReference(), is("\"reference typedef\""));
+ ListIterator<YangRangeInterval> it = lenRes.getAscendingRangeIntervals()
.listIterator();
- YangRangeInterval rangeInterval = lengthListIterator.next();
- assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(1)));
- assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+ YangRangeInterval rangeInterval = it.next();
+ assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(),
+ is(valueOf(1)));
+ assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(),
+ is(valueOf(100)));
}
/**
@@ -144,29 +160,36 @@
@Test
public void processValidBinaryLengthStatement() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/ValidBinaryLengthStatement.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/ValidBinaryLengthStatement.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
+ YangType<?> type = leaf.getDataType();
- assertThat(leafInfo.getName(), is("message"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("binary"));
- assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.BINARY));
- YangRangeRestriction lengthRestriction = (YangRangeRestriction) leafInfo
- .getDataType().getDataTypeExtendedInfo();
+ assertThat(leaf.getName(), is("message"));
+ assertThat(type.getDataTypeName(), is("binary"));
+ assertThat(type.getDataType(), is(BINARY));
+ YangRangeRestriction lenRes = (YangRangeRestriction) type
+ .getDataTypeExtendedInfo();
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
- .listIterator();
+ assertThat(lenRes.getDescription(), is("\"binary description\""));
+ assertThat(lenRes.getReference(), is("\"binary reference\""));
- YangRangeInterval rangeInterval = lengthListIterator.next();
+ ListIterator<YangRangeInterval> llIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
- assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(4)));
- assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(4)));
+ YangRangeInterval range = llIt.next();
+
+ assertThat(((YangUint64) range.getStartValue()).getValue(),
+ is(valueOf(4)));
+ assertThat(((YangUint64) range.getEndValue()).getValue(),
+ is(valueOf(4)));
}
/**
@@ -175,9 +198,11 @@
@Test
public void processLengthWithInvalidType() throws IOException, ParserException {
thrown.expect(ParserException.class);
- thrown.expectMessage("YANG file error : length name \"1..100\" can be used to restrict the built-in type" +
- " string/binary or types derived from string/binary.");
- YangNode node = manager.getDataModel("src/test/resources/LengthWithInvalidType.yang");
+ thrown.expectMessage("YANG file error : Length can only be used to" +
+ " restrict the built-in type string/" +
+ "binary or types derived from string/" +
+ "binary");
+ manager.getDataModel("src/test/resources/LengthWithInvalidType.yang");
}
/**
@@ -187,29 +212,34 @@
public void processLengthWithOneInterval() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/LengthWithOneInterval.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/LengthWithOneInterval.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
- YangLeafList leafListInfo = leafListIterator.next();
-
- assertThat(leafListInfo.getName(), is("invalid-interval"));
- assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
- .getDataType().getDataTypeExtendedInfo();
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
-
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
+ ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
.listIterator();
+ YangLeafList ll = it.next();
+ YangType<?> type = ll.getDataType();
- YangRangeInterval rangeInterval = lengthListIterator.next();
- assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(1)));
- assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(1)));
+ assertThat(ll.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("string"));
+ assertThat(type.getDataType(), is(STRING));
+ YangStringRestriction strRes = (YangStringRestriction) type
+ .getDataTypeExtendedInfo();
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
+
+ ListIterator<YangRangeInterval> llIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
+
+ YangRangeInterval range = llIt.next();
+ assertThat(((YangUint64) range.getStartValue()).getValue(),
+ is(valueOf(1)));
+ assertThat(((YangUint64) range.getEndValue()).getValue(),
+ is(valueOf(1)));
}
/**
@@ -219,29 +249,34 @@
public void processLengthWithMinMax() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/LengthWithMinMax.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/LengthWithMinMax.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
- YangLeafList leafListInfo = leafListIterator.next();
-
- assertThat(leafListInfo.getName(), is("invalid-interval"));
- assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
- .getDataType().getDataTypeExtendedInfo();
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
-
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
+ ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
.listIterator();
+ YangLeafList ll = it.next();
+ YangType<?> type = ll.getDataType();
- YangRangeInterval rangeInterval = lengthListIterator.next();
- assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
- assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(new BigInteger("18446744073709551615")));
+ assertThat(ll.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("string"));
+ assertThat(type.getDataType(), is(STRING));
+ YangStringRestriction strRes = (YangStringRestriction) type
+ .getDataTypeExtendedInfo();
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
+
+ ListIterator<YangRangeInterval> llIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
+
+ YangRangeInterval range = llIt.next();
+ assertThat(((YangUint64) range.getStartValue()).getValue(),
+ is(valueOf(0)));
+ assertThat(((YangUint64) range.getEndValue()).getValue(),
+ is(new BigInteger("18446744073709551615")));
}
/**
@@ -250,8 +285,10 @@
@Test
public void processLengthWithInvalidIntegerPattern() throws IOException, ParserException {
thrown.expect(ParserException.class);
- thrown.expectMessage("YANG file error : Input value \"a\" is not a valid uint64.");
- YangNode node = manager.getDataModel("src/test/resources/LengthWithInvalidIntegerPattern.yang");
+ thrown.expectMessage("YANG file error : Input value \"a\" is not a" +
+ " valid uint64.");
+ manager.getDataModel("src/test/resources/LengthWithInvalidI" +
+ "ntegerPattern.yang");
}
/**
@@ -260,44 +297,50 @@
@Test
public void processLengthWithInvalidInterval() throws IOException, ParserException {
thrown.expect(ParserException.class);
- thrown.expectMessage("YANG file error : 18446744073709551617 is greater than maximum value" +
- " 18446744073709551615.");
- YangNode node = manager.getDataModel("src/test/resources/LengthWithInvalidInterval.yang");
+ thrown.expectMessage("YANG file error : 18446744073709551617 is gre" +
+ "ater than maximum value " +
+ "18446744073709551615.");
+ manager.getDataModel("src/test/resources/LengthWithInvalidInter" +
+ "val.yang");
}
/**
- * Checks valid length substatements.
+ * Checks valid length sub-statements.
*/
@Test
public void processLengthSubStatements() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/LengthSubStatements.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/LengthSubStatements.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
+ YangType<?> type = leaf.getDataType();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- YangStringRestriction stringRestriction = (YangStringRestriction) leafInfo
- .getDataType().getDataTypeExtendedInfo();
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("string"));
+ assertThat(type.getDataType(), is(STRING));
+ YangStringRestriction strRes = (YangStringRestriction) type
+ .getDataTypeExtendedInfo();
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
- assertThat(lengthRestriction.getDescription(), is("\"length description\""));
- assertThat(lengthRestriction.getReference(), is("\"length reference\""));
+ assertThat(lenRes.getDescription(), is("\"length description\""));
+ assertThat(lenRes.getReference(), is("\"length reference\""));
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
- .listIterator();
+ ListIterator<YangRangeInterval> llIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
- YangRangeInterval rangeInterval = lengthListIterator.next();
+ YangRangeInterval range = llIt.next();
- assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
- assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+ assertThat(((YangUint64) range.getStartValue()).getValue(),
+ is(valueOf(0)));
+ assertThat(((YangUint64) range.getEndValue()).getValue(),
+ is(valueOf(100)));
}
/**
@@ -306,29 +349,33 @@
@Test
public void processLengthStatementWithSpace() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/LengthStatementWithSpace.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/LengthStatementWithSpace.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
+ YangType<?> type = leaf.getDataType();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- YangStringRestriction stringRestriction = (YangStringRestriction) leafInfo
- .getDataType().getDataTypeExtendedInfo();
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("string"));
+ assertThat(type.getDataType(), is(STRING));
+ YangStringRestriction strRes = (YangStringRestriction) type
+ .getDataTypeExtendedInfo();
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
- .listIterator();
+ ListIterator<YangRangeInterval> llIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
- YangRangeInterval rangeInterval = lengthListIterator.next();
+ YangRangeInterval range = llIt.next();
- assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
- assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+ assertThat(((YangUint64) range.getStartValue()).getValue(),
+ is(valueOf(0)));
+ assertThat(((YangUint64) range.getEndValue()).getValue(),
+ is(valueOf(100)));
}
}
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListenerTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListenerTest.java
index ce63ef2..c0f0c5b 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListenerTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/PatternRestrictionListenerTest.java
@@ -31,6 +31,7 @@
import org.onosproject.yang.compiler.parser.impl.YangUtilsParserManager;
import java.io.IOException;
+import java.util.List;
import java.util.ListIterator;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -49,35 +50,35 @@
@Test
public void processValidPatternStatement() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/ValidPatternStatement.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/ValidPatternStatement.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), Is.is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- YangStringRestriction stringRestriction = (YangStringRestriction) leafInfo
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(leaf.getDataType().getDataTypeName(), is("string"));
+ assertThat(leaf.getDataType().getDataType(), is(YangDataTypes.STRING));
+ YangStringRestriction strRes = (YangStringRestriction) leaf
.getDataType().getDataTypeExtendedInfo();
- ListIterator<String> patternListIterator = stringRestriction.getPatternRestriction()
- .getPatternList().listIterator();
- assertThat(patternListIterator.next(), is("[a-zA-Z]"));
+ ListIterator<YangPatternRestriction> patIt = strRes
+ .getPatternResList().listIterator();
+ assertThat(patIt.next().getPattern(), is("[a-zA-Z]"));
- leafInfo = leafIterator.next();
+ leaf = it.next();
- assertThat(leafInfo.getName(), is("ipv4-address"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- stringRestriction = (YangStringRestriction) leafInfo
- .getDataType().getDataTypeExtendedInfo();
- patternListIterator = stringRestriction.getPatternRestriction()
- .getPatternList().listIterator();
- assertThat(patternListIterator.next(), is(
+ assertThat(leaf.getName(), is("ipv4-address"));
+ assertThat(leaf.getDataType().getDataTypeName(), is("string"));
+ assertThat(leaf.getDataType().getDataType(), is(YangDataTypes.STRING));
+ strRes = (YangStringRestriction) leaf.getDataType()
+ .getDataTypeExtendedInfo();
+ patIt = strRes.getPatternResList().listIterator();
+ assertThat(patIt.next().getPattern(), is(
"(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}" +
"([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])" +
"(%[\\p{N}\\p{L}]+)?"));
@@ -89,24 +90,26 @@
@Test
public void processPatternStatementInsideLeafList() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/PatternStatementInsideLeafList.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/PatternStatementInsideLeafList.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
- YangLeafList leafListInfo = leafListIterator.next();
+ ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
+ .listIterator();
+ YangLeafList ll = it.next();
- assertThat(leafListInfo.getName(), is("invalid-interval"));
- assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
+ assertThat(ll.getName(), is("invalid-interval"));
+ assertThat(ll.getDataType().getDataTypeName(), is("string"));
+ assertThat(ll.getDataType().getDataType(), is(YangDataTypes.STRING));
+ YangStringRestriction strRes = (YangStringRestriction) ll
.getDataType().getDataTypeExtendedInfo();
- ListIterator<String> patternListIterator = stringRestriction.getPatternRestriction()
- .getPatternList().listIterator();
- assertThat(patternListIterator.next(), is("[a-zA-Z]"));
+ ListIterator<YangPatternRestriction> patIt = strRes.getPatternResList()
+ .listIterator();
+ assertThat(patIt.next().getPattern(), is("[a-zA-Z]"));
}
/**
@@ -115,7 +118,8 @@
@Test
public void processPatternStatementInsideTypeDef() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/PatternStatementInsideTypeDef.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/PatternStatementInsideTypeDef.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
@@ -123,11 +127,11 @@
assertThat(yangNode.getName(), is("Test"));
YangTypeDef typedef = (YangTypeDef) yangNode.getChild();
- YangStringRestriction stringRestriction = (YangStringRestriction) typedef.getTypeDefBaseType()
- .getDataTypeExtendedInfo();
+ YangStringRestriction strRes = (YangStringRestriction) typedef
+ .getTypeDefBaseType().getDataTypeExtendedInfo();
- YangPatternRestriction yangPatternRestriction = stringRestriction.getPatternRestriction();
- assertThat(yangPatternRestriction.getPatternList().listIterator().next(), is("[a-zA-Z]"));
+ List<YangPatternRestriction> patRes = strRes.getPatternResList();
+ assertThat(patRes.listIterator().next().getPattern(), is("[a-zA-Z]"));
}
/**
@@ -136,24 +140,26 @@
@Test
public void processMultiplePatternStatement() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/MultiplePatternStatement.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/MultiplePatternStatement.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
- YangLeafList leafListInfo = leafListIterator.next();
+ ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
+ .listIterator();
+ YangLeafList ll = it.next();
- assertThat(leafListInfo.getName(), is("invalid-interval"));
- assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
- .getDataType().getDataTypeExtendedInfo();
- ListIterator<String> patternListIterator = stringRestriction.getPatternRestriction()
- .getPatternList().listIterator();
- assertThat(patternListIterator.next(), is("[a-zA-Z]"));
+ assertThat(ll.getName(), is("invalid-interval"));
+ assertThat(ll.getDataType().getDataTypeName(), is("string"));
+ assertThat(ll.getDataType().getDataType(), is(YangDataTypes.STRING));
+ YangStringRestriction strRes = (YangStringRestriction) ll.getDataType()
+ .getDataTypeExtendedInfo();
+ ListIterator<YangPatternRestriction> patIt = strRes.getPatternResList()
+ .listIterator();
+ assertThat(patIt.next().getPattern(), is("[a-zA-Z]"));
}
/**
@@ -162,23 +168,25 @@
@Test
public void processPatternStatementWithPlus() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/PatternStatementWithPlus.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/PatternStatementWithPlus.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
- YangLeafList leafListInfo = leafListIterator.next();
+ ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
+ .listIterator();
+ YangLeafList ll = it.next();
- assertThat(leafListInfo.getName(), is("invalid-interval"));
- assertThat(leafListInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- YangStringRestriction stringRestriction = (YangStringRestriction) leafListInfo
- .getDataType().getDataTypeExtendedInfo();
- ListIterator<String> patternListIterator = stringRestriction.getPatternRestriction()
- .getPatternList().listIterator();
+ assertThat(ll.getName(), is("invalid-interval"));
+ assertThat(ll.getDataType().getDataTypeName(), is("string"));
+ assertThat(ll.getDataType().getDataType(), is(YangDataTypes.STRING));
+ YangStringRestriction strRes = (YangStringRestriction) ll.getDataType()
+ .getDataTypeExtendedInfo();
+ ListIterator<YangPatternRestriction> patIt = strRes.getPatternResList()
+ .listIterator();
//FIXME: + should not be remove from the end.
//assertThat(patternListIterator.next(), is("-[0-9]+|[0-9]+"));
}
@@ -189,26 +197,28 @@
@Test
public void processPatternSubStatements() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/PatternSubStatements.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/PatternSubStatements.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("string"));
- assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.STRING));
- YangStringRestriction stringRestriction = (YangStringRestriction) leafInfo
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(leaf.getDataType().getDataTypeName(), is("string"));
+ assertThat(leaf.getDataType().getDataType(), is(YangDataTypes.STRING));
+ YangStringRestriction strRes = (YangStringRestriction) leaf
.getDataType().getDataTypeExtendedInfo();
- assertThat(stringRestriction.getDescription(), is("\"pattern description\""));
- assertThat(stringRestriction.getReference(), is("\"pattern reference\""));
- ListIterator<String> patternListIterator = stringRestriction.getPatternRestriction()
- .getPatternList().listIterator();
- assertThat(patternListIterator.next(), is("[a-zA-Z]"));
+ ListIterator<YangPatternRestriction> patIt = strRes.getPatternResList()
+ .listIterator();
+ YangPatternRestriction pat = patIt.next();
+ assertThat(pat.getDescription(), is("\"pattern description\""));
+ assertThat(pat.getReference(), is("\"pattern reference\""));
+ assertThat(pat.getPattern(), is("[a-zA-Z]"));
}
/**
@@ -216,6 +226,7 @@
*/
@Test(expected = ParserException.class)
public void processInvalidPatternSubStatements() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/InvalidPatternSubStatements.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/InvalidPatternSubStatements.yang");
}
}
diff --git a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListenerTest.java b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListenerTest.java
index ab3cc4c..370514d 100644
--- a/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListenerTest.java
+++ b/compiler/base/parser/src/test/java/org/onosproject/yang/compiler/parser/impl/listeners/RangeRestrictionListenerTest.java
@@ -19,6 +19,7 @@
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import org.onosproject.yang.compiler.datamodel.YangDerivedInfo;
import org.onosproject.yang.compiler.datamodel.YangLeaf;
import org.onosproject.yang.compiler.datamodel.YangLeafList;
import org.onosproject.yang.compiler.datamodel.YangModule;
@@ -26,8 +27,10 @@
import org.onosproject.yang.compiler.datamodel.YangNodeType;
import org.onosproject.yang.compiler.datamodel.YangRangeInterval;
import org.onosproject.yang.compiler.datamodel.YangRangeRestriction;
-import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
+import org.onosproject.yang.compiler.datamodel.YangType;
+import org.onosproject.yang.compiler.datamodel.YangTypeDef;
import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangInt32;
+import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangUint8;
import org.onosproject.yang.compiler.parser.exceptions.ParserException;
import org.onosproject.yang.compiler.parser.impl.YangUtilsParserManager;
@@ -36,44 +39,48 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.DERIVED;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.INT32;
/**
* Test cases for range restriction listener.
*/
public class RangeRestrictionListenerTest {
+ private final YangUtilsParserManager manager = new YangUtilsParserManager();
@Rule
public ExpectedException thrown = ExpectedException.none();
- private final YangUtilsParserManager manager = new YangUtilsParserManager();
-
/**
* Checks valid range statement as sub-statement of leaf statement.
*/
@Test
public void processValidRangeStatement() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/ValidRangeStatement.yang");
+ YangNode node = manager.getDataModel("src/test/resources/ValidRange" +
+ "Statement.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("int32"));
- assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
- YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafInfo
- .getDataType().getDataTypeExtendedInfo();
+ YangType<?> type = leaf.getDataType();
- ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
- .listIterator();
- YangRangeInterval rangeInterval = rangeListIterator.next();
- assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(1));
- assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(4));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("int32"));
+ assertThat(type.getDataType(), is(INT32));
+ YangRangeRestriction ranRes = (YangRangeRestriction) type
+ .getDataTypeExtendedInfo();
+
+ ListIterator<YangRangeInterval> rlIt = ranRes
+ .getAscendingRangeIntervals().listIterator();
+ YangRangeInterval range = rlIt.next();
+ assertThat(((YangInt32) range.getStartValue()).getValue(), is(1));
+ assertThat(((YangInt32) range.getEndValue()).getValue(), is(4));
}
/**
@@ -82,28 +89,32 @@
@Test
public void processRangeStatementInsideLeafList() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/RangeStatementInsideLeafList.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/RangeStatementInsideLeafList.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
- YangLeafList leafListInfo = leafListIterator.next();
-
- assertThat(leafListInfo.getName(), is("invalid-interval"));
- assertThat(leafListInfo.getDataType().getDataTypeName(), is("int32"));
- assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
- YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafListInfo
- .getDataType().getDataTypeExtendedInfo();
-
- ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
+ ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
.listIterator();
- YangRangeInterval rangeInterval = rangeListIterator.next();
+ YangLeafList ll = it.next();
- assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(1));
- assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(4));
+ YangType<?> type = ll.getDataType();
+
+ assertThat(ll.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("int32"));
+ assertThat(type.getDataType(), is(INT32));
+ YangRangeRestriction ranRes = (YangRangeRestriction) type
+ .getDataTypeExtendedInfo();
+
+ ListIterator<YangRangeInterval> rlIt = ranRes
+ .getAscendingRangeIntervals().listIterator();
+ YangRangeInterval range = rlIt.next();
+
+ assertThat(((YangInt32) range.getStartValue()).getValue(), is(1));
+ assertThat(((YangInt32) range.getEndValue()).getValue(), is(4));
}
/**
@@ -112,28 +123,32 @@
@Test
public void processRangeWithOneInterval() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/RangeWithOneInterval.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/RangeWithOneInterval.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
- YangLeafList leafListInfo = leafListIterator.next();
-
- assertThat(leafListInfo.getName(), is("invalid-interval"));
- assertThat(leafListInfo.getDataType().getDataTypeName(), is("int32"));
- assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
- YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafListInfo
- .getDataType().getDataTypeExtendedInfo();
-
- ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
+ ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
.listIterator();
- YangRangeInterval rangeInterval = rangeListIterator.next();
+ YangLeafList ll = it.next();
- assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(1));
- assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(1));
+ YangType<?> type = ll.getDataType();
+
+ assertThat(ll.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("int32"));
+ assertThat(type.getDataType(), is(INT32));
+ YangRangeRestriction ranRes = (YangRangeRestriction) type
+ .getDataTypeExtendedInfo();
+
+ ListIterator<YangRangeInterval> rlIt = ranRes
+ .getAscendingRangeIntervals().listIterator();
+ YangRangeInterval range = rlIt.next();
+
+ assertThat(((YangInt32) range.getStartValue()).getValue(), is(1));
+ assertThat(((YangInt32) range.getEndValue()).getValue(), is(1));
}
/**
@@ -142,28 +157,34 @@
@Test
public void processRangeWithMinMax() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/RangeWithMinMax.yang");
+ YangNode node = manager.getDataModel("src/test/resources/RangeWithM" +
+ "inMax.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeafList> leafListIterator = yangNode.getListOfLeafList().listIterator();
- YangLeafList leafListInfo = leafListIterator.next();
-
- assertThat(leafListInfo.getName(), is("invalid-interval"));
- assertThat(leafListInfo.getDataType().getDataTypeName(), is("int32"));
- assertThat(leafListInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
- YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafListInfo
- .getDataType().getDataTypeExtendedInfo();
-
- ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
+ ListIterator<YangLeafList> it = yangNode.getListOfLeafList()
.listIterator();
- YangRangeInterval rangeInterval = rangeListIterator.next();
+ YangLeafList ll = it.next();
- assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(-2147483648));
- assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(2147483647));
+ YangType<?> type = ll.getDataType();
+
+ assertThat(ll.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("int32"));
+ assertThat(type.getDataType(), is(INT32));
+ YangRangeRestriction ranRes = (YangRangeRestriction) type
+ .getDataTypeExtendedInfo();
+
+ ListIterator<YangRangeInterval> rlIt = ranRes
+ .getAscendingRangeIntervals().listIterator();
+ YangRangeInterval range = rlIt.next();
+
+ assertThat(((YangInt32) range.getStartValue()).getValue(),
+ is(-2147483648));
+ assertThat(((YangInt32) range.getEndValue()).getValue(),
+ is(2147483647));
}
/**
@@ -172,8 +193,10 @@
@Test
public void processRangeWithInvalidIntegerPattern() throws IOException, ParserException {
thrown.expect(ParserException.class);
- thrown.expectMessage("YANG file error : Input value \"a\" is not a valid int32.");
- YangNode node = manager.getDataModel("src/test/resources/RangeWithInvalidIntegerPattern.yang");
+ thrown.expectMessage("YANG file error : Input value \"a\" is not " +
+ "a valid int32.");
+ manager.getDataModel("src/test/resources/RangeWithInval" +
+ "idIntegerPattern.yang");
}
/**
@@ -182,31 +205,34 @@
@Test
public void processRangeSubStatements() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/RangeSubStatements.yang");
+ YangNode node = manager.getDataModel("src/test/resources/" +
+ "RangeSubStatements.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("int32"));
- assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
- YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafInfo
- .getDataType().getDataTypeExtendedInfo();
+ YangType<?> type = leaf.getDataType();
- assertThat(rangeRestriction.getDescription(), is("\"range description\""));
- assertThat(rangeRestriction.getReference(), is("\"range reference\""));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("int32"));
+ assertThat(type.getDataType(), is(INT32));
+ YangRangeRestriction ranRes = (YangRangeRestriction) type
+ .getDataTypeExtendedInfo();
- ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
- .listIterator();
- YangRangeInterval rangeInterval = rangeListIterator.next();
- assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(1));
- assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(4));
- assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(4));
+ assertThat(ranRes.getDescription(), is("\"range description\""));
+ assertThat(ranRes.getReference(), is("\"range reference\""));
+
+ ListIterator<YangRangeInterval> rlIt = ranRes
+ .getAscendingRangeIntervals().listIterator();
+ YangRangeInterval range = rlIt.next();
+ assertThat(((YangInt32) range.getStartValue()).getValue(), is(1));
+ assertThat(((YangInt32) range.getEndValue()).getValue(), is(4));
+ assertThat(((YangInt32) range.getEndValue()).getValue(), is(4));
}
/**
@@ -215,26 +241,84 @@
@Test
public void processRangeStatementWithSpace() throws IOException, ParserException {
- YangNode node = manager.getDataModel("src/test/resources/RangeStatementWithSpace.yang");
+ YangNode node = manager.getDataModel("src/test/resources/RangeSta" +
+ "tementWithSpace.yang");
assertThat((node instanceof YangModule), is(true));
assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("int32"));
- assertThat(leafInfo.getDataType().getDataType(), is(YangDataTypes.INT32));
- YangRangeRestriction rangeRestriction = (YangRangeRestriction) leafInfo
- .getDataType().getDataTypeExtendedInfo();
+ YangType<?> type = leaf.getDataType();
- ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
- .listIterator();
- YangRangeInterval rangeInterval = rangeListIterator.next();
- assertThat(((YangInt32) rangeInterval.getStartValue()).getValue(), is(1));
- assertThat(((YangInt32) rangeInterval.getEndValue()).getValue(), is(4));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("int32"));
+ assertThat(type.getDataType(), is(INT32));
+ YangRangeRestriction ranRes = (YangRangeRestriction) type
+ .getDataTypeExtendedInfo();
+
+ ListIterator<YangRangeInterval> rlIt = ranRes
+ .getAscendingRangeIntervals().listIterator();
+ YangRangeInterval range = rlIt.next();
+ assertThat(((YangInt32) range.getStartValue()).getValue(), is(1));
+ assertThat(((YangInt32) range.getEndValue()).getValue(), is(4));
}
+
+ /**
+ * Checks range statement in typedef with description and reference.
+ *
+ * @throws IOException when IO operation fails
+ * @throws ParserException when parsing fails
+ */
+ @Test
+ public void processRangeStatementInTypeDef() throws IOException, ParserException {
+ YangNode node = manager.getDataModel("src/test/resources/Range" +
+ "WithTypedef.yang");
+ assertThat((node instanceof YangModule), is(true));
+ assertThat(node.getNodeType(), is(YangNodeType.MODULE_NODE));
+ YangModule yangNode = (YangModule) node;
+ assertThat(yangNode.getName(), is("Test"));
+
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
+
+ YangType<?> type = leaf.getDataType();
+
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataType(), is(DERIVED));
+ YangDerivedInfo info = (YangDerivedInfo) type
+ .getDataTypeExtendedInfo();
+
+ YangRangeRestriction ranRes1 = info.getRangeRes();
+
+ assertThat(ranRes1.getDescription(), is("\"range description\""));
+ assertThat(ranRes1.getReference(), is("\"range reference\""));
+
+ ListIterator<YangRangeInterval> rlIt1 = ranRes1
+ .getAscendingRangeIntervals().listIterator();
+ YangRangeInterval range1 = rlIt1.next();
+ assertThat(((YangUint8) range1.getStartValue()).getValue(),
+ is((short) 2));
+ assertThat(((YangUint8) range1.getEndValue()).getValue(),
+ is((short) 100));
+
+ YangTypeDef typeDef = (YangTypeDef) yangNode.getChild();
+ YangRangeRestriction ranRes = (YangRangeRestriction) typeDef
+ .getTypeDefBaseType().getDataTypeExtendedInfo();
+ assertThat(ranRes.getDescription(),
+ is("\"typedef description\""));
+ assertThat(ranRes.getReference(), is("\"typedef reference\""));
+
+ ListIterator<YangRangeInterval> rlIt2 = ranRes
+ .getAscendingRangeIntervals().listIterator();
+ YangRangeInterval range2 = rlIt2.next();
+ assertThat(((YangUint8) range2.getStartValue()).getValue(),
+ is((short) 1));
+ assertThat(((YangUint8) range2.getEndValue()).getValue(),
+ is((short) (100)));
+ }
+
}
diff --git a/compiler/base/parser/src/test/resources/LengthStatementInsideTypeDef.yang b/compiler/base/parser/src/test/resources/LengthStatementInsideTypeDef.yang
index c1195dc..ad59080 100644
--- a/compiler/base/parser/src/test/resources/LengthStatementInsideTypeDef.yang
+++ b/compiler/base/parser/src/test/resources/LengthStatementInsideTypeDef.yang
@@ -4,12 +4,18 @@
prefix Ant;
typedef invalid-interval {
type string {
- length "1..100";
+ length "1..100" {
+ description "length-description typedef";
+ reference "reference typedef";
+ }
}
}
leaf xyz {
type invalid-interval {
- length "2..100";
+ length "2..100"{
+ description "length-description type";
+ reference "reference type";
+ }
}
}
}
diff --git a/compiler/base/parser/src/test/resources/RangeWithTypedef.yang b/compiler/base/parser/src/test/resources/RangeWithTypedef.yang
new file mode 100644
index 0000000..d885d8c
--- /dev/null
+++ b/compiler/base/parser/src/test/resources/RangeWithTypedef.yang
@@ -0,0 +1,22 @@
+module Test {
+ yang-version 1;
+ namespace http://huawei.com;
+ prefix Ant;
+
+ typedef value {
+ type uint8 {
+ range "1..100" {
+ description "typedef description";
+ reference "typedef reference";
+ }
+ }
+ }
+ leaf invalid-interval {
+ type value {
+ range "2..100" {
+ description "range description";
+ reference "range reference";
+ }
+ }
+ }
+}
diff --git a/compiler/base/parser/src/test/resources/ValidBinaryLengthStatement.yang b/compiler/base/parser/src/test/resources/ValidBinaryLengthStatement.yang
index 7182eb3..349181a 100644
--- a/compiler/base/parser/src/test/resources/ValidBinaryLengthStatement.yang
+++ b/compiler/base/parser/src/test/resources/ValidBinaryLengthStatement.yang
@@ -4,7 +4,10 @@
prefix Ant;
leaf message {
type binary {
- length "4";
+ length "4" {
+ description "binary description";
+ reference "binary reference";
+ }
}
}
}
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterFileLinkingTest.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterFileLinkingTest.java
index 2e70c5a..63c21fe 100644
--- a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterFileLinkingTest.java
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/InterFileLinkingTest.java
@@ -145,9 +145,9 @@
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.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -304,9 +304,9 @@
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.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -463,9 +463,9 @@
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.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -541,9 +541,9 @@
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.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -618,9 +618,9 @@
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.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -692,9 +692,9 @@
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.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileTypeLinkingTest.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileTypeLinkingTest.java
index 85129fa..9cbdb42 100644
--- a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileTypeLinkingTest.java
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/IntraFileTypeLinkingTest.java
@@ -83,9 +83,9 @@
assertThat(derivedInfo.getEffectiveBuiltInType(), Is.is(YangDataTypes.STRING));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+ assertThat(derivedInfo.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -132,9 +132,9 @@
assertThat(derivedInfo.getEffectiveBuiltInType(), Is.is(YangDataTypes.STRING));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+ assertThat(derivedInfo.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -182,9 +182,9 @@
assertThat(derivedInfo.getEffectiveBuiltInType(), Is.is(YangDataTypes.STRING));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+ assertThat(derivedInfo.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -232,9 +232,9 @@
assertThat(derivedInfo.getEffectiveBuiltInType(), Is.is(YangDataTypes.STRING));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+ assertThat(derivedInfo.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -294,9 +294,9 @@
assertThat(derivedInfo.getEffectiveBuiltInType(), Is.is(YangDataTypes.INT32));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+ assertThat(derivedInfo.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -357,9 +357,9 @@
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.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -419,9 +419,9 @@
assertThat(derivedInfo.getEffectiveBuiltInType(), Is.is(YangDataTypes.INT32));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+ assertThat(derivedInfo.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -477,9 +477,9 @@
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.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
@@ -557,9 +557,9 @@
assertThat(derivedInfo.getEffectiveBuiltInType(), Is.is(YangDataTypes.BINARY));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
+ assertThat(derivedInfo.getLengthRes(), is(nullValue()));
+ assertThat(derivedInfo.getRangeRes(), is(nullValue()));
+ assertThat(derivedInfo.getPatternResList(), is(nullValue()));
assertThat(derivedInfo.getResolvedExtendedInfo(), is(nullValue()));
}
}
diff --git a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/RestrictionResolutionTest.java b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/RestrictionResolutionTest.java
index 9908367..af1c648 100644
--- a/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/RestrictionResolutionTest.java
+++ b/compiler/plugin/maven/src/test/java/org/onosproject/yang/compiler/plugin/maven/RestrictionResolutionTest.java
@@ -29,8 +29,6 @@
import org.onosproject.yang.compiler.datamodel.YangType;
import org.onosproject.yang.compiler.datamodel.YangTypeDef;
import org.onosproject.yang.compiler.datamodel.exceptions.DataModelException;
-import org.onosproject.yang.compiler.datamodel.utils.ResolvableStatus;
-import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes;
import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangInt16;
import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangInt32;
import org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangUint64;
@@ -42,12 +40,15 @@
import java.math.BigInteger;
import java.util.ListIterator;
+import static java.math.BigInteger.valueOf;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.IsNull.notNullValue;
import static org.onosproject.yang.compiler.datamodel.YangNodeType.MODULE_NODE;
+import static org.onosproject.yang.compiler.datamodel.utils.ResolvableStatus.RESOLVED;
import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.DERIVED;
+import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.INT16;
import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.INT32;
import static org.onosproject.yang.compiler.datamodel.utils.builtindatatype.YangDataTypes.STRING;
@@ -65,7 +66,8 @@
public void processLengthRestrictionInTypedef()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/LengthRestrictionInTypedef.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/LengthRestrictionInTypedef.yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -77,40 +79,45 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ YangType<?> type = leaf.getDataType();
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
+
+ assertThat(info.getReferredTypeDef(),
Is.is((YangTypeDef) node.getChild()));
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
-
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+ assertThat(info.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(notNullValue()));
+ assertThat(info.getLengthRes(), is(nullValue()));
+ assertThat(info.getRangeRes(), is(nullValue()));
+ assertThat(info.getPatternResList(), is(nullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangStringRestriction stringRestriction = (YangStringRestriction) derivedInfo.getResolvedExtendedInfo();
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
+ YangStringRestriction strRes = (YangStringRestriction) info
+ .getResolvedExtendedInfo();
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
- .listIterator();
+ ListIterator<YangRangeInterval> llIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
- YangRangeInterval rangeInterval = lengthListIterator.next();
+ YangRangeInterval range = llIt.next();
- assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
- assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+ assertThat(((YangUint64) range.getStartValue()).getValue(),
+ is(valueOf(0)));
+ assertThat(((YangUint64) range.getEndValue()).getValue(),
+ is(valueOf(100)));
}
/**
@@ -120,7 +127,8 @@
public void processLengthRestrictionInRefType()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/LengthRestrictionInRefType.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/LengthRestrictionInRefType.yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -132,40 +140,44 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ YangType<?> type = leaf.getDataType();
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
- is((YangTypeDef) node.getChild()));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
+ assertThat(info.getReferredTypeDef(),
+ is((YangTypeDef) node.getChild()));
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
-
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+ assertThat(info.getEffectiveBuiltInType(), is(STRING));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(notNullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
- assertThat(derivedInfo.getResolvedExtendedInfo(), is(notNullValue()));
+ assertThat(info.getLengthRes(), is(notNullValue()));
+ assertThat(info.getRangeRes(), is(nullValue()));
+ assertThat(info.getPatternResList(), is(nullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangStringRestriction stringRestriction = (YangStringRestriction) derivedInfo.getResolvedExtendedInfo();
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
+ YangStringRestriction strRes = (YangStringRestriction) info
+ .getResolvedExtendedInfo();
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
- .listIterator();
+ ListIterator<YangRangeInterval> llIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
- YangRangeInterval rangeInterval = lengthListIterator.next();
+ YangRangeInterval range = llIt.next();
- assertThat(((YangUint64) rangeInterval.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
- assertThat(((YangUint64) rangeInterval.getEndValue()).getValue(), is(BigInteger.valueOf(100)));
+ assertThat(((YangUint64) range.getStartValue()).getValue(),
+ is(valueOf(0)));
+ assertThat(((YangUint64) range.getEndValue()).getValue(),
+ is(valueOf(100)));
}
/**
@@ -175,7 +187,9 @@
public void processLengthRestrictionInTypedefAndTypeValid()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/LengthRestrictionInTypedefAndTypeValid.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/LengthRestrictionInTypedefAndTypeValid." +
+ "yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -187,45 +201,53 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ YangType<?> type = leaf.getDataType();
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
- is((YangTypeDef) node.getChild()));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+ assertThat(info.getReferredTypeDef(),
+ is((YangTypeDef) node.getChild()));
+
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+ assertThat(info.getEffectiveBuiltInType(), is(STRING));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(notNullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
- assertThat(derivedInfo.getResolvedExtendedInfo(), is(notNullValue()));
+ assertThat(info.getLengthRes(), is(notNullValue()));
+ assertThat(info.getRangeRes(), is(nullValue()));
+ assertThat(info.getPatternResList(), is(nullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangStringRestriction stringRestriction = (YangStringRestriction) derivedInfo.getResolvedExtendedInfo();
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
+ YangStringRestriction strRes = (YangStringRestriction) info
+ .getResolvedExtendedInfo();
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
- .listIterator();
+ ListIterator<YangRangeInterval> llIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
- YangRangeInterval rangeInterval1 = lengthListIterator.next();
+ YangRangeInterval range1 = llIt.next();
- assertThat(((YangUint64) rangeInterval1.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
- assertThat(((YangUint64) rangeInterval1.getEndValue()).getValue(), is(BigInteger.valueOf(20)));
+ assertThat(((YangUint64) range1.getStartValue()).getValue(),
+ is(valueOf(0)));
+ assertThat(((YangUint64) range1.getEndValue()).getValue(),
+ is(valueOf(20)));
- YangRangeInterval rangeInterval2 = lengthListIterator.next();
+ YangRangeInterval range2 = llIt.next();
- assertThat(((YangUint64) rangeInterval2.getStartValue()).getValue(), is(BigInteger.valueOf(201)));
- assertThat(((YangUint64) rangeInterval2.getEndValue()).getValue(), is(BigInteger.valueOf(300)));
+ assertThat(((YangUint64) range2.getStartValue()).getValue(),
+ is(valueOf(201)));
+ assertThat(((YangUint64) range2.getEndValue()).getValue(),
+ is(valueOf(300)));
}
/**
@@ -234,7 +256,8 @@
@Test(expected = LinkerException.class)
public void processLengthRestrictionInTypedefAndTypeInValid()
throws IOException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/LengthRestrictionInTypedefAndTypeInValid.yang");
+ manager.getDataModel("src/test/resources/LengthRestrictionInTypedef" +
+ "AndTypeInValid.yang");
}
/**
@@ -244,7 +267,8 @@
public void processRangeRestrictionInTypedef()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/RangeRestrictionInTypedef.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/RangeRestrictionInTypedef.yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -256,44 +280,48 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ YangType<?> type = leaf.getDataType();
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
- is((YangTypeDef) node.getChild()));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+ assertThat(info.getReferredTypeDef(),
+ is((YangTypeDef) node.getChild()));
+
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(INT32));
+ assertThat(info.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(notNullValue()));
+ assertThat(info.getLengthRes(), is(nullValue()));
+ assertThat(info.getRangeRes(), is(nullValue()));
+ assertThat(info.getPatternResList(), is(nullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangRangeRestriction rangeRestriction = (YangRangeRestriction) derivedInfo.getResolvedExtendedInfo();
+ YangRangeRestriction ranRes = (YangRangeRestriction) info
+ .getResolvedExtendedInfo();
- ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
- .listIterator();
+ ListIterator<YangRangeInterval> rlIt = ranRes
+ .getAscendingRangeIntervals().listIterator();
- YangRangeInterval rangeInterval1 = rangeListIterator.next();
+ YangRangeInterval range1 = rlIt.next();
- assertThat(((YangInt32) rangeInterval1.getStartValue()).getValue(), is(1));
- assertThat(((YangInt32) rangeInterval1.getEndValue()).getValue(), is(4));
+ assertThat(((YangInt32) range1.getStartValue()).getValue(), is(1));
+ assertThat(((YangInt32) range1.getEndValue()).getValue(), is(4));
- YangRangeInterval rangeInterval2 = rangeListIterator.next();
+ YangRangeInterval range2 = rlIt.next();
- assertThat(((YangInt32) rangeInterval2.getStartValue()).getValue(), is(10));
- assertThat(((YangInt32) rangeInterval2.getEndValue()).getValue(), is(20));
+ assertThat(((YangInt32) range2.getStartValue()).getValue(), is(10));
+ assertThat(((YangInt32) range2.getEndValue()).getValue(), is(20));
}
/**
@@ -303,7 +331,8 @@
public void processRangeRestrictionInRefTypedef()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/RangeRestrictionInRefTypedef.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/RangeRestrictionInRefTypedef.yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -316,47 +345,55 @@
assertThat(yangNode.getName(), is("Test"));
// check top typedef
- YangTypeDef topTypedef = (YangTypeDef) yangNode.getChild();
- assertThat(topTypedef.getName(), is("Num3"));
- YangType type = topTypedef.getTypeList().iterator().next();
- assertThat(type.getDataType(), is(YangDataTypes.INT16));
+ YangTypeDef typeDef1 = (YangTypeDef) yangNode.getChild();
+ assertThat(typeDef1.getName(), is("Num3"));
+ YangType type = typeDef1.getTypeList().iterator().next();
+ assertThat(type.getDataType(), is(INT16));
assertThat(type.getDataTypeName(), is("int16"));
// Check for the restriction value.
- YangRangeRestriction rangeRestriction = (YangRangeRestriction) type.getDataTypeExtendedInfo();
- ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
- .listIterator();
- YangRangeInterval rangeInterval1 = rangeListIterator.next();
- assertThat((int) ((YangInt16) rangeInterval1.getStartValue()).getValue(), is(-32000));
- assertThat((int) ((YangInt16) rangeInterval1.getEndValue()).getValue(), is(4));
+ YangRangeRestriction ranRes = (YangRangeRestriction) type.
+ getDataTypeExtendedInfo();
+ ListIterator<YangRangeInterval> rlIt = ranRes
+ .getAscendingRangeIntervals().listIterator();
+ YangRangeInterval range1 = rlIt.next();
+ assertThat((int) ((YangInt16) range1.getStartValue()).getValue(),
+ is(-32000));
+ assertThat((int) ((YangInt16) range1.getEndValue()).getValue(), is(4));
- YangRangeInterval rangeInterval2 = rangeListIterator.next();
- assertThat((int) ((YangInt16) rangeInterval2.getStartValue()).getValue(), is(32767));
- assertThat((int) ((YangInt16) rangeInterval2.getEndValue()).getValue(), is(32767));
+ YangRangeInterval range2 = rlIt.next();
+ assertThat((int) ((YangInt16) range2.getStartValue()).getValue(),
+ is(32767));
+ assertThat((int) ((YangInt16) range2.getEndValue()).getValue(),
+ is(32767));
// check referred typedef
- YangTypeDef refTypedef = (YangTypeDef) topTypedef.getNextSibling();
+ YangTypeDef refTypedef = (YangTypeDef) typeDef1.getNextSibling();
assertThat(refTypedef.getName(), is("Num6"));
YangType refType = refTypedef.getTypeList().iterator().next();
- assertThat(refType.getDataType(), is(YangDataTypes.DERIVED));
+ assertThat(refType.getDataType(), is(DERIVED));
assertThat(refType.getDataTypeName(), is("Num3"));
- YangDerivedInfo<YangRangeRestriction> derivedInfo =
- (YangDerivedInfo<YangRangeRestriction>) refType.getDataTypeExtendedInfo();
+ YangDerivedInfo<YangRangeRestriction> info =
+ (YangDerivedInfo<YangRangeRestriction>) refType
+ .getDataTypeExtendedInfo();
// Check for the restriction value.
- rangeRestriction = (YangRangeRestriction) derivedInfo.getResolvedExtendedInfo();
- rangeListIterator = rangeRestriction.getAscendingRangeIntervals().listIterator();
- rangeInterval1 = rangeListIterator.next();
- assertThat((int) ((YangInt16) rangeInterval1.getStartValue()).getValue(), is(-3));
- assertThat((int) ((YangInt16) rangeInterval1.getEndValue()).getValue(), is(-3));
+ ranRes = info.getResolvedExtendedInfo();
+ rlIt = ranRes.getAscendingRangeIntervals().listIterator();
+ range1 = rlIt.next();
+ assertThat((int) ((YangInt16) range1.getStartValue()).getValue(),
+ is(-3));
+ assertThat((int) ((YangInt16) range1.getEndValue()).getValue(), is(-3));
- rangeInterval2 = rangeListIterator.next();
- assertThat((int) ((YangInt16) rangeInterval2.getStartValue()).getValue(), is(-2));
- assertThat((int) ((YangInt16) rangeInterval2.getEndValue()).getValue(), is(2));
+ range2 = rlIt.next();
+ assertThat((int) ((YangInt16) range2.getStartValue()).getValue(),
+ is(-2));
+ assertThat((int) ((YangInt16) range2.getEndValue()).getValue(), is(2));
- YangRangeInterval rangeInterval3 = rangeListIterator.next();
- assertThat((int) ((YangInt16) rangeInterval3.getStartValue()).getValue(), is(3));
- assertThat((int) ((YangInt16) rangeInterval3.getEndValue()).getValue(), is(3));
+ YangRangeInterval range3 = rlIt.next();
+ assertThat((int) ((YangInt16) range3.getStartValue()).getValue(),
+ is(3));
+ assertThat((int) ((YangInt16) range3.getEndValue()).getValue(), is(3));
}
/**
@@ -365,8 +402,8 @@
@Test(expected = LinkerException.class)
public void processInvalidRangeRestrictionInRefTypedef()
throws IOException, ParserException, DataModelException {
-
- manager.getDataModel("src/test/resources/RangeRestrictionInvalidInRefTypedef.yang");
+ manager.getDataModel("src/test/resources/RangeRestrictionInvalidIn" +
+ "RefTypedef.yang");
}
/**
@@ -376,7 +413,8 @@
public void processRangeRestrictionInRefType()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/RangeRestrictionInRefType.yang");
+ YangNode node = manager.getDataModel("src/test/resources/RangeRes" +
+ "trictionInRefType.yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -388,44 +426,48 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ YangType<?> type = leaf.getDataType();
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
- is((YangTypeDef) node.getChild()));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+ assertThat(info.getReferredTypeDef(),
+ is((YangTypeDef) node.getChild()));
+
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(INT32));
+ assertThat(info.getEffectiveBuiltInType(), is(INT32));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(notNullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
- assertThat(derivedInfo.getResolvedExtendedInfo(), is(notNullValue()));
+ assertThat(info.getLengthRes(), is(nullValue()));
+ assertThat(info.getRangeRes(), is(notNullValue()));
+ assertThat(info.getPatternResList(), is(nullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangRangeRestriction rangeRestriction = (YangRangeRestriction) derivedInfo.getResolvedExtendedInfo();
+ YangRangeRestriction ranRes = (YangRangeRestriction) info
+ .getResolvedExtendedInfo();
- ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
- .listIterator();
+ ListIterator<YangRangeInterval> rlIt = ranRes
+ .getAscendingRangeIntervals().listIterator();
- YangRangeInterval rangeInterval1 = rangeListIterator.next();
+ YangRangeInterval range1 = rlIt.next();
- assertThat(((YangInt32) rangeInterval1.getStartValue()).getValue(), is(1));
- assertThat(((YangInt32) rangeInterval1.getEndValue()).getValue(), is(4));
+ assertThat(((YangInt32) range1.getStartValue()).getValue(), is(1));
+ assertThat(((YangInt32) range1.getEndValue()).getValue(), is(4));
- YangRangeInterval rangeInterval2 = rangeListIterator.next();
+ YangRangeInterval range2 = rlIt.next();
- assertThat(((YangInt32) rangeInterval2.getStartValue()).getValue(), is(10));
- assertThat(((YangInt32) rangeInterval2.getEndValue()).getValue(), is(20));
+ assertThat(((YangInt32) range2.getStartValue()).getValue(), is(10));
+ assertThat(((YangInt32) range2.getEndValue()).getValue(), is(20));
}
/**
@@ -435,7 +477,9 @@
public void processRangeRestrictionInRefTypeAndTypedefValid()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/RangeRestrictionInRefTypeAndTypedefValid.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/RangeRestrictionInRefTypeAndTypedef" +
+ "Valid.yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -447,44 +491,48 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ YangType<?> type = leaf.getDataType();
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
- is((YangTypeDef) node.getChild()));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+ assertThat(info.getReferredTypeDef(),
+ is((YangTypeDef) node.getChild()));
+
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(INT32));
+ assertThat(info.getEffectiveBuiltInType(), is(INT32));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(notNullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(nullValue()));
- assertThat(derivedInfo.getResolvedExtendedInfo(), is(notNullValue()));
+ assertThat(info.getLengthRes(), is(nullValue()));
+ assertThat(info.getRangeRes(), is(notNullValue()));
+ assertThat(info.getPatternResList(), is(nullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangRangeRestriction rangeRestriction = (YangRangeRestriction) derivedInfo.getResolvedExtendedInfo();
+ YangRangeRestriction ranRes = (YangRangeRestriction) info
+ .getResolvedExtendedInfo();
- ListIterator<YangRangeInterval> rangeListIterator = rangeRestriction.getAscendingRangeIntervals()
- .listIterator();
+ ListIterator<YangRangeInterval> rlIt = ranRes
+ .getAscendingRangeIntervals().listIterator();
- YangRangeInterval rangeInterval1 = rangeListIterator.next();
+ YangRangeInterval range1 = rlIt.next();
- assertThat(((YangInt32) rangeInterval1.getStartValue()).getValue(), is(1));
- assertThat(((YangInt32) rangeInterval1.getEndValue()).getValue(), is(4));
+ assertThat(((YangInt32) range1.getStartValue()).getValue(), is(1));
+ assertThat(((YangInt32) range1.getEndValue()).getValue(), is(4));
- YangRangeInterval rangeInterval2 = rangeListIterator.next();
+ YangRangeInterval range2 = rlIt.next();
- assertThat(((YangInt32) rangeInterval2.getStartValue()).getValue(), is(10));
- assertThat(((YangInt32) rangeInterval2.getEndValue()).getValue(), is(20));
+ assertThat(((YangInt32) range2.getStartValue()).getValue(), is(10));
+ assertThat(((YangInt32) range2.getEndValue()).getValue(), is(20));
}
/**
@@ -493,7 +541,8 @@
@Test(expected = LinkerException.class)
public void processRangeRestrictionInRefTypeAndTypedefInValid()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/RangeRestrictionInRefTypeAndTypedefInValid.yang");
+ manager.getDataModel("src/test/resources/RangeRestrictionInRefType" +
+ "AndTypedefInValid.yang");
}
/**
@@ -502,7 +551,8 @@
@Test(expected = ParserException.class)
public void processRangeRestrictionInString()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/RangeRestrictionInString.yang");
+ manager.getDataModel("src/test/resources/RangeRestrictionInString." +
+ "yang");
}
/**
@@ -511,7 +561,8 @@
@Test(expected = LinkerException.class)
public void processRangeRestrictionInStringInRefType()
throws IOException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/RangeRestrictionInStringInRefType.yang");
+ manager.getDataModel("src/test/resources/RangeRestrictionInStringIn" +
+ "RefType.yang");
}
/**
@@ -521,7 +572,8 @@
public void processPatternRestrictionInTypedef()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/PatternRestrictionInTypedef.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/PatternRestrictionInTypedef.yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -533,37 +585,40 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
+ YangType<?> type = leaf.getDataType();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
- is((YangTypeDef) node.getChild()));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
+ YangTypeDef typeDef = info.getReferredTypeDef();
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
+ assertThat(typeDef, is((YangTypeDef) node.getChild()));
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
+
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+ assertThat(info.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(notNullValue()));
+ assertThat(info.getLengthRes(), is(nullValue()));
+ assertThat(info.getRangeRes(), is(nullValue()));
+ assertThat(info.getPatternResList(), is(nullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangStringRestriction stringRestriction = (YangStringRestriction) derivedInfo.getResolvedExtendedInfo();
- YangPatternRestriction patternRestriction = stringRestriction.getPatternRestriction();
+ YangStringRestriction strRes = (YangStringRestriction) info
+ .getResolvedExtendedInfo();
+ ListIterator<YangPatternRestriction> patIt = strRes
+ .getPatternResList().listIterator();
+ YangPatternRestriction pattern1 = patIt.next();
- ListIterator<String> patternListIterator = patternRestriction.getPatternList().listIterator();
- String pattern1 = patternListIterator.next();
-
- assertThat(pattern1, is("[a-zA-Z]"));
+ assertThat(pattern1.getPattern(), is("[a-zA-Z]"));
}
/**
@@ -573,7 +628,8 @@
public void processPatternRestrictionInRefType()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/PatternRestrictionInRefType.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/PatternRestrictionInRefType.yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -585,37 +641,38 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
+ YangType<?> type = leaf.getDataType();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
- is((YangTypeDef) node.getChild()));
+ assertThat(info.getReferredTypeDef(),
+ is((YangTypeDef) node.getChild()));
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
-
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+ assertThat(info.getEffectiveBuiltInType(), is(STRING));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(notNullValue()));
- assertThat(derivedInfo.getResolvedExtendedInfo(), is(notNullValue()));
+ assertThat(info.getLengthRes(), is(nullValue()));
+ assertThat(info.getRangeRes(), is(nullValue()));
+ assertThat(info.getPatternResList(), is(notNullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangStringRestriction stringRestriction = (YangStringRestriction) derivedInfo.getResolvedExtendedInfo();
- YangPatternRestriction patternRestriction = stringRestriction.getPatternRestriction();
+ YangStringRestriction strRes = (YangStringRestriction) info
+ .getResolvedExtendedInfo();
+ ListIterator<YangPatternRestriction> patIt = strRes
+ .getPatternResList().listIterator();
+ YangPatternRestriction pattern1 = patIt.next();
- ListIterator<String> patternListIterator = patternRestriction.getPatternList().listIterator();
- String pattern1 = patternListIterator.next();
-
- assertThat(pattern1, is("[a-zA-Z]"));
+ assertThat(pattern1.getPattern(), is("[a-zA-Z]"));
}
/**
@@ -625,7 +682,9 @@
public void processPatternRestrictionInRefTypeAndTypedef()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/PatternRestrictionInRefTypeAndTypedef.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/PatternRestrictionInRefTypeAndTypedef" +
+ ".yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -637,41 +696,40 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
+ YangType<?> type = leaf.getDataType();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
- is((YangTypeDef) node.getChild()));
+ assertThat(info.getReferredTypeDef(),
+ is((YangTypeDef) node.getChild()));
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
-
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+ assertThat(info.getEffectiveBuiltInType(), is(STRING));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(notNullValue()));
- assertThat(derivedInfo.getResolvedExtendedInfo(), is(notNullValue()));
+ assertThat(info.getLengthRes(), is(nullValue()));
+ assertThat(info.getRangeRes(), is(nullValue()));
+ assertThat(info.getPatternResList(), is(notNullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangStringRestriction stringRestriction = (YangStringRestriction) derivedInfo.getResolvedExtendedInfo();
- YangPatternRestriction patternRestriction = stringRestriction.getPatternRestriction();
+ YangStringRestriction strRes = (YangStringRestriction) info
+ .getResolvedExtendedInfo();
+ ListIterator<YangPatternRestriction> patIt = strRes
+ .getPatternResList().listIterator();
+ YangPatternRestriction pattern1 = patIt.next();
+ assertThat(pattern1.getPattern(), is("[a-zA-Z]"));
- ListIterator<String> patternListIterator = patternRestriction.getPatternList().listIterator();
- String pattern1 = patternListIterator.next();
-
- assertThat(pattern1, is("[a-zA-Z]"));
-
- String pattern2 = patternListIterator.next();
-
- assertThat(pattern2, is("[0-9]"));
+ YangPatternRestriction pattern2 = patIt.next();
+ assertThat(pattern2.getPattern(), is("[0-9]"));
}
/**
@@ -681,7 +739,9 @@
public void processMultiplePatternRestriction()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/MultiplePatternRestrictionInRefTypeAndTypedef.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/MultiplePatternRestrictionInRefTypeAnd" +
+ "Typedef.yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -693,49 +753,46 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
+ YangType<?> type = leaf.getDataType();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
- is((YangTypeDef) node.getChild()));
+ assertThat(info.getReferredTypeDef(),
+ is((YangTypeDef) node.getChild()));
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
-
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+ assertThat(info.getEffectiveBuiltInType(), is(STRING));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(notNullValue()));
- assertThat(derivedInfo.getResolvedExtendedInfo(), is(notNullValue()));
+ assertThat(info.getLengthRes(), is(nullValue()));
+ assertThat(info.getRangeRes(), is(nullValue()));
+ assertThat(info.getPatternResList(), is(notNullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangStringRestriction stringRestriction = (YangStringRestriction) derivedInfo.getResolvedExtendedInfo();
- YangPatternRestriction patternRestriction = stringRestriction.getPatternRestriction();
+ YangStringRestriction strRes = (YangStringRestriction) info
+ .getResolvedExtendedInfo();
+ ListIterator<YangPatternRestriction> patIt = strRes
+ .getPatternResList().listIterator();
+ YangPatternRestriction pattern1 = patIt.next();
+ assertThat(pattern1.getPattern(), is("[a-z]"));
- ListIterator<String> patternListIterator = patternRestriction.getPatternList().listIterator();
- String pattern1 = patternListIterator.next();
+ YangPatternRestriction pattern2 = patIt.next();
+ assertThat(pattern2.getPattern(), is("[A-Z]"));
- assertThat(pattern1, is("[a-z]"));
+ YangPatternRestriction pattern3 = patIt.next();
+ assertThat(pattern3.getPattern(), is("[0-9]"));
- String pattern2 = patternListIterator.next();
-
- assertThat(pattern2, is("[A-Z]"));
-
- String pattern3 = patternListIterator.next();
-
- assertThat(pattern3, is("[0-9]"));
-
- String pattern4 = patternListIterator.next();
-
- assertThat(pattern4, is("[\\n]"));
+ YangPatternRestriction pattern4 = patIt.next();
+ assertThat(pattern4.getPattern(), is("[\\n]"));
}
/**
@@ -746,7 +803,8 @@
public void processMultiplePatternAndLengthRestriction()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/MultiplePatternAndLengthRestriction.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/MultiplePatternAndLengthRestriction.yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -758,65 +816,78 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
+ YangType<?> type = leaf.getDataType();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
- is((YangTypeDef) node.getChild()));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
+ assertThat(info.getReferredTypeDef(),
+ is((YangTypeDef) node.getChild()));
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+ assertThat(info.getEffectiveBuiltInType(), is(STRING));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(notNullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(notNullValue()));
- assertThat(derivedInfo.getResolvedExtendedInfo(), is(notNullValue()));
+ assertThat(info.getLengthRes(), is(notNullValue()));
+ assertThat(info.getRangeRes(), is(nullValue()));
+ assertThat(info.getPatternResList(), is(notNullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangStringRestriction stringRestriction = (YangStringRestriction) derivedInfo.getResolvedExtendedInfo();
+ YangStringRestriction strRes = (YangStringRestriction) info
+ .getResolvedExtendedInfo();
+ ListIterator<YangPatternRestriction> patIt = strRes
+ .getPatternResList().listIterator();
+ YangPatternRestriction pattern1 = patIt.next();
+ assertThat(pattern1.getPattern(), is("[a-z]"));
+ assertThat(pattern1.getDescription(),
+ is("\"pattern a-z description.\""));
+ assertThat(pattern1.getReference(), is("\"a-z reference\""));
- // Check for pattern restriction.
- YangPatternRestriction patternRestriction = stringRestriction.getPatternRestriction();
- ListIterator<String> patternListIterator = patternRestriction.getPatternList().listIterator();
- String pattern1 = patternListIterator.next();
+ YangPatternRestriction pattern2 = patIt.next();
+ assertThat(pattern2.getPattern(), is("[A-Z]"));
+ assertThat(pattern2.getDescription(),
+ is("\"pattern A-Z description.\""));
+ assertThat(pattern2.getReference(), is("\"A-Z reference\""));
- assertThat(pattern1, is("[a-z]"));
+ YangPatternRestriction pattern3 = patIt.next();
+ assertThat(pattern3.getPattern(), is("[0-9]"));
+ assertThat(pattern3.getDescription(),
+ is("\"pattern 0-9 description.\""));
+ assertThat(pattern3.getReference(), is("\"0-9 reference\""));
- String pattern2 = patternListIterator.next();
-
- assertThat(pattern2, is("[A-Z]"));
-
- String pattern3 = patternListIterator.next();
-
- assertThat(pattern3, is("[0-9]"));
-
- String pattern4 = patternListIterator.next();
-
- assertThat(pattern4, is("[\\n]"));
+ YangPatternRestriction pattern4 = patIt.next();
+ assertThat(pattern4.getPattern(), is("[\\n]"));
+ assertThat(pattern4.getDescription(),
+ is("\"pattern \\n description.\""));
+ assertThat(pattern4.getReference(), is("\"\\n reference\""));
// Check for length restriction.
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
- .listIterator();
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
+ ListIterator<YangRangeInterval> lenIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
- YangRangeInterval rangeInterval1 = lengthListIterator.next();
+ YangRangeInterval range1 = lenIt.next();
- assertThat(((YangUint64) rangeInterval1.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
- assertThat(((YangUint64) rangeInterval1.getEndValue()).getValue(), is(BigInteger.valueOf(20)));
+ assertThat(((YangUint64) range1.getStartValue()).getValue(),
+ is(valueOf(0)));
+ assertThat(((YangUint64) range1.getEndValue()).getValue(),
+ is(valueOf(20)));
- YangRangeInterval rangeInterval2 = lengthListIterator.next();
+ YangRangeInterval range2 = lenIt.next();
- assertThat(((YangUint64) rangeInterval2.getStartValue()).getValue(), is(BigInteger.valueOf(201)));
- assertThat(((YangUint64) rangeInterval2.getEndValue()).getValue(), is(BigInteger.valueOf(300)));
+ assertThat(((YangUint64) range2.getStartValue()).getValue(),
+ is(valueOf(201)));
+ assertThat(((YangUint64) range2.getEndValue()).getValue(),
+ is(valueOf(300)));
}
/**
@@ -827,7 +898,9 @@
public void processMultiplePatternAndLengthRestrictionValid()
throws IOException, ParserException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/MultiplePatternAndLengthRestrictionValid.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/MultiplePatternAndLengthRestric" +
+ "tionValid.yang");
// Check whether the data model tree returned is of type module.
assertThat(node instanceof YangModule, is(true));
@@ -839,66 +912,66 @@
YangModule yangNode = (YangModule) node;
assertThat(yangNode.getName(), is("Test"));
- ListIterator<YangLeaf> leafIterator = yangNode.getListOfLeaf().listIterator();
- YangLeaf leafInfo = leafIterator.next();
+ ListIterator<YangLeaf> it = yangNode.getListOfLeaf().listIterator();
+ YangLeaf leaf = it.next();
+ YangType<?> type = leaf.getDataType();
- assertThat(leafInfo.getName(), is("invalid-interval"));
- assertThat(leafInfo.getDataType().getDataTypeName(), is("hello"));
- assertThat(leafInfo.getDataType().getDataType(), is(DERIVED));
+ assertThat(leaf.getName(), is("invalid-interval"));
+ assertThat(type.getDataTypeName(), is("hello"));
+ assertThat(type.getDataType(), is(DERIVED));
+ YangDerivedInfo<?> info = (YangDerivedInfo<?>) type
+ .getDataTypeExtendedInfo();
- assertThat(((YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo()).getReferredTypeDef(),
- is((YangTypeDef) node.getChild()));
+ assertThat(info.getReferredTypeDef(),
+ is((YangTypeDef) node.getChild()));
- assertThat(leafInfo.getDataType().getResolvableStatus(), Is.is(ResolvableStatus.RESOLVED));
-
- YangDerivedInfo<?> derivedInfo = (YangDerivedInfo<?>) leafInfo.getDataType().getDataTypeExtendedInfo();
+ assertThat(type.getResolvableStatus(), Is.is(RESOLVED));
// Check for the effective built-in type.
- assertThat(derivedInfo.getEffectiveBuiltInType(), is(STRING));
+ assertThat(info.getEffectiveBuiltInType(), is(STRING));
// Check for the restriction.
- assertThat(derivedInfo.getLengthRestrictionString(), is(notNullValue()));
- assertThat(derivedInfo.getRangeRestrictionString(), is(nullValue()));
- assertThat(derivedInfo.getPatternRestriction(), is(notNullValue()));
- assertThat(derivedInfo.getResolvedExtendedInfo(), is(notNullValue()));
+ assertThat(info.getLengthRes(), is(notNullValue()));
+ assertThat(info.getRangeRes(), is(nullValue()));
+ assertThat(info.getPatternResList(), is(notNullValue()));
+ assertThat(info.getResolvedExtendedInfo(), is(notNullValue()));
// Check for the restriction value.
- YangStringRestriction stringRestriction = (YangStringRestriction) derivedInfo.getResolvedExtendedInfo();
+ YangStringRestriction strRes = (YangStringRestriction) info
+ .getResolvedExtendedInfo();
- // Check for pattern restriction.
- YangPatternRestriction patternRestriction = stringRestriction.getPatternRestriction();
- ListIterator<String> patternListIterator = patternRestriction.getPatternList().listIterator();
- String pattern1 = patternListIterator.next();
+ ListIterator<YangPatternRestriction> patIt = strRes
+ .getPatternResList().listIterator();
+ YangPatternRestriction pattern1 = patIt.next();
+ assertThat(pattern1.getPattern(), is("[a-z]"));
- assertThat(pattern1, is("[a-z]"));
+ YangPatternRestriction pattern2 = patIt.next();
+ assertThat(pattern2.getPattern(), is("[A-Z]"));
- String pattern2 = patternListIterator.next();
+ YangPatternRestriction pattern3 = patIt.next();
+ assertThat(pattern3.getPattern(), is("[0-9]"));
- assertThat(pattern2, is("[A-Z]"));
-
- String pattern3 = patternListIterator.next();
-
- assertThat(pattern3, is("[0-9]"));
-
- String pattern4 = patternListIterator.next();
-
- assertThat(pattern4, is("[\\n]"));
+ YangPatternRestriction pattern4 = patIt.next();
+ assertThat(pattern4.getPattern(), is("[\\n]"));
// Check for length restriction.
- YangRangeRestriction lengthRestriction = stringRestriction.getLengthRestriction();
- ListIterator<YangRangeInterval> lengthListIterator = lengthRestriction.getAscendingRangeIntervals()
- .listIterator();
+ YangRangeRestriction lenRes = strRes.getLengthRestriction();
+ ListIterator<YangRangeInterval> lenIt = lenRes
+ .getAscendingRangeIntervals().listIterator();
- YangRangeInterval rangeInterval1 = lengthListIterator.next();
+ YangRangeInterval range1 = lenIt.next();
- assertThat(((YangUint64) rangeInterval1.getStartValue()).getValue(), is(BigInteger.valueOf(0)));
- assertThat(((YangUint64) rangeInterval1.getEndValue()).getValue(), is(BigInteger.valueOf(20)));
+ assertThat(((YangUint64) range1.getStartValue()).getValue(),
+ is(valueOf(0)));
+ assertThat(((YangUint64) range1.getEndValue()).getValue(),
+ is(valueOf(20)));
- YangRangeInterval rangeInterval2 = lengthListIterator.next();
+ YangRangeInterval range2 = lenIt.next();
- assertThat(((YangUint64) rangeInterval2.getStartValue()).getValue(), is(BigInteger.valueOf(100)));
- assertThat(((YangUint64) rangeInterval2.getEndValue()).getValue(),
- is(new BigInteger("18446744073709551615")));
+ assertThat(((YangUint64) range2.getStartValue()).getValue(),
+ is(valueOf(100)));
+ assertThat(((YangUint64) range2.getEndValue()).getValue(),
+ is(new BigInteger("18446744073709551615")));
}
/**
@@ -908,6 +981,8 @@
@Test(expected = LinkerException.class)
public void processMultiplePatternAndLengthRestrictionInValid()
throws IOException, DataModelException {
- YangNode node = manager.getDataModel("src/test/resources/MultiplePatternAndLengthRestrictionInValid.yang");
+ YangNode node = manager.getDataModel(
+ "src/test/resources/MultiplePatternAndLengthRestriction" +
+ "InValid.yang");
}
}
diff --git a/compiler/plugin/maven/src/test/resources/MultiplePatternAndLengthRestriction.yang b/compiler/plugin/maven/src/test/resources/MultiplePatternAndLengthRestriction.yang
index d971643..b6e8e51 100644
--- a/compiler/plugin/maven/src/test/resources/MultiplePatternAndLengthRestriction.yang
+++ b/compiler/plugin/maven/src/test/resources/MultiplePatternAndLengthRestriction.yang
@@ -4,15 +4,27 @@
prefix Ant;
leaf invalid-interval {
type hello {
- pattern "[a-z]";
- pattern "[A-Z]";
+ pattern "[a-z]" {
+ description "pattern a-z description.";
+ reference "a-z reference";
+ }
+ pattern "[A-Z]" {
+ description "pattern A-Z description.";
+ reference "A-Z reference";
+ }
length "min..20 | 201..max";
}
}
typedef hello {
type string {
- pattern "[0-9]";
- pattern "[\n]";
+ pattern "[0-9]" {
+ description "pattern 0-9 description.";
+ reference "0-9 reference";
+ }
+ pattern "[\n]" {
+ description "pattern \n description.";
+ reference "\n reference";
+ }
length "0..100 | 101..200 | 201..300";
}
}