public void RandomCharsTest()
{
FormNode randomCharForm = QLParserHelper.Parse(FormExamples.RandomChars);
var isValid = Analyser.Analyse(randomCharForm);
Assert.IsFalse(isValid);
}
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 InvalidComparisonTest()
{
//TODO: Don't know how to detect this error yet!
FormNode form = QLParserHelper.Parse(_invalidFormRaw);
Assert.Fail();
}
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);
}
private static void WalkFormSchema(ChromeDriver driver, FormNode node, FormData data)
{
if (node == null)
{
return;
}
if (node is Facet facet)
{
var facetMapper = FacetMapperFactory.GetFacetMapper(driver, facet.FacetType);
var inputValue = GetInputValue(data, facet.DomainKey);
facetMapper.SetFacetValue(facet, inputValue);
}
if (node.ChildNodes == null)
{
return;
}
foreach (var childNode in node.ChildNodes)
{
WalkFormSchema(driver, childNode, data);
}
}
public override object Visit(FormNode node)
{
Form = new FormViewModel(node.Label);
VisitChildren(node);
return(Form);
}
public void Initialize()
{
OneVarForm = QLParserHelper.Parse(_oneVarFormRaw);
MultipleVarForm = QLParserHelper.Parse(_multipleVarFormRaw);
SymbolTable.Reset();
Analyser.Reset();
}
public override Node VisitForm(FormContext context)
{
ITerminalNode label = context.LABEL();
var form = new FormNode(context.Start, label?.GetText());
form.AddChild(Visit(context.block()));
return(form);
}
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);
}
override public Node Visit(FormNode node)
{
if (_formNodeExpectations.Count > 0)
{
_formNodeExpectations.Dequeue().Invoke(node);
}
return(VisitChildren(node));
}
public static FormManager CreateForm(FormNode node, ElementManagerController elementManagerController)
{
FormManager form = new FormManager(node.FormName, node.FormName, elementManagerController);
// Add all children
form.AddChildren(node.Children.Select(o => ParseChildNode(o, elementManagerController, form)).Where(o => o != null));
return(form);
}
public override Node Visit(FormNode form)
{
var newForm = new FormNode(form.Token, form.Label);
foreach (var block in form.ChildNodes)
{
newForm.AddChild(block.Accept(this));
}
return(newForm);
}
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 should_encode_form()
{
var form = new FormNode(NodeType.Object)
{
{ "oh", NodeType.Value, Metadata.Empty, x => x.Value = "hai" },
{ new FormValueNode("john", "zoidberg"), x => { } }
};
var stream = new MemoryStream();
form.Encode(stream);
stream.Position = 0;
new StreamReader(stream).ReadToEnd().ShouldEqual("oh=hai&john=zoidberg");
}
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 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 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());
}
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());
}
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);
}
/// <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());
}
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);
}
private static string GetFriendlyNodeNameForType(FormNode node)
{
switch (node)
{
case FormRouterFormNode frnfn:
return("ROUTER");
case TaskQuestionPageFormNode tqp:
return(tqp.PageId);
case PreTaskFormNode prefn:
return("PRE");
case PostTaskFormNode postfn:
return("POST");
case TaskSummaryFormNode sumfn:
return("SUM");
case TaskRouterFormNode trfn:
return("TASK");
case TaskItemRouterFormNode tirfn:
return("ITEM" + tirfn.RepeatIndex);
case TaskListFormNode tlfn:
return("TASKLIST");
case SubTaskRouterFormNode strfn:
return(strfn.SubTaskId);
case SubTaskItemRouterFormNode stirfn:
return(stirfn.SubTaskId + "-ITEM");
case PreSubTaskFormNode pstfn:
return(pstfn.SubTaskId + "-PRE");
case PostSubTaskFormNode poststfn:
return(poststfn.SubTaskId + "-POST");
default:
throw new NotImplementedException();
}
}
public void Initialize()
{
var firstQuestion = new QuestionNode(Location.Empty, "Q1", "Do you like puppies?", QValueType.Boolean);
var secondQuestion = new QuestionNode(Location.Empty, "Q2", "Do you like kittens?", QValueType.Boolean);
var thirdQuestion = new ConditionalNode(Location.Empty, null);
thirdQuestion.AddNode(new FormNode(Location.Empty, "InvalidFormInLowerLayer"));
var forthQuestion = new QuestionNode(Location.Empty, "Q4", "Is this the forthQuestion?", QValueType.Boolean);
_validAST = new FormNode(Location.Empty, "TestForm");
_validAST.AddNode(firstQuestion);
_validAST.AddNode(secondQuestion);
_multipleFormAST = new FormNode(Location.Empty, "TestForm");
_multipleFormAST.AddNode(new FormNode(Location.Empty, "InvalidForm"));
_multipleFormInLowerNodeAST = new FormNode(Location.Empty, "InvalidForm");
_multipleFormInLowerNodeAST.AddNode(thirdQuestion);
}
public void should_parse_form()
{
var form = new FormNode("oh=hai&john=zoidberg");
form.NodeType.ShouldEqual(NodeType.Object);
var values = form.ToList();
values.Count.ShouldEqual(2);
var value = values.First();
value.Name.ShouldEqual("oh");
value.Value.ShouldEqual("hai");
value.NodeType.ShouldEqual(NodeType.Value);
value = values[1];
value.Name.ShouldEqual("john");
value.Value.ShouldEqual("zoidberg");
value.NodeType.ShouldEqual(NodeType.Value);
}
public static void Print(FormNode form)
{
Console.WriteLine(form);
foreach (QLNode section in form.Children)
{
switch (section.GetNodeType())
{
case NodeType.Question:
PrintSection(section as QuestionNode);
break;
case NodeType.Computed:
PrintSection(section as ComputedNode);
break;
case NodeType.Conditional:
PrintSection(section as ConditionalNode);
break;
default:
return;
}
}
}
public static void PrintForm(FormNode form)
{
Console.WriteLine(form);
foreach (Node section in form.Children)
{
switch (section.GetNodeType())
{
case NodeType.QUESTION:
PrintSection(section as QuestionNode);
break;
case NodeType.COMPUTED:
PrintSection(section as ComputedNode);
break;
case NodeType.CONDITIONAL:
PrintSection(section as ConditionalNode);
break;
default:
return;
}
}
}
protected virtual void OnNewFormView(object sender, EventArgs args)
{
var srvNode = new FormNode();
var formView = formFolder.CreateFormView();
formView.Name = "NewFormView" + DateTime.Now.ToString("yyyy-MM-dd hh:mm:sss");
srvNode.FormView = formView;
this.formFolder.FormViews.AddChild(formView);
this.Children.Add(srvNode);
this.TreeNode.Expand();
}
private void Bar(FormNode node)
{
node.MyDelegateEvent += Handler;
}
