コード例 #1
0
        public bool AndBoolean(AndExpression node, List <object> parameters)
        {
            bool leftOperand  = _interpreter.DispatchBoolean(node.Children[0], parameters);
            bool rightOperand = _interpreter.DispatchBoolean(node.Children[1], parameters);

            return(leftOperand && rightOperand);
        }
コード例 #2
0
            public void CanTranslateExpressionWithManyBinaryOperatorsThatHaveDifferentPrecendence()
            {
                // Prepare (x OR y AND z)
                var x   = new FakeEvaluableExpression();
                var y   = new FakeEvaluableExpression();
                var z   = new FakeEvaluableExpression();
                var or  = new OrExpression();
                var and = new AndExpression();

                Tokens.Add(x);
                Tokens.Add(or);
                Tokens.Add(y);
                Tokens.Add(and);
                Tokens.Add(z);

                // Act
                var result = Parser.TransformInfixToPostfix(Tokens).ToList();

                // Verify
                Assert.AreSame(x, result[0]);
                Assert.AreSame(y, result[1]);
                Assert.AreSame(z, result[2]);
                Assert.AreSame(and, result[3]);
                Assert.AreSame(or, result[4]);
            }
コード例 #3
0
            public void CanTranslateExpressionUsingParenthesisPrecedence()
            {
                // Prepare (x OR y) AND z
                var x   = new FakeEvaluableExpression();
                var y   = new FakeEvaluableExpression();
                var z   = new FakeEvaluableExpression();
                var and = new AndExpression();
                var or  = new OrExpression();
                var lp  = new OpenParenthesis();
                var rp  = new CloseParenthesis();

                Tokens.Add(lp);
                Tokens.Add(x);
                Tokens.Add(or);
                Tokens.Add(y);
                Tokens.Add(rp);
                Tokens.Add(and);
                Tokens.Add(z);

                // Act
                var result = Parser.TransformInfixToPostfix(Tokens).ToList();

                // Verify
                Assert.IsTrue(result.Count == 5);
                Assert.AreSame(x, result[0]);
                Assert.AreSame(y, result[1]);
                Assert.AreSame(or, result[2]);
                Assert.AreSame(z, result[3]);
                Assert.AreSame(and, result[4]);
            }
コード例 #4
0
        /// <summary>
        /// Handles the AST node visit.
        /// </summary>
        /// <param name="astNode">AST node.</param>
        public override void Visit(AndGdAstNode astNode)
        {
            AndExpression andExpression = new AndExpression();

            astNode.Arguments.ForEach(arg => andExpression.Arguments.Add(MasterExporter.ToExpression(arg)));
            ExpressionData = andExpression;
        }
コード例 #5
0
ファイル: RuleTests.cs プロジェクト: evelasco85/LogSystem
        void SetupRules()
        {
            IRule accessRightsViolationRule = new Rule(Guid.NewGuid().ToString());

            accessRightsViolationRule
            .AddVariableScope(_componentVar)
            .AddVariableScope(_eventNameVar)
            .AddVariableScope(_isAdminVar, true)
            .AddVariableScope(_accessRightsVar, true);

            //Event-trigger condition
            IBooleanBase componentCondition     = EqualToExpression.New(_componentVar, new Literal(AUTHENTICATION_COMPONENT_NAME));
            IBooleanBase eventCondition         = EqualToExpression.New(_eventNameVar, new Literal(AUTHENTICATION_EVENT_NAME));
            IBooleanBase matchingEventCondition = AndExpression.New(componentCondition, eventCondition);

            //Parameter-trigger condition
            IBooleanBase accessRightsCondition           = EqualToExpression.New(_accessRightsVar, new Literal(Rights.Full));
            IBooleanBase isAdministratorCondition        = EqualToExpression.New(_isAdminVar, new Literal(true));
            IBooleanBase notAllowedAccessRightsCondition = AndExpression.New(accessRightsCondition, NotExpression.New(isAdministratorCondition));

            //Trigger condition
            IBooleanBase triggerCondition = AndExpression.New(matchingEventCondition, notAllowedAccessRightsCondition);

            accessRightsViolationRule.SetCondition(triggerCondition,
                                                   (resultContext, resultRule) =>
            {
                Console.WriteLine("Access rights violation alert!");
            },
                                                   (resultContext, resultRule) =>
            {
                Console.WriteLine("All is well...");
            });

            RuleManager.GetInstance().AddRule(accessRightsViolationRule);
        }
        public void SetUp()
        {
            this.andExpression         = new AndExpression();
            this.orExpression          = new OrExpression();
            this.exclusiveOrExpression = new ExclusiveOrExpression();
            this.notExpression         = new NotExpression();
            this.relationalExpression1 = new RelationalExpression();
            this.relationalExpression2 = new RelationalExpression();
            this.relationalExpression3 = new RelationalExpression();
            this.relationalExpression4 = new RelationalExpression();

            this.booleanExpressions = new List <BooleanExpression>
            {
                this.andExpression,
                this.orExpression,
                this.exclusiveOrExpression,
                this.notExpression,
                this.relationalExpression1,
                this.relationalExpression2,
                this.relationalExpression3,
                this.relationalExpression4
            };

            this.testCaseList = new Dictionary <ExpressionNumber, BooleanExpression>
            {
                { ExpressionNumber.And, this.andExpression },
                { ExpressionNumber.Or, this.orExpression },
                { ExpressionNumber.ExclusiveOr, this.exclusiveOrExpression },
                { ExpressionNumber.Not, this.notExpression },
                { ExpressionNumber.Relational1, this.relationalExpression1 },
                { ExpressionNumber.Relational2, this.relationalExpression2 },
                { ExpressionNumber.Relational3, this.relationalExpression3 },
                { ExpressionNumber.Relational4, this.relationalExpression4 }
            };
        }
コード例 #7
0
 protected override string VisitAnd(EntityConfiguration context, AndExpression expression)
 {
     return(string.Concat(
                expression.Left.Accept(this, context),
                " AND ",
                expression.Right.Accept(this, context)));
 }
コード例 #8
0
        public void VisitAnd()
        {
            var variable1 = new FuzzyVariable("MyFuzzyVariable1", new NumericVariable("MyNumVariable1"));
            var variable2 = new FuzzyVariable("MyFuzzyVariable2", new NumericVariable("MyNumVariable2"));
            var valueExpr1 =
                new ValueExpression(
                    variable1,
                    new FuzzyTerm("MyTerm1", new MembershipFunction()));
            var valueExpr2 =
                new ValueExpression(
                    variable2,
                    new FuzzyTerm("MyTerm2", new MembershipFunction()));

            var andExpr = new AndExpression(valueExpr1, valueExpr2);

            var sut = new GetInvolvedVariables();

            var result = sut.Visit(andExpr);
            Assert.AreEqual(2, result.Count);
            Assert.IsTrue(result.Contains(variable1));
            Assert.IsTrue(result.Contains(variable2));

            result = andExpr.Accept(sut);
            Assert.AreEqual(2, result.Count);
            Assert.IsTrue(result.Contains(variable1));
            Assert.IsTrue(result.Contains(variable2));
        }
コード例 #9
0
        public override object Walk(AndExpression node)
        {
            var           lv      = node.LeftExpression.Accept(this);
            Func <object> rvThunk = () => node.RightExpression.Accept(this);

            return(OpAnd(lv, rvThunk));
        }
コード例 #10
0
            public void CanTranslateExpressionWithUnaryAndBinaryOperators()
            {
                // Prepare
                var x    = new FakeEvaluableExpression();
                var y    = new FakeEvaluableExpression();
                var z    = new FakeEvaluableExpression();
                var not  = new NotExpression();
                var and1 = new AndExpression();
                var and2 = new AndExpression();

                Tokens.Add(x);
                Tokens.Add(and1);
                Tokens.Add(not);
                Tokens.Add(y);
                Tokens.Add(and2);
                Tokens.Add(z);

                // Act
                var result = Parser.TransformInfixToPostfix(Tokens).ToList();

                // Verify
                Assert.AreSame(x, result[0]);
                Assert.AreSame(y, result[1]);
                Assert.AreSame(not, result[2]);
                Assert.AreSame(and1, result[3]);
                Assert.AreSame(z, result[4]);
                Assert.AreSame(and2, result[5]);
            }
コード例 #11
0
        public void CanEvaluateAsynchronously()
        {
            // Prepare
            var leaf1 = new FakeEvaluableExpression(true, TimeSpan.FromSeconds(1));
            var leaf2 = new FakeEvaluableExpression(true);
            var leaf3 = new FakeEvaluableExpression(false);

            var notOp = new NotExpression {
                Left = leaf1
            };
            var andOp = new AndExpression {
                Left = notOp, Right = leaf2
            };

            var ast = new OrExpression {
                Left = andOp, Right = leaf3
            };
            var taskResult = ast.Evaluate(new CancellationToken());

            // Act
            taskResult.RunSynchronously();

            // Verify
            Assert.IsFalse(taskResult.Result);
        }
コード例 #12
0
        /// <summary>
        /// Applies a join-based filter to the criteria for the specified authorization view.
        /// </summary>
        /// <param name="criteria">The criteria to which filters should be applied.</param>
        /// <param name="whereJunction">The <see cref="ICriterion" /> container for adding WHERE clause criterion.</param>
        /// <param name="parameters">The named parameters to be used to satisfy additional filtering requirements.</param>
        /// <param name="viewName">The name of the view to be filtered.</param>
        /// <param name="joinPropertyName">The name of the property to be joined between the entity being queried and the authorization view.</param>
        /// <param name="filterPropertyName">The name of the property to be used for applying filter values.</param>
        /// <param name="joinType">The <see cref="JoinType" /> to be used.</param>
        public static void ApplyJoinFilter(
            this ICriteria criteria,
            Junction whereJunction,
            IDictionary <string, object> parameters,
            string viewName,
            string joinPropertyName,
            string filterPropertyName,
            JoinType joinType)
        {
            string authViewAlias = $"authView{viewName}";

            // Apply authorization join using ICriteria
            criteria.CreateEntityAlias(
                authViewAlias,
                Restrictions.EqProperty($"aggregateRoot.{joinPropertyName}", $"{authViewAlias}.{joinPropertyName}"),
                joinType,
                $"{viewName.GetAuthorizationViewClassName()}".GetFullNameForView());

            object value;

            // Defensive check to ensure required parameter is present
            if (!parameters.TryGetValue(filterPropertyName, out value))
            {
                throw new Exception($"Unable to find parameter for filtering '{filterPropertyName}' on view '{viewName}'.");
            }

            var arrayOfValues = value as object[];

            if (arrayOfValues != null)
            {
                if (joinType == JoinType.InnerJoin)
                {
                    whereJunction.Add(Restrictions.In($"{authViewAlias}.{filterPropertyName}", arrayOfValues));
                }
                else
                {
                    var and = new AndExpression(
                        Restrictions.In($"{authViewAlias}.{filterPropertyName}", arrayOfValues),
                        Restrictions.IsNotNull($"{authViewAlias}.{joinPropertyName}"));

                    whereJunction.Add(and);
                }
            }
            else
            {
                if (joinType == JoinType.InnerJoin)
                {
                    whereJunction.Add(Restrictions.Eq($"{authViewAlias}.{filterPropertyName}", value));
                }
                else
                {
                    var and = new AndExpression(
                        Restrictions.Eq($"{authViewAlias}.{filterPropertyName}", value),
                        Restrictions.IsNotNull($"{authViewAlias}.{joinPropertyName}"));

                    whereJunction.Add(and);
                }
            }
        }
コード例 #13
0
            public Bitmap Visit(AndExpression expr)
            {
                var left  = expr.Left.Accept(this);
                var right = expr.Right.Accept(this);

                left.And(right);
                return(left);
            }
コード例 #14
0
            protected override void VisitAndExpression(AndExpression expression)
            {
                base.VisitAndExpression(expression);

                var inner = Pop();

                Push(new And(inner));
            }
コード例 #15
0
        private AndExpression GetAndExpression(TypeEnum left, TypeEnum right)
        {
            ExpressionNode leftNode  = GetLiteral(left);
            ExpressionNode rightNode = GetLiteral(right);
            var            node      = new AndExpression(leftNode, rightNode, 0, 0);

            return(node);
        }
コード例 #16
0
        public static void SerializeAndExpression()
        {
            var v = new BooleanLiteral(true);
            var a = new AndExpression(v, v);
            var b = SerializationUtil.Reserialize(a);

            Assert.AreEqual(a, b);
        }
 public override void Visit(AndExpression expression)
 {
     _expressionString.Append(" (");
     Visit(expression.Left);
     _expressionString.Append(" && ");
     Visit(expression.Right);
     _expressionString.Append(") ");
 }
コード例 #18
0
        internal DateTime AllowAccess(string portName, string moduleName, string username)
        {
            AssertionExpression resourceAccessAssertion = new AssertionExpression(
                new AtomicAssertion(
                    localAuthority,
                    new AtomicClaim(
                        new ResourceAccessFact(
                            new StringPrincipal("port:" + portName),
                            new StringPrincipal("mod:" + moduleName),
                            new PrincipalVariable("$grp"),

                            new IntegerVariable("$from"),
                            new IntegerVariable("$to"),
                            new IntegerVariable("$day"),

                            new VerbVariable("$amode"),
                            new IntegerVariable("prio")))));

            AssertionExpression groupMembershipAssertion = new AssertionExpression(
                new AtomicAssertion(
                    localAuthority,
                    new AtomicClaim(
                        new UserGroupMembershipFact(
                            new StringPrincipal("usr:"******"$grp")))));
            DateTime currTime = DateTime.Now;

            int currMinute = currTime.Hour * 100 | currTime.Minute;

            Expression minutesMoreThanFrom = new ConstraintExpression(new LessThanOrEqualConstraint(new IntegerVariable("$from"), new IntegerHolder(currMinute)));
            Expression minutesLessThanTo   = new ConstraintExpression(new LessThanOrEqualConstraint(new IntegerHolder(currMinute), new IntegerVariable("$to")));
            Expression minutesInRange      = new AndExpression(minutesMoreThanFrom, minutesLessThanTo);

            int currDayOfWeek = (int)currTime.DayOfWeek;

            Expression noDayOfWeekRestriction = new NotExpression(new ConstraintExpression(new InequalityConstraint(new IntegerVariable("$day"), new IntegerHolder(-1))));
            Expression dayOfWeekMatches       = new NotExpression(new ConstraintExpression(new InequalityConstraint(new IntegerVariable("$day"), new IntegerHolder(currDayOfWeek))));
            Expression dayOfWeekAllowed       = new OrExpression(noDayOfWeekRestriction, dayOfWeekMatches);

            Query query = new Query(
                new AndExpression(
                    resourceAccessAssertion,
                    groupMembershipAssertion,
                    minutesInRange,
                    dayOfWeekAllowed));

            QueryContext context = new QueryContext(localAuthority, policyAssertions, query,
                                                    DateTime.UtcNow, new PrincipalIdentifier[] { }, new Uri[] { }, 0, false);

            ReadOnlyCollection <Answer> answers = new Microsoft.Secpal.Authorization.QueryEngine().ExecuteQuery(context);

            //logger.Log("\nquery: " + query + "\n");
            //logger.Log("answers: {0}", answers.Count.ToString());
            //foreach (Answer answer in answers)
            //    logger.Log(answer.Substitution.ToString());

            return((answers.Count > 0) ? DateTime.MaxValue : DateTime.MinValue);
        }
コード例 #19
0
        /// <summary>
        /// Applies a join-based filter to the criteria for the specified authorization view.
        /// </summary>
        /// <param name="criteria">The criteria to which filters should be applied.</param>
        /// <param name="whereJunction">The <see cref="ICriterion" /> container for adding WHERE clause criterion.</param>
        /// <param name="parameters">The named parameters to be used to satisfy additional filtering requirements.</param>
        /// <param name="viewName">The name of the view to be filtered.</param>
        /// <param name="subjectEndpointName">The name of the property to be joined for the entity being queried .</param>
        /// <param name="viewTargetEndpointName">The name of the property to be joined for the other property as authorization view.</param>
        /// <param name="joinType">The <see cref="JoinType" /> to be used.</param>
        /// <param name="authViewAlias">The name of the property to be used for auth View Alias name.</param>
        public static void ApplyJoinFilter(
            this ICriteria criteria,
            Junction whereJunction,
            IDictionary <string, object> parameters,
            string viewName,
            string subjectEndpointName,
            string viewTargetEndpointName,
            JoinType joinType,
            string authViewAlias = null)
        {
            authViewAlias = string.IsNullOrWhiteSpace(authViewAlias) ? $"authView{viewName}" : $"authView{authViewAlias}";

            // Apply authorization join using ICriteria
            criteria.CreateEntityAlias(
                authViewAlias,
                Restrictions.EqProperty($"aggregateRoot.{subjectEndpointName}",
                                        $"{authViewAlias}.{viewTargetEndpointName}"),
                joinType,
                $"{viewName.GetAuthorizationViewClassName()}".GetFullNameForView());

            // Defensive check to ensure required parameter is present
            if (!parameters.TryGetValue(RelationshipAuthorizationConventions.ClaimsParameterName, out object value))
            {
                throw new Exception($"Unable to find parameter for filtering '{RelationshipAuthorizationConventions.ClaimsParameterName}' on view '{viewName}'. Available parameters: '{string.Join("', '", parameters.Keys)}'");
            }

            if (value is object[] arrayOfValues)
            {
                if (joinType == JoinType.InnerJoin)
                {
                    whereJunction.Add(Restrictions.In($"{authViewAlias}.{RelationshipAuthorizationConventions.ViewSourceColumnName}", arrayOfValues));
                }
                else
                {
                    var and = new AndExpression(
                        Restrictions.In($"{authViewAlias}.{RelationshipAuthorizationConventions.ViewSourceColumnName}", arrayOfValues),
                        Restrictions.IsNotNull($"{authViewAlias}.{viewTargetEndpointName}"));

                    whereJunction.Add(and);
                }
            }
            else
            {
                if (joinType == JoinType.InnerJoin)
                {
                    whereJunction.Add(Restrictions.Eq($"{authViewAlias}.{RelationshipAuthorizationConventions.ViewSourceColumnName}", value));
                }
                else
                {
                    var and = new AndExpression(
                        Restrictions.Eq($"{authViewAlias}.{RelationshipAuthorizationConventions.ViewSourceColumnName}", value),
                        Restrictions.IsNotNull($"{authViewAlias}.{viewTargetEndpointName}"));

                    whereJunction.Add(and);
                }
            }
        }
コード例 #20
0
ファイル: SODAQueryBuilder.cs プロジェクト: git-thinh/limada
            public virtual void Visit(AndExpression expression)
            {
                expression.Left().Accept(this);
                IConstraint left = _constraint;

                expression.Right().Accept(this);
                left.And(_constraint);
                _constraint = left;
            }
コード例 #21
0
        public void TestBothTrueEvaluate()
        {
            var expression = new AndExpression(
                Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)true),
                Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)true),
                new Context(ExpressiveOptions.None));

            Assert.AreEqual(true, expression.Evaluate(null));
        }
コード例 #22
0
        public void TestRightTrueEvaluate()
        {
            var expression = new AndExpression(
                Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)false),
                Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)true),
                ExpressiveOptions.None);

            Assert.AreEqual(false, expression.Evaluate(null));
        }
コード例 #23
0
ファイル: FSM.cs プロジェクト: letmefly/unity
    private Expression CreateExpression(List <Token> tokens)
    {
        Expression currExpression = null;

        if (mTokenIdx >= tokens.Count)
        {
            return(currExpression);
        }

        if (tokens[mTokenIdx].mType == eTokenType.TOK_CONDITION)
        {
            currExpression = new ConditionExpression(tokens[mTokenIdx].mIndex);
            mExpressions.Add(currExpression);
        }
        else if (tokens[mTokenIdx].mType == eTokenType.TOK_OPEN_PAREN)
        {
            mTokenIdx     += 1;
            currExpression = CreateExpression(tokens);
        }
        else if (tokens[mTokenIdx].mType == eTokenType.TOK_NOT)
        {
            mTokenIdx += 1;
            Expression childExpression = CreateExpression(tokens);
            Expression expression      = new NotExpression(childExpression);
            mExpressions.Add(expression);
            currExpression = expression;
        }

        // Right Expressions
        if (mTokenIdx + 1 >= tokens.Count)
        {
            return(currExpression);
        }

        mTokenIdx += 1;
        if (tokens[mTokenIdx].mType == eTokenType.TOK_AND)
        {
            mTokenIdx += 1;
            Expression childA     = currExpression;
            Expression childB     = CreateExpression(tokens);
            Expression expression = new AndExpression(childA, childB);
            mExpressions.Add(expression);
            currExpression = expression;
        }
        else if (tokens[mTokenIdx].mType == eTokenType.TOK_OR)
        {
            mTokenIdx += 1;
            Expression childA = currExpression;
            Expression childB = CreateExpression(tokens);

            Expression expression = new OrExpression(childA, childB);
            mExpressions.Add(expression);
            currExpression = expression;
        }

        return(currExpression);
    }
コード例 #24
0
        private bool MatchAndExpression(AndExpression expression)
        {
            if (!expression.Expressions.Any())
            {
                return(false);
            }

            return(expression.Expressions.All(MatchOne));
        }
コード例 #25
0
        public override void ExitLogicalExpressionAnd([NotNull] RuleSetGrammarParser.LogicalExpressionAndContext context)
        {
            // popping order matters
            LogicalExpression right = logicalExpressions.Pop();
            LogicalExpression left  = logicalExpressions.Pop();
            AndExpression     expr  = new AndExpression(left, right);

            this.logicalExpressions.Push(expr);
        }
コード例 #26
0
        private void DoTestEvaluate(IExpression a, IExpression b, bool expected)
        {
            // Arrange
            IExpression expression = new AndExpression(a, b);

            // Act
            bool result = expression.Evaluate(null);

            // Assert
            Assert.AreEqual(expected, result);
        }
コード例 #27
0
        private ISqlElement CreateUnionCondition(QueryEntityProperty property, QueryEntity nestedEntity)
        {
            if (!nestedEntity.mapping.Index.HasValue)
            {
                const string messageFormat = "invalid table name [{0}], table name must contain index";
                throw new InvalidOperationException(string.Format(messageFormat,
                                                                  nestedEntity.mapping.DbTableName));
            }
            var tableIndexColumnName = property.mapping.UnionLayout.TableIndexColumnName;

            if (string.IsNullOrEmpty(tableIndexColumnName))
            {
                const string messageFormat = "tableIndex column is not defined for [{0}.{1}]";
                throw new InvalidOperationException(string.Format(messageFormat,
                                                                  property.referer.mapping.QueryTableName, property.mapping.PropertyName));
            }
            ISqlElement result = new EqualityExpression
            {
                Left = new ColumnReferenceExpression
                {
                    Name  = tableIndexColumnName,
                    Table = GetTableDeclaration(property.referer)
                },
                Right = new LiteralExpression
                {
                    Value   = nestedEntity.mapping.Index,
                    SqlType = SqlType.ByteArray
                }
            };
            var typeColumnName = property.mapping.UnionLayout.TypeColumnName;

            if (!string.IsNullOrEmpty(typeColumnName))
            {
                result = new AndExpression
                {
                    Left = new EqualityExpression
                    {
                        Left = new ColumnReferenceExpression
                        {
                            Name  = typeColumnName,
                            Table = GetTableDeclaration(property.referer)
                        },
                        Right = new LiteralExpression
                        {
                            Value   = configurationItemReferenceType,
                            SqlType = SqlType.ByteArray
                        }
                    },
                    Right = result
                }
            }
            ;
            return(result);
        }
コード例 #28
0
ファイル: NodeWalker.cs プロジェクト: buunguyen/bike
 public virtual object Walk(AndExpression node)
 {
     if (Enter(node))
     {
         node.LeftExpression.Accept(this);
         if (node.RightExpression != null)
             node.RightExpression.Accept(this);
     }
     Exit(node);
     return null;
 }
コード例 #29
0
 public Expression VisitAndConvert(IExpression expression)
 {
     return(expression switch
     {
         AndExpression andExpression => VisitAndConvert(andExpression),
         CompareExpression compareExpression => VisitAndConvert(compareExpression),
         InExpression inExpression => VisitAndConvert(inExpression),
         NotExpression notExpression => VisitAndConvert(notExpression),
         OrExpression orExpression => VisitAndConvert(orExpression),
         AssignExpression assignExpression => VisitAndConvert(assignExpression),
         _ => null
     });
コード例 #30
0
ファイル: ParserTests.cs プロジェクト: smartcaveman/AjSharp
        public void ParseAndExpression()
        {
            IExpression expression = ParseExpression("k==1 && l==1");

            Assert.IsNotNull(expression);
            Assert.IsInstanceOfType(expression, typeof(AndExpression));

            AndExpression andexpr = (AndExpression)expression;

            Assert.IsInstanceOfType(andexpr.LeftExpression, typeof(CompareExpression));
            Assert.IsInstanceOfType(andexpr.RightExpression, typeof(CompareExpression));
        }
コード例 #31
0
        public void Should_parse_AndExpression(string input, AndExpression expected)
        {
            // Arrange
            _outputHelper.WriteLine($"input : '{input}'");
            TokenList <FilterToken> tokens = _tokenizer.Tokenize(input);

            // Act
            FilterExpression expression = FilterTokenParser.And.Parse(tokens);

            // Assert
            AssertThatShould_parse(expression, expected);
        }
コード例 #32
0
        public void TestShortCircuit()
        {
            var rightHandMock = new Mock <IExpression>();

            var expression = new AndExpression(
                Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)false),
                rightHandMock.Object,
                new Context(ExpressiveOptions.None));

            expression.Evaluate(null);

            rightHandMock.Verify(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()), Times.Never);
        }
コード例 #33
0
 public virtual object Walk(AndExpression node)
 {
     if (Enter(node))
     {
         node.LeftExpression.Accept(this);
         if (node.RightExpression != null)
         {
             node.RightExpression.Accept(this);
         }
     }
     Exit(node);
     return(null);
 }
コード例 #34
0
        public void Visit(AndExpression expression)
        {
            foreach (var queryExpression in expression.Expressions)
            {
                var matcher = new InMemoryRowMatcher(_row, queryExpression);

                if (!matcher.IsMatch())
                {
                    _isMatch = false;
                    return;
                }
            }
        }
コード例 #35
0
        public void Constructor()
        {
            var termA = new FuzzyTerm("TermA", new MembershipFunction());
            var termB = new FuzzyTerm("TermB", new MembershipFunction());
            var varA = new FuzzyVariable("Variable A", null, termA);
            var varB = new FuzzyVariable("Variable B", null, termB);

            var exprA = new ValueExpression(varA, termA);
            var exprB = new ValueExpression(varB, termB);

            var sut = new AndExpression(exprA, exprB);

            Assert.AreEqual(exprA, sut.LeftExpression);
            Assert.AreEqual(exprB, sut.RightExpression);
        }
コード例 #36
0
        public void Conjunction_of_multiple_equality_comparisons_is_parsed_into_AndExpression_with_corresponding_property_names_and_values()
        {
            var pageCount = 123;
            var expression = _parser.Parse<Book>(
                x => x.AuthorName == "An author name" &&
                     x.Title == GetTitle() &&
                     x.PageCount == pageCount &&
                     x.Isbn == "123-456-789");

            var expectedExpression = new AndExpression(
                new EqualsExpression(new PropertyExpression("AuthorName", typeof(string)), new ValueExpression("An author name")),
                new EqualsExpression(new PropertyExpression("Title", typeof(string)), new ValueExpression("a title")),
                new EqualsExpression(new PropertyExpression("PageCount", typeof(int)), new ValueExpression(123)),
                new EqualsExpression(new PropertyExpression("Isbn", typeof(string)), new ValueExpression("123-456-789")));

            Assert.AreEqual(expectedExpression, expression);
        }
コード例 #37
0
        public void VisitAnd()
        {
            var valueExpr1 =
                new ValueExpression(
                    new FuzzyVariable("MyFuzzyVariable1", new NumericVariable("MyNumVariable1")),
                    new FuzzyTerm("MyTerm1", new MembershipFunction()));
            var valueExpr2 =
                new ValueExpression(
                    new FuzzyVariable("MyFuzzyVariable2", new NumericVariable("MyNumVariable2")),
                    new FuzzyTerm("MyTerm2", new MembershipFunction()));

            var andExpr = new AndExpression(valueExpr1, valueExpr2);

            var sut = new ToStringVisitor();

            var result = sut.Visit(andExpr);
            Assert.AreEqual("MyFuzzyVariable1=MyTerm1 && MyFuzzyVariable2=MyTerm2", result);

            result = andExpr.Accept(sut);
            Assert.AreEqual("MyFuzzyVariable1=MyTerm1 && MyFuzzyVariable2=MyTerm2", result);
        }
コード例 #38
0
        public void Accept()
        {
            var termA = new FuzzyTerm("TermA", new MembershipFunction());
            var termB = new FuzzyTerm("TermB", new MembershipFunction());
            var varA = new FuzzyVariable("Variable A", null, termA);
            var varB = new FuzzyVariable("Variable B", null, termB);

            var mocks = new MockRepository();

            var visitor = mocks.StrictMock<IExpressionVisitor<int>>();

            var sut = new AndExpression(new ValueExpression(varA, termA), new ValueExpression(varB, termB));

            Expect.Call(visitor.Visit(sut)).Return(42);

            mocks.ReplayAll();

            var result = sut.Accept(visitor);

            Assert.AreEqual(42, result);

            mocks.VerifyAll();
        }
コード例 #39
0
 public virtual bool Enter(AndExpression node)
 {
     return true;
 }
コード例 #40
0
 public virtual void Exit(AndExpression node)
 {
 }
コード例 #41
0
 // AndExpression
 public override bool Walk(AndExpression node) { return Location >= node.StartIndex && Location <= node.EndIndex; }
コード例 #42
0
 public virtual void PostWalk(AndExpression node) { }
コード例 #43
0
 public override void PostWalk(AndExpression node) { }
コード例 #44
0
ファイル: PrintNodeWalker.cs プロジェクト: buunguyen/bike
 public override bool Enter(AndExpression node)
 {
     Print("AndExpression");
     level++;
     return true;
 }
コード例 #45
0
		public void Visit(AndExpression x)
		{
			
		}
コード例 #46
0
		public ISymbolValue Visit(AndExpression x)
		{
			return E_MathOp(x);
		}
コード例 #47
0
ファイル: Parser_Impl.cs プロジェクト: rainers/D_Parser
 IExpression ParseAsmAndExpression(IBlockNode Scope, IStatement Parent)
 {
     var left = ParseAsmEqualExpression(Scope, Parent);
     while (laKind == BitwiseAnd)
     {
         Step();
         var e = new AndExpression();
         e.LeftOperand = left;
         e.RightOperand = ParseAsmEqualExpression(Scope, Parent);
         left = e;
     }
     return left;
 }
コード例 #48
0
ファイル: Parser_Impl.cs プロジェクト: rainers/D_Parser
        IExpression AndExpression(IBlockNode Scope = null)
        {
            // Note: Since we ignored all kinds of CmpExpressions in AndAndExpression(), we have to take CmpExpression instead of ShiftExpression here!
            var left = CmpExpression(Scope);
            if (laKind != BitwiseAnd)
                return left;

            Step();
            var ae = new AndExpression();
            ae.LeftOperand = left;
            ae.RightOperand = AndExpression(Scope);
            return ae;
        }
コード例 #49
0
ファイル: FSM.cs プロジェクト: letmefly/unity
    private Expression CreateExpression(List<Token> tokens)
    {
        Expression currExpression = null;

        if (mTokenIdx >= tokens.Count)
        {
            return currExpression;
        }

        if (tokens[mTokenIdx].mType == eTokenType.TOK_CONDITION)
        {
            currExpression = new ConditionExpression(tokens[mTokenIdx].mIndex);
            mExpressions.Add(currExpression);
        }
        else if (tokens[mTokenIdx].mType == eTokenType.TOK_OPEN_PAREN)
        {
            mTokenIdx += 1;
            currExpression = CreateExpression(tokens);
        }
        else if (tokens[mTokenIdx].mType == eTokenType.TOK_NOT)
        {
            mTokenIdx += 1;
            Expression childExpression = CreateExpression(tokens);
            Expression expression = new NotExpression(childExpression);
            mExpressions.Add(expression);
            currExpression = expression;
        }

        // Right Expressions
        if (mTokenIdx + 1 >= tokens.Count)
        {
            return currExpression;
        }

        mTokenIdx += 1;
        if (tokens[mTokenIdx].mType == eTokenType.TOK_AND)
        {
            mTokenIdx += 1;
            Expression childA = currExpression;
            Expression childB = CreateExpression(tokens);
            Expression expression = new AndExpression(childA, childB);
            mExpressions.Add(expression);
            currExpression = expression;
        }
        else if (tokens[mTokenIdx].mType == eTokenType.TOK_OR)
        {
            mTokenIdx += 1;
            Expression childA = currExpression;
            Expression childB = CreateExpression(tokens);

            Expression expression = new OrExpression(childA, childB);
            mExpressions.Add(expression);
            currExpression = expression;
        }

        return currExpression;
    }
コード例 #50
0
        public void Update_command_for_mass_update_with_query_constraint_and_multiple_setters_creates_parameterized_sql_with_matching_where_and_set_clauses()
        {
            var columnConstraints = new Dictionary<string, object>();
            var columnSetters = new Dictionary<string, object>();

            columnSetters["ColumnName1"] = "value 1";
            columnSetters["ColumnName2"] = "value 2";

            columnConstraints["ColumnName3"] = "value 3";
            columnConstraints["ColumnName4"] = "value 4";

            var expression = new AndExpression(
                new EqualsExpression(new PropertyExpression("ColumnName3"), new ValueExpression("value 3")),
                new EqualsExpression(new PropertyExpression("ColumnName4"), new ValueExpression("value 4")));

            var sqlCommand = _generator.CreateUpdateCommand("TableName", expression, columnSetters);

            var expectedSql = "UPDATE [TableName] SET [ColumnName1] = @ColumnName1, [ColumnName2] = @ColumnName2 " +
                              "WHERE ([ColumnName3] = @ColumnName3Constraint AND [ColumnName4] = @ColumnName4Constraint)";

            Assert.AreEqual(expectedSql, sqlCommand.CommandText);

            Assert.AreEqual(4, sqlCommand.Parameters.Count);

            var actualParameters = sqlCommand.Parameters.OfType<SqlParameter>().OrderBy(x => x.ParameterName).ToList();

            Assert.AreEqual("ColumnName1", actualParameters[0].ParameterName);
            Assert.AreEqual("value 1", actualParameters[0].Value);
            Assert.AreEqual("ColumnName2", actualParameters[1].ParameterName);
            Assert.AreEqual("value 2", actualParameters[1].Value);
            Assert.AreEqual("ColumnName3Constraint", actualParameters[2].ParameterName);
            Assert.AreEqual("value 3", actualParameters[2].Value);
            Assert.AreEqual("ColumnName4Constraint", actualParameters[3].ParameterName);
            Assert.AreEqual("value 4", actualParameters[3].Value);
        }
コード例 #51
0
ファイル: PrintNodeWalker.cs プロジェクト: buunguyen/bike
 public override void Exit(AndExpression node)
 {
     level--;
 }
コード例 #52
0
ファイル: Parser.cs プロジェクト: buunguyen/bike
        public ExprNode ParseLogicalAndExpression()
        {
            var exp = new AndExpression
                          {
                              Token = Next(),
                              LeftExpression = ParseEqualityExpression()
                          };
            if (Next().IsNot(TokenType.LogicalAnd))
                return exp.LeftExpression;

            Match(TokenType.LogicalAnd);
            exp.RightExpression = ParseLogicalAndExpression();
            return exp;
        }
コード例 #53
0
        public void Delete_command_with_query_constraint_creates_parameterized_delete_with_corresponding_where_clause()
        {
            var expression = new AndExpression(
                new EqualsExpression(new PropertyExpression("ColumnName1"), new ValueExpression("value 1")),
                new EqualsExpression(new PropertyExpression("ColumnName2"), new ValueExpression("value 2")));

            var sqlCommand = _generator.CreateDeleteCommand("TableName", expression);
            var actualParameters = sqlCommand.Parameters.SortByParameterName();

            var expectedSql = "DELETE FROM [TableName] " +
                              "WHERE ([ColumnName1] = @ColumnName1Constraint AND [ColumnName2] = @ColumnName2Constraint)";

            Assert.AreEqual(expectedSql, sqlCommand.CommandText);

            Assert.AreEqual(2, sqlCommand.Parameters.Count);

            Assert.AreEqual("ColumnName1Constraint", actualParameters[0].ParameterName);
            Assert.AreEqual("value 1", actualParameters[0].Value);
            Assert.AreEqual("ColumnName2Constraint", actualParameters[1].ParameterName);
            Assert.AreEqual("value 2", actualParameters[1].Value);
        }
コード例 #54
0
ファイル: Interpreter.cs プロジェクト: buunguyen/bike
 public override object Walk(AndExpression node)
 {
     var lv = node.LeftExpression.Accept(this);
     Func<object> rvThunk = () => node.RightExpression.Accept(this);
     return OpAnd(lv, rvThunk);
 }
コード例 #55
0
        // *** BEGIN GENERATED CODE ***
        // generated by function: gen_python_walker_nr from: generate_walker.py

        // AndExpression
        public override bool Walk(AndExpression node) { return false; }
コード例 #56
0
 public void Visit(AndExpression expression)
 {
     DoBooleanAggregate(expression, CodeBinaryOperatorType.BooleanAnd);
 }
コード例 #57
0
        // This is generated by the srcipts\generate_walker.py script.
        // That will scan all types that derive from the IronPython AST nodes and inject into here.

        #region Generated Python AST Walker

        // *** BEGIN GENERATED CODE ***
        // generated by function: gen_python_walker from: generate_walker.py

        // AndExpression
        public virtual bool Walk(AndExpression node) { return true; }
コード例 #58
0
        internal DateTime AllowAccess(string portName, string moduleName, string username)
        {

            AssertionExpression resourceAccessAssertion = new AssertionExpression(
                                                              new AtomicAssertion(
                                                                  localAuthority,
                                                                  new AtomicClaim(
                                                                      new ResourceAccessFact(
                                                                          new StringPrincipal("port:" + portName),
                                                                          new StringPrincipal("mod:" + moduleName),
                                                                          new PrincipalVariable("$grp"),

                                                                          new IntegerVariable("$from"),
                                                                          new IntegerVariable("$to"),
                                                                          new IntegerVariable("$day"),

                                                                          new VerbVariable("$amode"),
                                                                          new IntegerVariable("prio")))));

            AssertionExpression groupMembershipAssertion = new AssertionExpression(
                                                               new AtomicAssertion(
                                                                    localAuthority,
                                                                    new AtomicClaim(
                                                                        new UserGroupMembershipFact(
                                                                            new StringPrincipal("usr:"******"$grp")))));
            DateTime currTime = DateTime.Now;
            
            int currMinute = currTime.Hour * 100 | currTime.Minute;
            
            Expression minutesMoreThanFrom = new ConstraintExpression(new LessThanOrEqualConstraint(new IntegerVariable("$from"), new IntegerHolder(currMinute)));
            Expression minutesLessThanTo = new ConstraintExpression(new LessThanOrEqualConstraint(new IntegerHolder(currMinute), new IntegerVariable("$to")));
            Expression minutesInRange = new AndExpression(minutesMoreThanFrom, minutesLessThanTo);

            int currDayOfWeek = (int) currTime.DayOfWeek;

            Expression noDayOfWeekRestriction = new NotExpression(new ConstraintExpression(new InequalityConstraint(new IntegerVariable("$day"), new IntegerHolder(-1))));
            Expression dayOfWeekMatches = new NotExpression(new ConstraintExpression(new InequalityConstraint(new IntegerVariable("$day"), new IntegerHolder(currDayOfWeek))));
            Expression dayOfWeekAllowed = new OrExpression(noDayOfWeekRestriction, dayOfWeekMatches);

            Query query = new Query(
                              new AndExpression(
                                  resourceAccessAssertion,
                                  groupMembershipAssertion,
                                  minutesInRange,
                                  dayOfWeekAllowed));
                              
            QueryContext context = new QueryContext(localAuthority, policyAssertions, query, 
                                                    DateTime.UtcNow, new PrincipalIdentifier[] { }, new Uri[] { }, 0, false);

            ReadOnlyCollection<Answer> answers = new Microsoft.Secpal.Authorization.QueryEngine().ExecuteQuery(context);

            //logger.Log("\nquery: " + query + "\n");
            //logger.Log("answers: {0}", answers.Count.ToString());
            //foreach (Answer answer in answers)
            //    logger.Log(answer.Substitution.ToString());

            return (answers.Count > 0) ? DateTime.MaxValue : DateTime.MinValue;
                
        }
コード例 #59
0
        private static AstExpression ParseExpression(Dictionary<string, Pivots.Pivot> pivotVsPivotValues,
            GetChoiceDelegate get_choice_fn, string expression) {
            AstExpression result = null;
            var rxResult = Pivots.ExpressionRx.Match(expression);
            if (rxResult.Success) {
                var state = ExpressionState.None;
                AstExpression current = null;
                bool invert = false;

                foreach (var item in rxResult.Groups[1].Captures.Cast<Capture>().Select(each => each.Value.Trim()).Where(each => !string.IsNullOrEmpty(each))) {
                    switch (item[0]) {
                        case '!':
                            if (result != null && state == ExpressionState.None) {
                                throw new ClrPlusException("Invalid expression. (not expression must be separated from previous expression with an operator)");
                            }
                            if (item.Length % 2 != 0)
                                invert = !invert;
                            continue;

                        case '&':
                        case ',':
                        case '\\':
                        case '/':
                            if (state != ExpressionState.None) {
                                throw new ClrPlusException("Invalid expression. (May not state two operators in a row)");
                            }
                            if (result == null) {
                                throw new ClrPlusException("Invalid expression. (may not start with an operator)");
                            }
                            state = ExpressionState.HasAnd;
                            continue;

                        case '|':
                        case '+':
                            if (state != ExpressionState.None) {
                                throw new ClrPlusException("Invalid expression. (May not state two operators in a row)");
                            }
                            if (result == null) {
                                throw new ClrPlusException("Invalid expression. (may not start with an operator)");
                            }
                            state = ExpressionState.HasOr;
                            continue;

                        case '(':
                            if (result != null && state == ExpressionState.None) {
                                throw new ClrPlusException("Invalid expression. (nested expression must be separated from previous expression with an operator)");
                            }
                            if (item.EndsWith(")")) {
                                // parse nested expression.
                                current = ParseExpression(pivotVsPivotValues, get_choice_fn, item.Substring(1, item.Length - 2));
                                break;
                            }
                            throw new ClrPlusException("Mismatched '(' in expression");

                        default:
                            if (!Pivots.WordRx.IsMatch(item)) {
                                throw new ClrPlusException("Invalid characters in expression");
                            }
                            if (result != null && state == ExpressionState.None) {
                                throw new ClrPlusException("Invalid expression. (expression must be separated from previous expression with an operator)");
                            }
                            // otherwise, it's the word we're looking for.
                            // 
                            string choice;
                            string pivot;

                            if (get_choice_fn(item, out choice, out pivot)) {
                                current = new PivotExpression(pivot, choice, false);
                                break;
                            }
                            else if (item.ToLowerInvariant() == "true") {
                                current = TrueExpression.instance;
                                break;
                            }
                            else if (item.ToLowerInvariant() == "false") {
                                current = FalseExpression.instance;
                                break;
                            }

                            throw new ClrPlusException(string.Format("Unmatched configuration choice '{0}", item));
                    }

                    if (invert)
                        current = current.Invert();

                    switch (state) {
                        case ExpressionState.None:
                            result = current;
                            continue;
                        case ExpressionState.HasAnd:
                            result = new AndExpression(result, current);
                            break;
                        case ExpressionState.HasOr:
                            result = new OrExpression(result, current);
                            break;
                    }

                    current = null;
                    state = ExpressionState.None;
                }
            }

            if (result == null)
                result = TrueExpression.instance;

            return result;
        }
コード例 #60
0
 private string GetExpression(AndExpression expression, ref List<OleDbParameter> parameters)
 {
     return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " AND " +
       GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ";
 }