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; }