示例#1
0
 public void TrueTrueTest()
 {
     MockExpression leftExpression = new MockExpression(true);
     MockExpression rightExpression = new MockExpression(true);
     AndOperator expression = new AndOperator(leftExpression, rightExpression);
     Assert.IsTrue(expression.Evaluate(this.principal));
 }
        public void InstanceWithFalseInitialization()
        {
            var andOperator = new AndOperator(false);

            Assert.IsNotNull(andOperator);
            Assert.IsFalse(andOperator.Result);
        }
        public void InstanceWithTrueInitialization()
        {
            var andOperator = new AndOperator(true);

            Assert.IsNotNull(andOperator);
            Assert.IsTrue(andOperator.Result);
        }
示例#4
0
        public void AndOrNotTestWithQuotedStrings()
        {
            Parser            parser     = new Parser();
            BooleanExpression expression = parser.Parse(
                "(R:\"Human Resources\" OR R:\"General Managers\") AND NOT R:\"HR Specialist\"");

            Assert.AreEqual(typeof(AndOperator), expression.GetType());
            AndOperator andOperator = (AndOperator)expression;

            Assert.AreEqual(typeof(OrOperator), andOperator.Left.GetType());
            OrOperator orOperator = (OrOperator)andOperator.Left;

            Assert.AreEqual(typeof(RoleExpression), orOperator.Left.GetType());
            RoleExpression hrRoleExpression = (RoleExpression)orOperator.Left;

            Assert.AreEqual("Human Resources", hrRoleExpression.Word.Value);
            Assert.AreEqual(typeof(RoleExpression), orOperator.Right.GetType());
            RoleExpression gmRoleExpression = (RoleExpression)orOperator.Right;

            Assert.AreEqual("General Managers", gmRoleExpression.Word.Value);
            Assert.AreEqual(typeof(NotOperator), andOperator.Right.GetType());
            NotOperator notOperator = (NotOperator)andOperator.Right;

            Assert.AreEqual(typeof(RoleExpression), notOperator.Expression.GetType());
            RoleExpression specialistRoleExpression = (RoleExpression)notOperator.Expression;

            Assert.AreEqual("HR Specialist", specialistRoleExpression.Word.Value);
        }
示例#5
0
        public void AddFilterTest()
        {
            string expected = @"<?xml version=""1.0"" encoding=""utf-8""?>" +
                              "<and>" +
                              "<greaterthanorequalto>" +
                              "<field>RECORDNO</field>" +
                              "<value>1</value>" +
                              "</greaterthanorequalto>" +
                              "<lessthanorequalto>" +
                              "<field>RECORDNO</field>" +
                              "<value>100</value>" +
                              "</lessthanorequalto>" +
                              "</and>";

            Stream            stream      = new MemoryStream();
            XmlWriterSettings xmlSettings = new XmlWriterSettings
            {
                Encoding = Encoding.GetEncoding("UTF-8")
            };

            IaXmlWriter xml = new IaXmlWriter(stream, xmlSettings);

            AndOperator andFilter = new AndOperator(null);

            andFilter.AddFilter((new Filter("RECORDNO")).SetGreaterThanOrEqualTo("1"));
            andFilter.AddFilter((new Filter("RECORDNO")).SetLessThanOrEqualTo("100"));
            andFilter.WriteXml(ref xml);

            xml.Flush();

            stream.Position = 0;
            StreamReader reader = new StreamReader(stream);

            Assert.Equal(expected, reader.ReadToEnd());
        }
 public void FalseFalseTest()
 {
     MockExpression leftExpression = new MockExpression(false);
     MockExpression rightExpression = new MockExpression(false);
     AndOperator expression = new AndOperator(leftExpression, rightExpression);
     Assert.IsFalse(expression.Evaluate(principal));
 }
示例#7
0
 public void Visit(AndOperator node)
 {
     builder.AppendLine($"And");
     builder.Indent();
     node.Left.Accept(this);
     node.Right.Accept(this);
     builder.Outdent();
 }
示例#8
0
 public void TestTokenInheritance()
 {
     AndOperator andOp = new AndOperator();
     Assert.IsTrue(andOp.value == '*');
     Assert.IsInstanceOfType(andOp, typeof(AndOperator));
     Assert.IsInstanceOfType(andOp, typeof(OperatorToken));
     Assert.IsInstanceOfType(andOp, typeof(Token));
 }
示例#9
0
        public void FalseTrueTest()
        {
            MockExpression leftExpression  = new MockExpression(false);
            MockExpression rightExpression = new MockExpression(true);
            AndOperator    expression      = new AndOperator(leftExpression, rightExpression);

            Assert.IsFalse(expression.Evaluate(this.principal));
        }
示例#10
0
        public override VariableValue Evaluate(IVariableStore variables)
        {
            var left   = Left.Evaluate(variables);
            var right  = Right.Evaluate(variables);
            var result = AndOperator.And(this, ref left, ref right);

            return(Assign(variables, ref result));
        }
示例#11
0
        public void FilterOrWithAndConditionTest()
        {
            string expected = @"<?xml version=""1.0"" encoding=""utf-8""?>
<function controlid=""unittest"">
    <query>
        <select>
            <field>BATCHNO</field>
            <field>RECORDNO</field>
            <field>STATE</field>
        </select>
        <object>GLBATCH</object>
        <filter>
            <or>
                <equalto>
                    <field>JOURNAL</field>
                    <value>APJ</value>
                </equalto>
                <and>
                    <greaterthanorequalto>
                        <field>BATCHNO</field>
                        <value>1</value>
                    </greaterthanorequalto>
                    <equalto>
                        <field>STATE</field>
                        <value>Posted</value>
                    </equalto>
                </and>
            </or>
        </filter>
        <options />
    </query>
</function>";

            SelectBuilder builder = new SelectBuilder();

            ISelect[] fields = builder.Fields(new[] { "BATCHNO", "RECORDNO", "STATE" }).GetFields();

            AndOperator batchnoAndState = new AndOperator(new List <IFilter>());

            batchnoAndState.AddFilter((new Filter("BATCHNO")).SetGreaterThanOrEqualTo("1"));
            batchnoAndState.AddFilter((new Filter("STATE")).SetEqualTo("Posted"));

            IFilter journal = new Filter("JOURNAL").SetEqualTo("APJ");

            IFilter filter = new OrOperator(new List <IFilter>()
            {
                journal, batchnoAndState
            });

            IQueryFunction query = new QueryFunction("unittest")
            {
                FromObject   = "GLBATCH",
                SelectFields = fields,
                Filter       = filter
            };

            this.CompareXml(expected, query);
        }
示例#12
0
        public void AndApplyConstants()
        {
            Constant       c1 = Constant.Word32(1);
            Constant       c2 = Constant.Word32(2);
            BinaryOperator op = new AndOperator();
            Constant       c3 = op.ApplyConstants(c1, c2);

            Assert.AreEqual(0, c3.ToInt32());
        }
示例#13
0
        public void Visit(AndOperator node)
        {
            VisitBinary(node);

            ITerminalWrapper leftWrapper  = ReferenceTables.GetValue(node.Left);
            ITerminalWrapper rightWrapper = ReferenceTables.GetValue(node.Right);

            ReferenceTables.SetValue(node, ((dynamic)leftWrapper) & ((dynamic)rightWrapper));
        }
示例#14
0
        public void TestTokenInheritance()
        {
            AndOperator andOp = new AndOperator();

            Assert.IsTrue(andOp.value == '*');
            Assert.IsInstanceOfType(andOp, typeof(AndOperator));
            Assert.IsInstanceOfType(andOp, typeof(OperatorToken));
            Assert.IsInstanceOfType(andOp, typeof(Token));
        }
        public void PerformLogicWithFalseInitializationAndFalse()
        {
            var andOperator = new AndOperator(false);
            Assert.IsNotNull(andOperator);

            var result = andOperator.PerformLogic(false);

            Assert.IsFalse(andOperator.Result);
            Assert.AreEqual(andOperator.Result, result);
        }
示例#16
0
        public EvaluationTreeTestViewModel()
        {
            var node1 = new ComparisonOperator <string>("a", "b", BooleanOperatorTypeEnum.EqualOrLess);
            var node2 = new ComparisonOperator <string>("c", "d", BooleanOperatorTypeEnum.EqualOrGreater);
            var node3 = new AndOperator(node1, node2);

            Debug.WriteLine(string.Format("{0} = {1}", node1.GetNodeAsString(), node1.GetResult()));
            Debug.WriteLine(string.Format("{0} = {1}", node2.GetNodeAsString(), node2.GetResult()));
            Debug.WriteLine(string.Format("{0} = {1}", node3.GetNodeAsString(), node3.GetResult()));
        }
        public void PerformLogicWithTrueInitializationAndTrue()
        {
            var andOperator = new AndOperator(true);
            Assert.IsNotNull(andOperator);

            var result = andOperator.PerformLogic(true);

            Assert.IsTrue(andOperator.Result);
            Assert.AreEqual(andOperator.Result, result);
        }
示例#18
0
        public void AndExpressionWithoutParentheses()
        {
            Parser            parser     = new Parser();
            BooleanExpression expression = parser.Parse("R:Role1 and R:Role2");

            Assert.AreEqual(typeof(AndOperator), expression.GetType());
            AndOperator andOperator = (AndOperator)expression;

            Assert.AreEqual(typeof(RoleExpression), andOperator.Left.GetType());
            Assert.AreEqual(typeof(RoleExpression), andOperator.Right.GetType());
            Assert.AreEqual("Role1", ((RoleExpression)andOperator.Left).Word.Value);
            Assert.AreEqual("Role2", ((RoleExpression)andOperator.Right).Word.Value);
        }
示例#19
0
        public void ComplexExpressionTest()
        {
            AndOperator expression = new AndOperator();
            expression.Left = new RoleExpression("Managers");
            expression.Right = new NotOperator(new IdentityExpression("Bob"));

            GenericIdentity identity = new GenericIdentity("Bob");
            string[] roles = new string[] {"Managers"};
            GenericPrincipal principal = new GenericPrincipal(identity, roles);

            bool result = expression.Evaluate(principal);
            Assert.IsFalse(result);
        }
示例#20
0
        public void AndExpressionTest()
        {
            Parser            parser     = new Parser();
            BooleanExpression expression = parser.Parse("(R:Role1 and R:Role2)");

            Assert.AreEqual(typeof(AndOperator), expression.GetType());
            AndOperator andOperator = (AndOperator)expression;

            Assert.IsNotNull(andOperator.Left);
            Assert.IsNotNull(andOperator.Right);
            Assert.AreEqual(typeof(RoleExpression), andOperator.Left.GetType());
            Assert.AreEqual(typeof(RoleExpression), andOperator.Right.GetType());
            Assert.AreEqual("Role1", ((RoleExpression)andOperator.Left).Word.Value);
            Assert.AreEqual("Role2", ((RoleExpression)andOperator.Right).Word.Value);
        }
示例#21
0
        public void AndOperator_ShouldPrint()
        {
            var ast = new AndOperator
                      (
                position: 0,
                left: new Identifier(0, "x"),
                right: new Identifier(0, "y")
                      );

            Assert.That(PrettyPrinter.ToString(ast), Is.EqualTo(
                            @"And
    Identifier(x)
    Identifier(y)
"));
        }
        public void ComplexExpressionTest()
        {
            AndOperator expression = new AndOperator();

            expression.Left  = new RoleExpression("Managers");
            expression.Right = new NotOperator(new IdentityExpression("Bob"));

            GenericIdentity identity = new GenericIdentity("Bob");

            string[]         roles     = new string[] { "Managers" };
            GenericPrincipal principal = new GenericPrincipal(identity, roles);

            bool result = expression.Evaluate(principal);

            Assert.IsFalse(result);
        }
示例#23
0
        public void CanPerformMultiOperationalExpression(int a, int b, int c, int d)
        {
            Dictionary <string, bool> expectedAnswersMap = new Dictionary <string, bool>
            {
                { "0000", false },
                { "1000", false },
                { "0100", false },
                { "0010", false },
                { "0001", true },
                { "1100", false },
                { "1010", true },
                { "1001", true },
                { "0110", true },
                { "0101", true },
                { "0011", true },
                { "1110", true },
                { "0111", true },
                { "1101", true },
                { "1011", true },
                { "1111", true },
            };
            LeafNode <int> A = new LeafNode <int>(a, SimpleValueExpressionFunction);
            LeafNode <int> B = new LeafNode <int>(b, SimpleValueExpressionFunction);
            LeafNode <int> C = new LeafNode <int>(c, SimpleValueExpressionFunction);
            LeafNode <int> D = new LeafNode <int>(d, SimpleValueExpressionFunction);
            List <Node>    firstOrChildren = new List <Node>
            {
                A,
                B
            };
            List <Node> middleAndChildren = new List <Node>();
            List <Node> lastOrChildren    = new List <Node>();
            Operator    andOp             = new AndOperator();
            Operator    orOp = new OrOperator();

            OperatorNode firstOr = new OperatorNode(firstOrChildren, orOp);

            middleAndChildren.Add(firstOr);
            middleAndChildren.Add(C);
            OperatorNode middleAnd = new OperatorNode(middleAndChildren, andOp);

            lastOrChildren.Add(middleAnd);
            lastOrChildren.Add(D);
            OperatorNode lastOr = new OperatorNode(lastOrChildren, orOp);

            Assert.Equal(lastOr.Evaluate(), expectedAnswersMap[$"{a}{b}{c}{d}"]);
        }
示例#24
0
        public void AndNotTest()
        {
            Parser            parser     = new Parser();
            BooleanExpression expression = parser.Parse("R:Managers AND NOT I:Bob");

            AndOperator andOperator = (AndOperator)expression;

            RoleExpression roleExpression = (RoleExpression)andOperator.Left;

            Assert.AreEqual("Managers", roleExpression.Word.Value);

            NotOperator notOperator = (NotOperator)andOperator.Right;

            IdentityExpression identityExpression = (IdentityExpression)notOperator.Expression;

            Assert.AreEqual("Bob", identityExpression.Word.Value);
        }
示例#25
0
        public void MultipleAndExpressionWithParentheses()
        {
            Parser            parser     = new Parser();
            BooleanExpression expression = parser.Parse("R:Role1 and R:Role2 and I:User1");

            Assert.AreEqual(typeof(AndOperator), expression.GetType());
            AndOperator andOperator = (AndOperator)expression;

            Assert.IsNotNull(andOperator.Left);
            Assert.IsNotNull(andOperator.Right);

            Assert.AreEqual("User1", ((IdentityExpression)andOperator.Right).Word.Value);

            AndOperator leftAndOperator = (AndOperator)andOperator.Left;

            Assert.AreEqual("Role2", ((RoleExpression)leftAndOperator.Right).Word.Value);
        }
示例#26
0
        public void NullFilterTest()
        {
            Stream            stream      = new MemoryStream();
            XmlWriterSettings xmlSettings = new XmlWriterSettings
            {
                Encoding = Encoding.GetEncoding("UTF-8")
            };

            IaXmlWriter xml = new IaXmlWriter(stream, xmlSettings);

            IFilter andFilter = new AndOperator(null);

            var ex = Record.Exception(() => andFilter.WriteXml(ref xml));

            Assert.IsType <IntacctException>(ex);
            Assert.Equal("Two or more IFilter objects required for and", ex.Message);
        }
示例#27
0
文件: Lexer.cs 项目: biterman/obi-wan
 /* Methods */
 private void Tokenize()
 {
     tokens = new List<Token>();
     Token prev = null;
     Token t = null;
     while (_inputReader.Peek() != -1)
     {
         char c = (char)_inputReader.Read();
         switch (c)
         {
             case Token.AND:
                 t = new AndOperator();
                 tokens.Add(t);
                 break;
             case Token.OR:
                 t = new OrOperator();
                 tokens.Add(t);
                 break;
             case Token.LEFT_PAREN:
                 // Insert implicit AND operators before (
                 if ((prev is RightParenthesis) || (prev is Literal) || (prev is NotOperator))
                     tokens.Add(new AndOperator());
                 t = new LeftParenthesis();
                 tokens.Add(t);
                 break;
             case Token.RIGHT_PAREN:
                 t = new RightParenthesis();
                 tokens.Add(t);
                 break;
             case Token.NOT:
                 t = new NotOperator();
                 tokens.Add(t);
                 break;
             default:
                 t = new Literal(c);
                 // Insert implicit AND operators before Literals
                 if ((prev is RightParenthesis) || (prev is Literal) || (prev is NotOperator))
                     tokens.Add(new AndOperator());
                 tokens.Add(t);
                 break;
         }
         prev = t;
     }
 }
示例#28
0
        public void FilterAndConditionTest()
        {
            string expected = @"<?xml version=""1.0"" encoding=""utf-8""?>
<function controlid=""unittest"">
    <query>
        <select>
            <field>CUSTOMERID</field>
            <field>RECORDNO</field>
        </select>
        <object>ARINVOICE</object>
        <filter>
            <and>
                <greaterthanorequalto>
                    <field>RECORDNO</field>
                    <value>1</value>
                </greaterthanorequalto>
                <lessthanorequalto>
                    <field>RECORDNO</field>
                    <value>100</value>
                </lessthanorequalto>
            </and>
        </filter>
        <options />
    </query>
</function>";

            SelectBuilder builder = new SelectBuilder();

            ISelect[] fields = builder.Fields(new[] { "CUSTOMERID", "RECORDNO" }).GetFields();

            AndOperator filter = new AndOperator(new List <IFilter>());

            filter.AddFilter((new Filter("RECORDNO")).SetGreaterThanOrEqualTo("1"));
            filter.AddFilter((new Filter("RECORDNO")).SetLessThanOrEqualTo("100"));

            IQueryFunction query = new QueryFunction("unittest")
            {
                FromObject   = "ARINVOICE",
                SelectFields = fields,
                Filter       = filter
            };

            this.CompareXml(expected, query);
        }
示例#29
0
        public override string BuildSql(SqlOptions sqlOptions)
        {
            AndOperator andBlock;

            if (Entities.Count == 1 && Entities[0] is AndOperator andOperator)
            {
                andBlock = andOperator;
            }
            else
            {
                andBlock = new AndOperator(Entities);
            }
            andBlock.Indent  = true;
            andBlock.NewLine = true;
            var conditions = andBlock.BuildSql(sqlOptions, FlowOptions.Construct(this));
            var command    = sqlOptions.Command("WHERE");

            return($"{command}{sqlOptions.NewLine()}{sqlOptions.Indent("    ")}{conditions}");
        }
示例#30
0
 public RuleFilter(AndOperator theAndOperator, string prefix, Tagging tag)
 {
     TheAndOperator = theAndOperator;
     if (string.IsNullOrWhiteSpace(prefix) || string.IsNullOrEmpty(prefix))
     {
         Prefix = null;
     }
     else
     {
         Prefix = prefix;
     }
     if (tag != null && tag.TaggingSet.Tag.Count == 0)
     {
         tag = null;
     }
     else
     {
         Tag = tag;
     }
 }
示例#31
0
        public void SingleFilterTest()
        {
            Stream            stream      = new MemoryStream();
            XmlWriterSettings xmlSettings = new XmlWriterSettings
            {
                Encoding = Encoding.GetEncoding("UTF-8")
            };

            IaXmlWriter xml = new IaXmlWriter(stream, xmlSettings);

            List <IFilter> filters = new List <IFilter>();

            filters.Add((new Filter("RECORDNO")).SetGreaterThanOrEqualTo("1"));
            IFilter andFilter = new AndOperator(filters);

            var ex = Record.Exception(() => andFilter.WriteXml(ref xml));

            Assert.IsType <IntacctException>(ex);
            Assert.Equal("Two or more IFilter objects required for and", ex.Message);
        }
示例#32
0
        public void CreateExpressionTest1()
        {
            // Arrange
            var parameterExpression = Expression.Parameter(typeof(Employee), "sample");
            var expressionProperty  = Expression.Property(parameterExpression, nameof(Employee.FirstName));
            var containsOperator    = new ContainsOperator();

            Expression leftExpression  = containsOperator.CreateExpression(expressionProperty, Expression.Constant("xxx"));
            Expression rightExpression = containsOperator.CreateExpression(expressionProperty, Expression.Constant("yyy"));

            Expression expectedExpression = Expression.And(leftExpression, rightExpression);

            var _operator = new AndOperator();

            // Act
            Expression resultExpression = _operator.CreateExpression(leftExpression, rightExpression);

            // Assert
            Assert.AreEqual(expectedExpression.ToString(), resultExpression.ToString(), "Expression not correct");
        }
        public void Visit(AndOperator and)
        {
            var falseLabel = MakeNewLabel();
            var endLabel   = MakeNewLabel();

            and.Left.Accept(this);
            var leftOperand = tacs.Last().Result;

            tacs.Add(Tac.IfFalse(leftOperand, falseLabel));
            and.Right.Accept(this);
            var rightOperand = tacs.Last().Result;

            tacs.Add(Tac.IfFalse(rightOperand, falseLabel));
            var resultVariable = MakeNewTemp();

            tacs.Add(Tac.Assign("1", resultVariable));
            tacs.Add(Tac.Goto(endLabel));
            tacs.Add(Tac.Label(falseLabel, resultVariable));
            tacs.Add(Tac.Assign("0", resultVariable));
            tacs.Add(Tac.Label(endLabel, resultVariable));
        }
示例#34
0
 public void BuildSupplyPoint()
 {
     MarketDB.Instance.InsertByForce();
     datalayer               = PolicyDL.Instance;
     UsernameEqualsLeaf2     = new UsernameEquals(PolicyType.Global, "bla", "bla_bla", 1);
     UsernameEqualsLeaf      = new UsernameEquals(PolicyType.Global, "bla", "bla_bla", 2);
     QuantityLessThanLeaf    = new QuantityLessThan(PolicyType.Global, "bla", "bla_bla", 3);
     QuantityGreaterThanLeaf = new QuantityGreaterThan(PolicyType.Global, "bla", "bla_bla", 4);
     PriceLessThanLeaf       = new PriceLessThan(PolicyType.Global, "bla", "bla_bla", 5);
     PriceGreaterThanLeaf    = new PriceGreaterThan(PolicyType.Global, "bla", "bla_bla", 6);
     AddressEqualsLeaf       = new AddressEquals(PolicyType.Global, "bla", "bla_bla", 7);
     AndHas0opSun            = new AndOperator(PolicyType.Global, "bla", PriceGreaterThanLeaf, PriceLessThanLeaf, 8);
     AndHas1opSun            = new AndOperator(PolicyType.Global, "bla", AndHas0opSun, UsernameEqualsLeaf2, 9);
     OrHas0opSun             = new OrOperator(PolicyType.Global, "bla", QuantityLessThanLeaf, QuantityGreaterThanLeaf, 10);
     OrHas1opSun             = new OrOperator(PolicyType.Global, "bla", OrHas0opSun, UsernameEqualsLeaf, 11);
     NotHasCondSun           = new NotOperator(PolicyType.Global, "bla", AddressEqualsLeaf, null, 12);
     NotHasopSun             = new NotOperator(PolicyType.Global, "bla", NotHasCondSun, null, 13);
     OrHas2opSuns            = new OrOperator(PolicyType.Global, "bla", AndHas1opSun, OrHas1opSun, 14);
     ROOT_AndHas2opSuns      = new AndOperator(PolicyType.Global, "bla", OrHas2opSuns, NotHasopSun, 15);
     BadInputLeaf            = new UsernameEquals(PolicyType.Global, "bla", "bla'bla", 1);
 }
示例#35
0
        public void CanPerformSimpleAndTree()
        {
            List <Node> children = new List <Node>
            {
                new LeafNode <int>(0, SimpleValueExpressionFunction),
                new LeafNode <int>(0, SimpleValueExpressionFunction)
            };

            Operator     op       = new AndOperator();
            OperatorNode opNode00 = new OperatorNode(children, op);

            children = new List <Node>
            {
                new LeafNode <int>(0, SimpleValueExpressionFunction),
                new LeafNode <int>(1, SimpleValueExpressionFunction)
            };
            OperatorNode opNode01 = new OperatorNode(children, op);

            children = new List <Node>
            {
                new LeafNode <int>(1, SimpleValueExpressionFunction),
                new LeafNode <int>(0, SimpleValueExpressionFunction)
            };
            OperatorNode opNode10 = new OperatorNode(children, op);

            children = new List <Node>
            {
                new LeafNode <int>(1, SimpleValueExpressionFunction),
                new LeafNode <int>(1, SimpleValueExpressionFunction)
            };
            OperatorNode opNode11 = new OperatorNode(children, op);

            Assert.False(opNode00.Evaluate());
            Assert.False(opNode01.Evaluate());
            Assert.False(opNode10.Evaluate());
            Assert.True(opNode11.Evaluate());
        }
示例#36
0
        public void AndOrNotTest()
        {
            Parser            parser     = new Parser();
            BooleanExpression expression = parser.Parse(
                "(R:HumanSR OR R:GeneralManagers) AND NOT R:HRSpecialist");

            AndOperator andOperator = (AndOperator)expression;

            OrOperator orOperator = (OrOperator)andOperator.Left;

            RoleExpression hrRoleExpression = (RoleExpression)orOperator.Left;

            Assert.AreEqual("HumanSR", hrRoleExpression.Word.Value);

            RoleExpression gmRoleExpression = (RoleExpression)orOperator.Right;

            Assert.AreEqual("GeneralManagers", gmRoleExpression.Word.Value);

            NotOperator notOperator = (NotOperator)andOperator.Right;

            RoleExpression specialistRoleExpression = (RoleExpression)notOperator.Expression;

            Assert.AreEqual("HRSpecialist", specialistRoleExpression.Word.Value);
        }
示例#37
0
文件: TPL.cs 项目: Zoranan/TplLibrary
        private static ExpTreeNode GetAsExpressionTree(this ParseTreeNode parsedNode, ExpTreeNode parentExpNode)
        {
            //The current node is a variable / value token. Create a value node and return it back
            if (!parsedNode.ChildNodes.Any())
            {
                switch (parsedNode.Term.Name)
                {
                case "variable":
                {
                    var varName = parsedNode.FindTokenAndGetValue <string>();
                    return(new VariableValue(varName, parentExpNode));
                }

                case "boolean":
                    return(new LiteralValue(parsedNode.FindTokenAndGetValue <bool>(), parentExpNode));

                case "integer":
                case "decimal":
                    return(new LiteralValue(parsedNode.FindTokenAndGetValue <double>(), parentExpNode));

                case "SingleQuoteString":
                case "DoubleQuoteString":
                    return(new LiteralValue(parsedNode.FindTokenAndGetValue <string>(), parentExpNode));

                default:
                    throw parsedNode.GetException($"Invalid token type '{parsedNode.Term.Name}' in expression");
                }
            }

            // Look on the next node down
            else if (parsedNode.ChildNodes.Count == 1)
            {
                return(GetAsExpressionTree(parsedNode.ChildNodes[0], parentExpNode));
            }

            //Ignore parenthesis, the middle non-terminal is what we want
            // Look on the next node down
            else if (parsedNode.ChildNodes.Count == 3 && parsedNode.ChildNodes[0]?.Token?.Text == "(")
            {
                return(GetAsExpressionTree(parsedNode.ChildNodes[1], parentExpNode));
            }

            //Binary operator
            else if (parsedNode.ChildNodes.Count == 3)
            {
                BinaryOperatorBase binaryOp;
                var opStr = parsedNode.ChildNodes[1].FindToken().ValueString;
                switch (opStr)
                {
                // Math
                case "+":
                    binaryOp = new AdditionOperator(parentExpNode);
                    break;

                case "-":
                    binaryOp = new SubtractionOperator(parentExpNode);
                    break;

                case "*":
                    binaryOp = new MultiplacationOperator(parentExpNode);
                    break;

                case "/":
                    binaryOp = new DivisionOperator(parentExpNode);
                    break;

                case "%":
                    binaryOp = new ModulusOperator(parentExpNode);
                    break;

                case "^":
                    binaryOp = new PowerOperator(parentExpNode);
                    break;

                // Bool
                case "~==":
                    binaryOp = new LooseEqualsOperator(parentExpNode);
                    break;

                case "~!=":
                    binaryOp = new LooseNotEqualsOperator(parentExpNode);
                    break;

                case "==":
                    binaryOp = new EqualsOperator(parentExpNode);
                    break;

                case "!=":
                    binaryOp = new NotEqualsOperator(parentExpNode);
                    break;

                case "like":
                    binaryOp = new LikeOperator(parentExpNode);
                    break;

                case "match":
                    binaryOp = new MatchOperator(parentExpNode);
                    break;

                case ">":
                    binaryOp = new GreaterThanOperator(parentExpNode);
                    break;

                case ">=":
                    binaryOp = new GreaterThanOrEqualOperator(parentExpNode);
                    break;

                case "<":
                    binaryOp = new LessThanOperator(parentExpNode);
                    break;

                case "<=":
                    binaryOp = new LessThanOrEqualOperator(parentExpNode);
                    break;

                case "&&":
                    binaryOp = new AndOperator(parentExpNode);
                    break;

                case "||":
                    binaryOp = new OrOperator(parentExpNode);
                    break;

                default:
                    throw parsedNode.ChildNodes[1].GetException($"Unrecognized operator '{opStr}'");
                }

                binaryOp.LeftOperand  = GetAsExpressionTree(parsedNode.ChildNodes[0], binaryOp);
                binaryOp.RightOperand = GetAsExpressionTree(parsedNode.ChildNodes[2], binaryOp);

                //Optimize
                if (binaryOp.LeftOperand is LiteralValue && binaryOp.RightOperand is LiteralValue)
                {
                    return(new LiteralValue(binaryOp.Eval(), parentExpNode));
                }

                return(binaryOp);
            }

            // Unary operator
            else if (parsedNode.ChildNodes.Count == 2)
            {
                var opVal = parsedNode.ChildNodes[0].FindToken().Value;
                UnaryOperatorBase unaryOp;
                if (parsedNode.ChildNodes[0].FindToken().Value is TypeCode convertType)
                {
                    unaryOp = new TypeConversionOperator(convertType, parentExpNode);
                }
                else
                {
                    var opStr = opVal.ToString();
                    switch (opStr)
                    {
                    case "!":
                        unaryOp = new NotOperator(parentExpNode);
                        break;

                    //Property Checking
                    case "lengthof":
                        unaryOp = new LengthOperator(parentExpNode);
                        break;

                    case "typeof":
                        unaryOp = new TypeOperator(parentExpNode);
                        break;

                    default:
                        unaryOp = new GenericUnaryMathFunctionOperator(opStr, parentExpNode);
                        break;
                    }
                }

                unaryOp.Operand = GetAsExpressionTree(parsedNode.ChildNodes[1], unaryOp);

                //Optimize
                if (unaryOp.Operand is LiteralValue)
                {
                    return(new LiteralValue(unaryOp.Eval(), parentExpNode));
                }

                return(unaryOp);
            }

            else
            {
                throw parsedNode.GetException($"Invalid number of tokens ({parsedNode.ChildNodes.Count})");
            }
        }
示例#38
0
 public void Visit(AndOperator node)
 {
 }
            /// <summary>
            /// Processes the and operator.
            /// </summary>
            /// <param name="inputAndOperator">The input and operator.</param>
            /// <returns></returns>
            private static AndConditionOperator <LanguageUnderstandingResult> ProcessAndOperator(AndOperator inputAndOperator)
            {
                var andOperator = new CognitiveServices.LanguageUnderstanding.Conditions.AndConditionOperator <LanguageUnderstandingResult>();
                var operators   = ProcessSuboperators(inputAndOperator);

                andOperator.Operators = operators.ToArray();
                return(andOperator);
            }