Пример #1
0
        public void SetActive_2LevelCompositePredicateChildChanged_ActivePropertyChangedEittedOnce()
        {
            int count       = 0;
            var childFilter = new Predicate <string> {
                Expression = (ev) => true
            };

            // Arrange
            var filter = new OrPredicate <string> {
                new OrPredicate <string> {
                    new Predicate <string> {
                        Expression = (ev) => true
                    },
                    childFilter,
                },
                new OrPredicate <string> {
                    new Predicate <string> {
                        Expression = (ev) => true
                    },
                    new Predicate <string> {
                        Expression = (ev) => true
                    },
                }
            };

            filter.PropertyChanged += (sender, e) => count++;

            childFilter.Active = false;

            Assert.AreEqual(1, count);
        }
Пример #2
0
        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(""));
        }
Пример #3
0
        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);
        }
Пример #4
0
        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(""));
        }
Пример #5
0
        private static bool ContainsEmbed(string input)
        {
            IElementPredicate predicate = new OrPredicate(new BeginTagPredicate("embed"), new BeginTagPredicate("object"));
            HtmlExtractor     ex        = new HtmlExtractor(input);

            return(ex.Seek(predicate).Success);
        }
Пример #6
0
    // OrExpression := AndExpression ('or' SS AndExpression)+
    private State DoParseOrExpression1Rule(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, "AndExpression")); },
                            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, "or"); },
                                                                                                                                              delegate(State s3, List <Result> r3) { return DoParse(s3, r3, "SS"); },
                                                                                                                                              delegate(State s3, List <Result> r3) { return DoParse(s3, r3, "AndExpression"); }); })); });

        if (_state.Parsed)
        {
            Predicate value = results.Count > 0 ? results[0].Value : default(Predicate);
            value = new OrPredicate(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 = "or expression";
            if (expected != null)
            {
                _state = new State(_start.Index, false, ErrorSet.Combine(_start.Errors, new ErrorSet(_state.Errors.Index, expected)));
            }
        }

        return(_state);
    }
Пример #7
0
        Size FindSizeAttribute(string input)
        {
            Size size = new Size(_width, _height);

            if (string.IsNullOrEmpty(input))
            {
                return(size);
            }

            try
            {
                RequiredAttribute[] attrWidth = new RequiredAttribute[] { new RequiredAttribute("width"), new RequiredAttribute("height") };
                IElementPredicate   predicate = new OrPredicate(new BeginTagPredicate("embed", attrWidth), new BeginTagPredicate("object", attrWidth));
                HtmlExtractor       ex        = new HtmlExtractor(input);
                if (ex.Seek(predicate).Success)
                {
                    BeginTag tag = (BeginTag)ex.Element;
                    size = new Size(Convert.ToInt32(tag.GetAttributeValue("width"), CultureInfo.InvariantCulture), Convert.ToInt32(tag.GetAttributeValue("height"), CultureInfo.InvariantCulture));
                }
            }
            catch (Exception ex)
            {
                Trace.Fail("Exception thrown while trying to find video size: " + ex);
            }

            return(size);
        }
Пример #8
0
        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(""));
        }
Пример #9
0
        void UpdateTeamsPredicates()
        {
            Filters.IgnoreEvents = true;
            TeamsPredicate.Clear();

            foreach (var team in new LMTeamVM [] { homeTeamVM, awayTeamVM })
            {
                var teamPredicate = new OrPredicate <TimelineEventVM> {
                    Name = team.Name,
                };
                teamPredicate.Add(new Predicate {
                    Name       = Catalog.GetString("Team"),
                    Expression = ev =>
                                 (ev.Model as LMTimelineEvent).TaggedTeams.Contains(team.Model)
                });
                foreach (var player in team)
                {
                    teamPredicate.Add(new Predicate {
                        Name       = player.Model.Name,
                        Expression = ev =>
                                     (ev.Model as LMTimelineEvent).Players.Contains(player.Model)
                    });
                }
                TeamsPredicate.Add(teamPredicate);
            }
            Filters.IgnoreEvents = false;
            RaisePropertyChanged("Collection", this);
        }
Пример #10
0
        public async Task OrPredicateExample()
        {
            var imposter = _client.CreateTcpImposter(4553, "OrPredicateExample");

            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 OrPredicate(new List <PredicateBase> {
                startsWith, endsWith, contains
            });

            imposter.AddStub().On(predicate)
            .ReturnsData("matches");

            await _client.SubmitAsync(imposter);
        }
        public override void ExitOrPredicate(MiniSqlParserParser.OrPredicateContext context)
        {
            var right    = (Predicate)_stack.Pop();
            var comments = this.GetComments(context.K_OR());
            var left     = (Predicate)_stack.Pop();
            var node     = new OrPredicate(left, right, comments);

            _stack.Push(node);
        }
Пример #12
0
        public string ConvertToString(OrPredicate predicate)
        {
            StringBuilder content = new StringBuilder();

            foreach (TextPredicate child in predicate.Children)
            {
                content.Append(this.ConvertToString(child));
            }
            return(this.ConvertToString(content.ToString(), this.Or_Tag));
        }
Пример #13
0
        public IPredicate <T> Build()
        {
            var builders = from item in _predicates
                           select item.Build();

            var predicate = new OrPredicate <T>();

            predicate.AddPredicate(builders.ToArray());

            return(predicate);
        }
Пример #14
0
        public OrPredicate Read_OrPredicate(XmlNode nodeRepresentation)
        {
            OrPredicate predicate = new OrPredicate();

            foreach (XmlNode childNode in nodeRepresentation.ChildNodes)
            {
                TextPredicate child = this.ReadTextPredicate(childNode);
                predicate.AddChild(child);
            }
            return(predicate);
        }
Пример #15
0
        public void OrPredicate_Constructor_SetsPredicateCollection()
        {
            var expectedPredicates = new List <PredicateBase>
            {
                new EqualsPredicate <TestPredicateFields>(null),
                new MatchesPredicate <TestPredicateFields>(null),
            };
            var predicate = new OrPredicate(expectedPredicates);

            Assert.AreSame(expectedPredicates, predicate.Predicates);
        }
Пример #16
0
        protected virtual void UpdateCommonTagsPredicates()
        {
            if (Project == null)
            {
                return;
            }
            bool oldIgnoreEvents = ViewModel.Filters.IgnoreEvents;

            ViewModel.Filters.IgnoreEvents = true;
            ViewModel.CommonTagsPredicate.Clear();

            var tags = Project.Dashboard.Model.CommonTagsByGroup;

            var listPredicates = new List <IPredicate <TimelineEventVM> > ();
            Expression <Func <TimelineEventVM, bool> > noTagsExpression = ev => true;

            foreach (var tagGroup in tags)
            {
                var tagsPredicates = new List <IPredicate <TimelineEventVM> > ();
                noTagsExpression = noTagsExpression.And(ev => !tagGroup.Value.Intersect(ev.Model.Tags).Any());

                Expression <Func <TimelineEventVM, bool> > tagGroupExpression = ev => ev.Model.Tags.Any(tag => tag.Group == tagGroup.Key);
                var tagGroupPredicate = new OrPredicate <TimelineEventVM> {
                    Name        = string.IsNullOrEmpty(tagGroup.Key) ? "General tags" : tagGroup.Key,
                    DisplayName = string.IsNullOrEmpty(tagGroup.Key) ? Catalog.GetString("General tags") : tagGroup.Key,
                };

                tagsPredicates.Add(new Predicate {
                    Name        = "None",
                    DisplayName = Catalog.GetString("None"),
                    Expression  = ev => !ev.Model.Tags.Any(tag => tag.Group == tagGroup.Key)
                });

                foreach (var tag in tagGroup.Value)
                {
                    tagsPredicates.Add(new Predicate {
                        Name        = tag.Value,
                        DisplayName = tag.Value,
                        Expression  = tagGroupExpression.And(ev => ev.Model.Tags.Contains(tag))
                    });
                }
                tagGroupPredicate.AddRange(tagsPredicates);
                listPredicates.Add(tagGroupPredicate);
            }

            ViewModel.CommonTagsPredicate.AddRange(listPredicates);
            ViewModel.Filters.IgnoreEvents = oldIgnoreEvents;
            if (!ViewModel.Filters.IgnoreEvents)
            {
                ViewModel.Filters.EmitPredicateChanged();
            }
        }
Пример #17
0
        public void TestOrFalse()
        {
            var filter = new OrPredicate <string> {
                new Predicate <string> {
                    Expression = (ev) => false
                },
                new Predicate <string> {
                    Expression = (ev) => false
                },
            };

            Assert.IsFalse(filter.Filter(""));
        }
Пример #18
0
 private static bool ContainsEmbedOrObject(string html)
 {
     try
     {
         IElementPredicate predicate = new OrPredicate(new BeginTagPredicate("embed"), new BeginTagPredicate("object"), new BeginTagPredicate("iframe"));
         HtmlExtractor     ex        = new HtmlExtractor(html);
         return(ex.Seek(predicate).Success);
     }
     catch
     {
         return(false);
     }
 }
        public OpenMediaReadyAction(IProtocol protocol) :
            base(protocol)
        {
            base.Request = RequestCancelNotReadyForMedia.Create("chat", null);

            OrPredicate <IMessage> filter = new OrPredicate <IMessage>(
                new MessageIdFilter(EventAck.MessageId),
                new MessageIdFilter(EventAgentAvailable.MessageId));

            filter.AddPredicate(new AgentStatusFilter("chat", 1));

            base.SuccessFilter = filter;
            base.FailureFilter = new MessageIdFilter(EventError.MessageId);
        }
Пример #20
0
        protected override void UpdateTeamsPredicates()
        {
            bool oldIgnoreEvents = ViewModel.Filters.IgnoreEvents;

            ViewModel.Filters.IgnoreEvents = true;
            ViewModel.TeamsPredicate.Clear();
            var teamsPredicates = new List <IPredicate <TimelineEventVM> > ();

            LMTimelineVM lmTimeline = (LMTimelineVM)ViewModel;
            LMTeamVM     homeTeamVM = (LMTeamVM)lmTimeline.HomeTeamTimelineVM.Team;
            LMTeamVM     awayTeamVM = (LMTeamVM)lmTimeline.AwayTeamTimelineVM.Team;

            teamsPredicates.Add(new Predicate {
                Name       = Catalog.GetString("No team / player tagged"),
                Expression = ev =>
                             (!(ev.Model as LMTimelineEvent).Teams.Any() &&
                              !(ev.Model as LMTimelineEvent).Players.Any())
            });

            foreach (var team in new LMTeamVM [] { homeTeamVM, awayTeamVM })
            {
                var playersPredicates = new List <IPredicate <TimelineEventVM> > ();
                var teamPredicate     = new OrPredicate <TimelineEventVM> {
                    Name = team.Name,
                };
                playersPredicates.Add(new Predicate {
                    Name       = Catalog.GetString("Team tagged"),
                    Expression = ev =>
                                 (ev.Model as LMTimelineEvent).Teams.Contains(team.Model)
                });
                foreach (var player in team)
                {
                    playersPredicates.Add(new Predicate {
                        Name       = player.Model.Name,
                        Expression = ev =>
                                     (ev.Model as LMTimelineEvent).Players.Contains(player.Model)
                    });
                }
                teamPredicate.AddRange(playersPredicates);
                teamsPredicates.Add(teamPredicate);
            }
            ViewModel.TeamsPredicate.AddRange(teamsPredicates);
            ViewModel.Filters.IgnoreEvents = oldIgnoreEvents;
            if (!ViewModel.Filters.IgnoreEvents)
            {
                ViewModel.Filters.EmitPredicateChanged();
            }
        }
        private void OrButton_Clicked(object sender, EventArgs e)
        {
            OrPredicate   or    = new OrPredicate();
            TextPredicate child = this.getPendingChildPredicate();

            if (child != null)
            {
                or.AddChild(child);
                this.openPredicates.Add(or);
            }
            else
            {
                this.addChild(or);
            }
            this.updateLayout();
        }
Пример #22
0
        /// <summary>
        /// Parser for OrPredicate
        /// </summary>
        /// <returns>Parsed OrPredicate</returns>
        public OrPredicate ParseOrPredicate(Predicate parsedLeftPredicate)
        {
            OrPredicate orPredicate = new OrPredicate();

            //Add left predicate
            orPredicate.SetLeftPredicate(parsedLeftPredicate);

            //Skip || tokens
            NextToken("|", "predicate || predicate", '|');
            NextToken("|", "predicate || predicate", '|');

            //Parse right predicate
            orPredicate.SetRightPredicate(ParsePredicate());

            return(orPredicate);
        }
Пример #23
0
        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(""));
        }
Пример #24
0
        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
        }
Пример #26
0
        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(""));
        }
Пример #27
0
        public void SetActive_1LevelCompositePredicateActiveNotChanged_ActivePropertyChangedEittedOnce()
        {
            int count = 0;

            // Arrange
            var filter = new OrPredicate <string> {
                new Predicate <string> {
                    Expression = (ev) => true
                },
                new Predicate <string> {
                    Expression = (ev) => true
                },
            };

            filter.PropertyChanged += (sender, e) => count++;

            filter.Active = true;

            Assert.AreEqual(0, count);
        }
Пример #28
0
        public void TestOrEvents()
        {
            // Arrange
            string property = "";
            int    count    = 0;
            var    filter   = new OrPredicate <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);
        }
Пример #29
0
        public void ParseOrPredicateTest()
        {
            //Create parser
            PredicateParser predicateParser = new PredicateParser(Init("condition1 || condition2 || condition3"));
            Predicate       parsedPredicate = predicateParser.ParsePredicate();

            //Check Predicates
            Assert.AreEqual(typeof(OrPredicate), parsedPredicate.GetType());

            //Check OrPredicate
            OrPredicate parsedOrPredicate = (OrPredicate)parsedPredicate;

            Assert.AreEqual(typeof(ExpressionPredicate), parsedOrPredicate.GetLeftPredicate().GetType());
            Assert.AreEqual(typeof(OrPredicate), parsedOrPredicate.GetRightPredicate().GetType());

            //Check nested OrPredicate
            OrPredicate parsedNestedOrPredicate = (OrPredicate)parsedOrPredicate.GetRightPredicate();

            Assert.AreEqual(typeof(ExpressionPredicate), parsedNestedOrPredicate.GetLeftPredicate().GetType());
            Assert.AreEqual(typeof(ExpressionPredicate), parsedNestedOrPredicate.GetRightPredicate().GetType());
        }
Пример #30
0
        public void TestActiveEvents()
        {
            // Arrange
            string property  = "";
            int    count     = 0;
            var    filter    = new OrPredicate <string> ();
            var    predicate = new Predicate <string> {
                Expression = (ev) => true
            };

            filter.Add(predicate);
            filter.PropertyChanged += (sender, e) => {
                property = e.PropertyName;
                count++;
            };

            // Act
            predicate.Active = false;

            //Assert
            Assert.AreEqual("Active", property);
            Assert.AreEqual(1, count);
        }