[ONOS-6677] Description in pattern statement
Change-Id: Iacdd3ac0cafe6b39eaa4ba463d5c25a72aa50549
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";
+ }
}
}
}