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); }
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]); }
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]); }
/// <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; }
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 } }; }
protected override string VisitAnd(EntityConfiguration context, AndExpression expression) { return(string.Concat( expression.Left.Accept(this, context), " AND ", expression.Right.Accept(this, context))); }
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)); }
public override object Walk(AndExpression node) { var lv = node.LeftExpression.Accept(this); Func <object> rvThunk = () => node.RightExpression.Accept(this); return(OpAnd(lv, rvThunk)); }
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]); }
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); }
/// <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); } } }
public Bitmap Visit(AndExpression expr) { var left = expr.Left.Accept(this); var right = expr.Right.Accept(this); left.And(right); return(left); }
protected override void VisitAndExpression(AndExpression expression) { base.VisitAndExpression(expression); var inner = Pop(); Push(new And(inner)); }
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); }
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(") "); }
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); }
/// <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); } } }
public virtual void Visit(AndExpression expression) { expression.Left().Accept(this); IConstraint left = _constraint; expression.Right().Accept(this); left.And(_constraint); _constraint = left; }
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)); }
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)); }
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); }
private bool MatchAndExpression(AndExpression expression) { if (!expression.Expressions.Any()) { return(false); } return(expression.Expressions.All(MatchOne)); }
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); }
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); }
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); }
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; }
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 });
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)); }
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); }
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); }
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); }
public void Visit(AndExpression expression) { foreach (var queryExpression in expression.Expressions) { var matcher = new InMemoryRowMatcher(_row, queryExpression); if (!matcher.IsMatch()) { _isMatch = false; return; } } }
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); }
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); }
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); }
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(); }
public virtual bool Enter(AndExpression node) { return true; }
public virtual void Exit(AndExpression node) { }
// AndExpression public override bool Walk(AndExpression node) { return Location >= node.StartIndex && Location <= node.EndIndex; }
public virtual void PostWalk(AndExpression node) { }
public override void PostWalk(AndExpression node) { }
public override bool Enter(AndExpression node) { Print("AndExpression"); level++; return true; }
public void Visit(AndExpression x) { }
public ISymbolValue Visit(AndExpression x) { return E_MathOp(x); }
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; }
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; }
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; }
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); }
public override void Exit(AndExpression node) { level--; }
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; }
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); }
public override object Walk(AndExpression node) { var lv = node.LeftExpression.Accept(this); Func<object> rvThunk = () => node.RightExpression.Accept(this); return OpAnd(lv, rvThunk); }
// *** BEGIN GENERATED CODE *** // generated by function: gen_python_walker_nr from: generate_walker.py // AndExpression public override bool Walk(AndExpression node) { return false; }
public void Visit(AndExpression expression) { DoBooleanAggregate(expression, CodeBinaryOperatorType.BooleanAnd); }
// 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; }
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; }
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; }
private string GetExpression(AndExpression expression, ref List<OleDbParameter> parameters) { return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " AND " + GetExpressionDispatch(expression.Children[1], ref parameters) + " ) "; }