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