public async Task AndPredicateExample() { var imposter = _client.CreateTcpImposter(4554, "AndPredicateExample"); var startsWithFields = new TcpPredicateFields { Data = "start" }; var startsWith = new StartsWithPredicate <TcpPredicateFields>(startsWithFields); var endsWithFields = new TcpPredicateFields { Data = "end\n" }; var endsWith = new EndsWithPredicate <TcpPredicateFields>(endsWithFields); var containsFields = new TcpPredicateFields { Data = "middle" }; var contains = new ContainsPredicate <TcpPredicateFields>(containsFields); var predicate = new AndPredicate(new List <PredicateBase> { startsWith, endsWith, contains }); imposter.AddStub().On(predicate) .ReturnsData("matches"); await _client.SubmitAsync(imposter); }
public void TestAndContainingInactiveOr() { var filter = new OrPredicate <string> { new Predicate <string> { Expression = (ev) => true }, new Predicate <string> { Expression = (ev) => false }, }; filter.Active = false; var filter2 = new OrPredicate <string> { new Predicate <string> { Expression = (ev) => true }, new Predicate <string> { Expression = (ev) => false }, }; var container = new AndPredicate <string> (); container.Add(filter); container.Add(filter2); Assert.IsFalse(filter.Elements [0].Active); Assert.IsFalse(filter.Elements [1].Active); Assert.IsFalse(filter.Filter("")); Assert.IsTrue(filter2.Filter("")); Assert.IsTrue(container.Filter("")); }
public void TestAndContainingOrSetActive() { // Arrange var filter = new OrPredicate <string> { new Predicate <string> { Expression = (ev) => true }, new Predicate <string> { Expression = (ev) => true }, }; var filter2 = new OrPredicate <string> { new Predicate <string> { Expression = (ev) => true }, new Predicate <string> { Expression = (ev) => true }, }; var container = new AndPredicate <string> (); container.Add(filter); container.Add(filter2); // Act filter2.Active = false; // Assert Assert.IsFalse(filter2 [0].Active); Assert.IsFalse(filter2 [1].Active); Assert.IsTrue(container.Filter("")); }
public static AndPredicate And(this Expression operand) { AndPredicate andPredicate = new AndPredicate(); andPredicate.Operand = operand; return(andPredicate); }
public void TestAndContainingOr() { var filter = new OrPredicate <string> { new Predicate <string> { Expression = (ev) => true }, new Predicate <string> { Expression = (ev) => false }, }; var filter2 = new OrPredicate <string> { new Predicate <string> { Expression = (ev) => true }, new Predicate <string> { Expression = (ev) => false }, }; var container = new AndPredicate <string> (); container.Add(filter); container.Add(filter2); Assert.IsTrue(container.Filter("")); }
public string ConvertToString(TextPredicate predicate) { ContainsPhrase_Predicate contains = predicate as ContainsPhrase_Predicate; if (contains != null) { return(this.ConvertToString(contains)); } AndPredicate and = predicate as AndPredicate; if (and != null) { return(this.ConvertToString(and)); } OrPredicate or = predicate as OrPredicate; if (or != null) { return(this.ConvertToString(or)); } NotPredicate not = predicate as NotPredicate; if (not != null) { return(this.ConvertToString(not)); } throw new Exception("Unrecognized predicate: " + predicate); }
// AndExpression := EqualityExpression ('and' SS EqualityExpression)+ private State DoParseAndExpression1Rule(State _state, List <Result> _outResults) { State _start = _state; List <Result> results = new List <Result>(); _state = DoSequence(_state, results, delegate(State s, List <Result> r) { return(DoParse(s, r, "EqualityExpression")); }, delegate(State s, List <Result> r) { return(DoRepetition(s, r, 1, 2147483647, delegate(State s2, List <Result> r2) { return DoSequence(s2, r2, delegate(State s3, List <Result> r3) { return DoParseLiteral(s3, r3, "and"); }, delegate(State s3, List <Result> r3) { return DoParse(s3, r3, "SS"); }, delegate(State s3, List <Result> r3) { return DoParse(s3, r3, "EqualityExpression"); }); })); }); if (_state.Parsed) { Predicate value = results.Count > 0 ? results[0].Value : default(Predicate); value = new AndPredicate(from e in results where e.Value != null select e.Value); _outResults.Add(new Result(this, _start.Index, _state.Index - _start.Index, m_input, value)); } else { string expected; expected = "and expression"; if (expected != null) { _state = new State(_start.Index, false, ErrorSet.Combine(_start.Errors, new ErrorSet(_state.Errors.Index, expected))); } } return(_state); }
public override void VisitLeave(AndPredicate expression) { IsMatchPredicate exp = _matchStack.Pop(); _matchStack.Push( delegate(IInputIterator iterator) { _disableCapturingGroup.Push(true); _xmlDisableBackReferencePop.Push(true); Boolean result = true; Int32 savePosition = iterator.Index; if (exp(iterator)) { iterator.Index = savePosition; result &= true; } else { iterator.Index = savePosition; result &= false; } _xmlDisableBackReferencePop.Pop(); _disableCapturingGroup.Pop(); return(result); } ); }
public override void ExitAndPredicate(MiniSqlParserParser.AndPredicateContext context) { var right = (Predicate)_stack.Pop(); var comments = this.GetComments(context.K_AND()); var left = (Predicate)_stack.Pop(); var node = new AndPredicate(left, right, comments); _stack.Push(node); }
public string ConvertToString(AndPredicate predicate) { StringBuilder content = new StringBuilder(); foreach (TextPredicate child in predicate.Children) { content.Append(this.ConvertToString(child)); } return(this.ConvertToString(content.ToString(), this.And_Tag)); }
public void TestGrammarAndLetterA() { TestGrammar1 grammar = TestGrammar1.Create(); Nonterminal nonterminal = grammar.GetNonterminal(o => o.AndLetterA()); Assert.AreEqual("AndLetterA", nonterminal.Name); AndPredicate expression = (AndPredicate)nonterminal.Expression; Assert.AreEqual("LetterA", ((Nonterminal)expression.Operand).Name); }
public void AndPredicate_Constructor_SetsPredicateCollection() { var expectedPredicates = new List <PredicateBase> { new EqualsPredicate <TestPredicateFields>(null), new MatchesPredicate <TestPredicateFields>(null), }; var predicate = new AndPredicate(expectedPredicates); Assert.AreSame(expectedPredicates, predicate.Predicates); }
public AndPredicate Read_AndPredicate(XmlNode nodeRepresentation) { AndPredicate predicate = new AndPredicate(); foreach (XmlNode childNode in nodeRepresentation.ChildNodes) { TextPredicate child = this.ReadTextPredicate(childNode); predicate.AddChild(child); } return(predicate); }
public IPredicate <T> Build() { var builders = from item in _predicates select item.Build(); var predicate = new AndPredicate <T>(); predicate.AddPredicate(builders.ToArray()); return(predicate); }
public void AndPredicateTest() { var expr = AndPredicate.Create(baseExpr); var parser = Parser.Create(expr); { Assert.IsTrue(parser.Parse("123", out var ret, out _, out var end)); Assert.AreEqual("123", ret.ToString()); Assert.AreEqual(end, 0); } { Assert.IsFalse(parser.Parse("abc", out _, out _, out _)); } }
public void TestAndFalse() { var filter = new AndPredicate <string> { new Predicate <string> { Expression = (ev) => true }, new Predicate <string> { Expression = (ev) => false }, }; Assert.IsFalse(filter.Filter("")); }
private void AndButton_Clicked(object sender, EventArgs e) { AndPredicate and = new AndPredicate(); TextPredicate child = this.getPendingChildPredicate(); if (child != null) { and.AddChild(child); this.openPredicates.Add(and); } else { this.addChild(and); } this.updateLayout(); }
/// <summary> /// Parser for AndPredicate /// </summary> /// <returns>Parsed AndPredicate</returns> public AndPredicate ParseAndPredicate(Predicate parsedLeftPredicate) { AndPredicate andPredicate = new AndPredicate(); //Add left predicate andPredicate.SetLeftPredicate(parsedLeftPredicate); //Skip && tokens NextToken("&", "predicate && predicate", '&'); NextToken("&", "predicate && predicate", '&'); //Parse right predicate andPredicate.SetRightPredicate(ParsePredicate()); return(andPredicate); }
public virtual void TesCustomPredicate() { var mapOther = Client.GetMap <int, string>(TestSupport.RandomString()); var ep = new EqualPredicate(); var cp = new CustomPredicate <int, string>(); var ap = new AndPredicate(ep, cp); try { var keySet = mapOther.KeySet(ap); } finally { Assert.Pass("Predicate generics related compile test, if compiles it passes"); } }
public void TestAndContainingEmptyOr() { var filter = new OrPredicate <string> { new Predicate <string> { Expression = PredicateBuilder.True <string>() }, }; // This OR doesn't have any active Predicate, thus it's ignored var filter2 = new OrPredicate <string> (); var container = new AndPredicate <string> (); container.Add(filter); container.Add(filter2); Assert.IsTrue(container.Filter("")); }
public void ParseNotPredicateTest() { //Create parser PredicateParser predicateParser = new PredicateParser(Init("! condition1 && test.list?")); Predicate parsedPredicate = predicateParser.ParsePredicate(); //Check Predicates Assert.AreEqual(typeof(NotPredicate), parsedPredicate.GetType()); //Check AndPredicate Predicate parsedInnerPredicate = ((NotPredicate)parsedPredicate).GetPredicate(); Assert.AreEqual(typeof(AndPredicate), parsedInnerPredicate.GetType()); AndPredicate parsedInnerAndPredicate = (AndPredicate)parsedInnerPredicate; Assert.AreEqual(typeof(ExpressionPredicate), parsedInnerAndPredicate.GetLeftPredicate().GetType()); Assert.AreEqual(typeof(IsPredicate), parsedInnerAndPredicate.GetRightPredicate().GetType()); }
public void TestElementsEvents() { // Arrange string property = ""; int count = 0; int countElements = 0; var filter = new OrPredicate <string> { new Predicate <string> { Expression = (ev) => true }, new Predicate <string> { Expression = (ev) => false }, }; var filter2 = new OrPredicate <string> { new Predicate <string> { Expression = (ev) => true }, new Predicate <string> { Expression = (ev) => false }, }; var container = new AndPredicate <string> (); container.Elements.CollectionChanged += (sender, e) => { countElements++; }; container.PropertyChanged += (sender, e) => { property = e.PropertyName; count++; }; // Act container.Add(filter); container.Add(filter2); //Assert Assert.AreEqual("Collection_Elements", property); Assert.AreEqual(2, count); Assert.AreEqual(count, countElements); }
// add the given predicate as a child of the leafmost existing predicate private void addChild(TextPredicate predicate) { if (this.openPredicates.Count < 1) { // no predicates already exist, this one becomes the primary one this.openPredicates.Add(predicate); return; } TextPredicate last = this.openPredicates.Last(); OrPredicate or = last as OrPredicate; if (or != null) { // we have a pending 'or'; add it here or.AddChild(predicate); return; } AndPredicate and = last as AndPredicate; if (and != null) { // we have a pending 'and'; add it here and.AddChild(predicate); return; } NotPredicate not = last as NotPredicate; if (not != null) { // we have a pending 'not'; add it here not.Child = predicate; return; } if (last == null) { // We have an empty spot to add this predicate to // This user is expected to attach this to a parent later // If the user doesn't attach this to a parent later, we will for them this.openPredicates.RemoveAt(this.openPredicates.Count - 1); this.openPredicates.Add(predicate); return; } // error; do nothing }
public void TestAndOrEmpty() { // Arrange var filter = new OrPredicate <string> (); var filter2 = new OrPredicate <string> (); var container = new AndPredicate <string> (); container.Add(filter); container.Add(filter2); // Act // Assert Assert.IsFalse(filter.Active); Assert.IsFalse(filter2.Active); Assert.IsFalse(container.Active); Assert.IsTrue(container.Filter("")); }
public void TestAndEvents() { // Arrange string property = ""; int count = 0; var filter = new AndPredicate <string> (); filter.PropertyChanged += (sender, e) => { property = e.PropertyName; count++; }; // Act filter.Add(new Predicate <string> { Expression = (ev) => true }); //Assert Assert.AreEqual("Collection_Elements", property); Assert.AreEqual(1, count); }
public void ParsePredicateTest() { //Create parser PredicateParser predicateParser = new PredicateParser(Init("condition1 && condition2 || condition3")); Predicate parsedPredicate = predicateParser.ParsePredicate(); //Check Predicates Assert.AreEqual(typeof(AndPredicate), parsedPredicate.GetType()); //Check OrPredicate AndPredicate parsedAndPredicate = (AndPredicate)parsedPredicate; Assert.AreEqual(typeof(ExpressionPredicate), parsedAndPredicate.GetLeftPredicate().GetType()); Assert.AreEqual(typeof(OrPredicate), parsedAndPredicate.GetRightPredicate().GetType()); //Check nested OrPredicate OrPredicate parsedNestedOrPredicate = (OrPredicate)parsedAndPredicate.GetRightPredicate(); Assert.AreEqual(typeof(ExpressionPredicate), parsedNestedOrPredicate.GetLeftPredicate().GetType()); Assert.AreEqual(typeof(ExpressionPredicate), parsedNestedOrPredicate.GetRightPredicate().GetType()); }
public TimelineVM() { eventTypeToTimeline = new Dictionary <EventType, EventTypeTimelineVM> (); playerToTimeline = new Dictionary <Player, PlayerTimelineVM> (); EventTypesTimeline = new NestedViewModel <EventTypeTimelineVM> (); TeamsTimeline = new NestedViewModel <TeamTimelineVM> (); FullTimeline = CreateFullTimeline(); FullTimeline.ViewModels.CollectionChanged += HandleTimelineCollectionChanged; FullTimeline.PropertyChanged += FullTimeline_PropertyChanged; EditionCommand = new Command <TimelineEventVM> (HandleEditPlay); GroupEventsByEventTypeName = false; Filters = new AndPredicate <TimelineEventVM> (); EventsPredicate = new AndPredicate <TimelineEventVM> { Name = "Events", DisplayName = Catalog.GetString("Events") }; PeriodsPredicate = new OrPredicate <TimelineEventVM> { Name = "Periods", DisplayName = Catalog.GetString("Periods") }; TimersPredicate = new OrPredicate <TimelineEventVM> { Name = "Timers", DisplayName = Catalog.GetString("Timers") }; CommonTagsPredicate = new AndPredicate <TimelineEventVM> { Name = "Common Tags", DisplayName = Catalog.GetString("Common Tags") }; EventTypesPredicate = new OrPredicate <TimelineEventVM> { Name = "Event Types", DisplayName = Catalog.GetString("Event Types") }; TeamsPredicate = new OrPredicate <TimelineEventVM> { Name = "Teams", DisplayName = Catalog.GetString("Teams"), }; }
void IVisitor.VisitBefore(AndPredicate andPredicate) { this.ParentExists(andPredicate); }
void IVisitor.VisitAfter(AndPredicate andPredicate) { this.ParentExists(andPredicate); }
/// <summary> /// Method which evaluates an predicate and returns true or false /// </summary> /// <param name="predicate">Predicate to evaluate</param> /// <returns>True if predicate is true, otherwise false</returns> private bool EvaluatePredicate(Predicate predicate) { if (predicate is IsPredicate) { //Evaluate Expression Predicate IsPredicate isPredicate = (IsPredicate)predicate; Expression expression = isPredicate.GetExpression(); //In case of VarExpression, get expression from symboltable if (expression is VarExpression) { expression = GetReferenceExpression((VarExpression)expression); if (expression == null) { return(false); } } //If right type return true, otherwise false if (isPredicate.GetType() is StringType) { return(expression is TextExpression); } else if (isPredicate.GetType() is ListType) { return(expression is ListExpression); } else if (isPredicate.GetType() is RecordType) { return(expression is RecordExpression); } else { //No match between types which could be checked, so false return(false); } } else if (predicate is ExpressionPredicate) { //Evaluate Expression Predicate ExpressionPredicate expressionPredicate = (ExpressionPredicate)predicate; Expression expression = expressionPredicate.GetExpression(); if (expression is FieldExpression) { //Check if specific field exists in record (not null) Expression expr = GetExpression((FieldExpression)expression); return(expr != null); } else if (expression is VarExpression) { //Check if specific variable is defined VarExpression varExpr = (VarExpression)expression; return(SymbolTable.ContainsVariable(varExpr.GetVariableIdentifier())); } else { //Other expressions are always true, because they doesn't refer to something return(true); } } else if (predicate is AndPredicate) { //Evaluate And Predicate AndPredicate andPredicate = (AndPredicate)predicate; return(EvaluatePredicate(andPredicate.GetLeftPredicate()) && EvaluatePredicate(andPredicate.GetLeftPredicate())); } else if (predicate is OrPredicate) { //Evaluate Or Predicate OrPredicate orPredicate = (OrPredicate)predicate; return(EvaluatePredicate(orPredicate.GetLeftPredicate()) || EvaluatePredicate(orPredicate.GetRightPredicate())); } else if (predicate is NotPredicate) { //Evaluate Not Predicate NotPredicate notPredicate = (NotPredicate)predicate; return(!EvaluatePredicate(notPredicate.GetPredicate())); } return(false); }