public void QuestionTypeTest()
{
var form = QLParserHelper.Parse(_formRaw);
var firstQuestion = form.Children[0] as QuestionNode;
Assert.AreEqual(QValueType.BOOLEAN, firstQuestion.ValueType);
}
public void InvalidComparisonTest()
{
//TODO: Don't know how to detect this error yet!
FormNode form = QLParserHelper.Parse(_invalidFormRaw);
Assert.Fail();
}
static void Main(string[] args)
{
Console.WriteLine("---- Start parsing the QL ----");
FormNode ql = QLParserHelper.Parse(Util.FileToString(QLFile));
QLPrinter.Print(ql);
Console.WriteLine();
Console.WriteLine("---- Start parsing QLS ----");
QLSNode qls = QLSParserHelper.Parse(Util.FileToString(QLSFile));
QLSPrinter.Print(qls);
Analyser.Analyse(ql, qls);
var errors = Analyser.GetErrors();
Console.WriteLine("\n\n---- Errors and/or warnings: {0} ----", errors.Count);
foreach (string error in errors)
{
Console.WriteLine(error);
}
Console.ReadLine();
}
static void Main(string[] args)
{
string[] lines = System.IO.File.ReadAllLines(@"..\..\..\QLParserTester\Questionnaire.gl");
StringBuilder builder = new StringBuilder();
foreach (string line in lines)
{
builder.AppendLine(line);
}
Console.WriteLine("Start parsing the QL");
FormNode form = QLParserHelper.Parse(builder.ToString());
PrintForm(form);
Analyser.Analyse(form);
var errors = Analyser.GetErrors();
Console.WriteLine("\n\n---- Errors: {0} ----", errors.Count);
foreach (string error in errors)
{
Console.WriteLine(error);
}
Console.ReadLine();
}
public void SimpleComparisonWithNumbersTest()
{
FormNode form = QLParserHelper.Parse(_simpleComparionWithNumbersFormRaw);
var comparisonNode = form.Children
.Where(x => x.Type == NodeType.CONDITIONAL)
.Select(x => x as ConditionalNode)
.First().Expression as ComparisonExpressionNode;
var left = comparisonNode.Left as IdentifierNode;
var opr = comparisonNode.Operator;
var right = comparisonNode.Right as ArthimetricExpressionNode;
Assert.AreEqual("sellingPrice", left.ID);
Assert.AreEqual(ComparisonOperator.LT, opr);
var arthLeft = right.Left as LiteralNode;
var arthOpr = right.Operator;
var arthRight = right.Right as LiteralNode;
Assert.AreEqual("50", arthLeft.Value);
Assert.AreEqual(QValueType.INTEGER, arthLeft.QValueType);
Assert.AreEqual(ArthimetricOperator.MULT, arthOpr);
Assert.AreEqual("20", arthRight.Value);
Assert.AreEqual(QValueType.INTEGER, arthRight.QValueType);
}
public void QuestionTextTest()
{
var form = QLParserHelper.Parse(_formRaw);
var firstQuestion = form.Children[0] as QuestionNode;
Assert.AreEqual("Have you sold a house in 2010?", firstQuestion.Text);
}
public void RandomCharsTest()
{
FormNode randomCharForm = QLParserHelper.Parse(FormExamples.RandomChars);
var isValid = Analyser.Analyse(randomCharForm);
Assert.IsFalse(isValid);
}
public void QuestionIDTest()
{
var form = QLParserHelper.Parse(_formRaw);
var firstQuestion = form.Children[0] as QuestionNode;
Assert.AreEqual("hasSoldAHouse", firstQuestion.ID);
}
public void Initialize()
{
OneVarForm = QLParserHelper.Parse(_oneVarFormRaw);
MultipleVarForm = QLParserHelper.Parse(_multipleVarFormRaw);
SymbolTable.Reset();
Analyser.Reset();
}
public void Initialize()
{
_simpleForm = QLParserHelper.Parse(_simpleFormRaw);
_complexeForm = QLParserHelper.Parse(_complexFormRaw);
_nestedStatementForm = QLParserHelper.Parse(_nestedStatementsFormRaw);
_simpleLiteralTrueForm = QLParserHelper.Parse(_simpleLiteralTrueFormRaw);
_simpleLiteralFalseForm = QLParserHelper.Parse(_simpleLiteralFalseFormRaw);
_complexLiteralForm = QLParserHelper.Parse(_complexLiteralFormRaw);
}
protected FormManager OnlyQL(string rawQL, ElementManagerController elementManagerController, ref List <string> errors)
{
FormNode formNode = QLParserHelper.Parse(rawQL);
if (!Analyser.Analyse(formNode))
{
errors.AddRange(Analyser.GetErrors());
return(null);
}
return(ElementManagerFactory.CreateForm(formNode, elementManagerController));
}
public void MultiplicationsWithVarsTest()
{
FormNode form = QLParserHelper.Parse(_simpleComparionWithNumbersAndVarsFormRaw);
var comparisonNode = form.Children
.Where(x => x.Type == NodeType.CONDITIONAL)
.Select(x => x as ConditionalNode)
.First().Expression as ComparisonExpressionNode;
var arthimetric = comparisonNode.Right as ArthimetricExpressionNode;
Assert.AreEqual(NodeType.IDENTIFIER, arthimetric.Left.GetNodeType());
Assert.AreEqual(ArthimetricOperator.MULT, arthimetric.Operator);
Assert.AreEqual(NodeType.LITERAL, arthimetric.Right.GetNodeType());
}
public void TwoTimesFailedTest()
{
var ql = QLParserHelper.Parse(simpleQLRaw);
var result1 = Analyser.Analyse(ql);
Assert.IsTrue(result1);
Assert.AreEqual(0, Analyser.GetErrors().Count);
var ql2 = QLParserHelper.Parse(simpleQLRaw);
var result2 = Analyser.Analyse(ql2);
Assert.AreEqual(0, Analyser.GetErrors().Count);
Assert.IsTrue(result2);
}
public void ParenthesesTest()
{
FormNode form = QLParserHelper.Parse(_simpleComparionWithNumbersAndParensFormRaw);
var comparisonNode = form.Children
.Where(x => x.Type == NodeType.Conditional)
.Select(x => x as ConditionalNode)
.First().Expression as ComparisonExpressionNode;
var arthimetric = comparisonNode.Right as ArthimetricExpressionNode;
Assert.AreEqual(NodeType.ArthimetricExpression, arthimetric.Left.GetNodeType());
Assert.AreEqual(ArthimetricOperator.Mult, arthimetric.Operator);
Assert.AreEqual(NodeType.Literal, arthimetric.Right.GetNodeType());
}
public void MultiplyBeforePlusTest()
{
FormNode form = QLParserHelper.Parse(_simpleComparionWithNumbersFormRaw);
var comparisonNode = form.Children
.Where(x => x.Type == NodeType.CONDITIONAL)
.Select(x => x as ConditionalNode)
.First().Expression as ComparisonExpressionNode;
var arthimetric = comparisonNode.Right as ArthimetricExpressionNode;
Assert.AreEqual(NodeType.LITERAL, arthimetric.Left.GetNodeType());
Assert.AreEqual(ArthimetricOperator.PLUS, arthimetric.Operator);
Assert.AreEqual(NodeType.ARTHIMETRIC_EXPRESSION, arthimetric.Right.GetNodeType());
Assert.AreEqual(QValueType.INTEGER, arthimetric.Right.GetQValueType());
}
/// <summary>
/// Handles QL-language input
/// </summary>
/// <param name="rawQL">Raw QL-language string</param>
public virtual void HandleQL(string rawQL)
{
FormNode node = QLParserHelper.Parse(rawQL);
if (!Analyser.Analyse(node))
{
ShowError(Analyser.GetErrors().ToArray());
return;
}
FormManager formManager = ElementManagerFactory.CreateForm(node, this);
DisplayForm(formManager.Text, formManager);
//IEnumerable<ElementManager> widgets = ElementManagerFactory.CreateWidgets(node, this);
//DisplayForm(node.FormName, widgets.ToArray());
}
private FormManager QLQLS(string rawQl, string rawQls, ElementManagerController elementManagerController, ref List <string> errors)
{
FormNode formNode = QLParserHelper.Parse(rawQl);
QLSNode qlsNode = QLSParserHelper.Parse(rawQls);
if (!Analyser.Analyse(formNode, qlsNode))
{
errors.AddRange(Analyser.GetErrors());
return(null);
}
FormManager result = ElementManagerFactory.CreateForm(formNode, elementManagerController);
result = ElementManagerFactory.ApplyQLS(result, qlsNode, elementManagerController, ref errors);
return(result);
}
public void SimpleComputedSumTest()
{
FormNode node = QLParserHelper.Parse(_simpleComputedForm);
var computed = node.Children
.Where(x => x.Type == NodeType.COMPUTED)
.Select(x => x as ComputedNode)
.First();
Assert.AreEqual(NodeType.COMPUTED, computed.Type);
Assert.AreEqual("simpleSum", computed.ID);
Assert.AreEqual("Simple sum:", computed.Text);
Assert.AreEqual(QValueType.DOUBLE, computed.ValueType);
Assert.AreEqual(NodeType.ARTHIMETRIC_EXPRESSION, computed.Expression.GetNodeType());
Assert.AreEqual(QValueType.DOUBLE, computed.Expression.GetQValueType());
}
public void SimpleComputedSumTest()
{
FormNode node = QLParserHelper.Parse(_simpleComputedForm);
var computed = node.Children
.Where(x => x.Type == NodeType.Computed)
.Select(x => x as ComputedNode)
.First();
Assert.AreEqual(NodeType.Computed, computed.Type);
Assert.AreEqual("simpleSum", computed.ID);
Assert.AreEqual("Simple sum:", computed.Text);
Assert.AreEqual(QValueType.Double, computed.ValueType);
Assert.AreEqual(NodeType.ArthimetricExpression, computed.Expression.GetNodeType());
Assert.AreEqual(QValueType.Double, computed.Expression.GetQValueType());
}
public void SimpleComparisonFormTest()
{
FormNode form = QLParserHelper.Parse(_simpleComparisonFormRaw);
var comparisonNode = form.Children
.Where(x => x.Type == NodeType.CONDITIONAL)
.Select(x => x as ConditionalNode)
.First().Expression as ComparisonExpressionNode;
var left = comparisonNode.Left as IdentifierNode;
var opr = comparisonNode.Operator;
var right = comparisonNode.Right as IdentifierNode;
Assert.AreEqual("sellingPrice", left.ID);
Assert.AreEqual(ComparisonOperator.LT, opr);
Assert.AreEqual("buyingPrice", right.ID);
}
public void SimpleIntegerComparisonForTest()
{
FormNode form = QLParserHelper.Parse(_simpleIntegerForm);
var comparisonNode = form.Children
.Where(x => x.Type == NodeType.CONDITIONAL)
.Select(x => x as ConditionalNode)
.First().Expression as ComparisonExpressionNode;
var left = comparisonNode.Left as LiteralNode;
var opr = comparisonNode.Operator;
var right = comparisonNode.Right as LiteralNode;
Assert.AreEqual("10", left.Value);
Assert.AreEqual(QValueType.INTEGER, left.QValueType);
Assert.AreEqual(ComparisonOperator.LT, opr);
Assert.AreEqual("5", right.Value);
Assert.AreEqual(QValueType.INTEGER, left.QValueType);
}
public void SimpleDoubleComparisonFormTest()
{
FormNode form = QLParserHelper.Parse(_simpleDoubleForm);
var comparisonNode = form.Children
.Where(x => x.Type == NodeType.Conditional)
.Select(x => x as ConditionalNode)
.First().Expression as ComparisonExpressionNode;
var left = comparisonNode.Left as LiteralNode;
var opr = comparisonNode.Operator;
var right = comparisonNode.Right as LiteralNode;
Assert.AreEqual("10.0", left.Value);
Assert.AreEqual(QValueType.Double, left.QValueType);
Assert.AreEqual(ComparisonOperator.GreaterThan, opr);
Assert.AreEqual("5.5", right.Value);
Assert.AreEqual(QValueType.Double, left.QValueType);
}
public void CountQuestionsTest()
{
var form = QLParserHelper.Parse(_formRaw);
Assert.AreEqual(1, form.Children.Count);
}
public void Initialize()
{
_simpleFormWithConditional = QLParserHelper.Parse(FormExamples.SimpleFormWithConditional);
_simpleFormWithNotInitialisedVar = QLParserHelper.Parse(FormExamples.SimpleFormWithConditionalNotInitialised);
_simpleFormWithComputedNode = QLParserHelper.Parse(FormExamples.SimpleFormWithComputedNode);
}
public void NoVariablesInSymbolTable()
{
SimpleForm = QLParserHelper.Parse(_simpleFormRaw);
Assert.AreEqual(0, SymbolTable.Instance.TypeMap.Count);
}
public void GitHubExampleTest()
{
FormNode node = QLParserHelper.Parse(FormExamples.GitHubExampleForm);
Assert.IsNotNull(node);
}
public void SimpleFormNameTest()
{
FormNode form = QLParserHelper.Parse(_simpleForm);
Assert.AreEqual("SimpleForm", form.FormName);
}
public void Initialize()
{
node = QLParserHelper.Parse(_simpleConditional);
}
public void CountMultipleQuestionsTest()
{
var form = QLParserHelper.Parse(_formMultipleQuestionsRaw);
Assert.AreEqual(2, form.Children.Count);
}
public void IncorrectFormSyntexTest()
{
FormNode form = QLParserHelper.Parse(_incorrectSimpleForm);
Assert.IsNull(form);
}
