Exemple #1
0
        public FilterRule(FilterRuleType type) : base()
        {
            Type = type;
            switch (type)
            {
            case FilterRuleType.Filter:
                RuleName = AppTools.GetReswLanguage("Tip_RuleFilter");
                break;

            case FilterRuleType.FilterOut:
                RuleName = AppTools.GetReswLanguage("Tip_RuleFilterOut");
                break;

            case FilterRuleType.TotalLimit:
                RuleName = AppTools.GetReswLanguage("Tip_TotalLimit");
                break;

            case FilterRuleType.SingleLimit:
                RuleName = AppTools.GetReswLanguage("Tip_SingleLimit");
                break;

            default:
                break;
            }
        }
        public void Evaluate_Always_ConsidersRulesInOrder(FilterSetResult expectedResult, FilterRuleType[] ruleTypes, bool[] states)
        {
            FilterRule<object>[] filterRules = new FilterRule<object>[ruleTypes.Length];
            for (int i = 0; i < ruleTypes.Length; i++)
                filterRules[i] = new FilterRule<object>(ruleTypes[i],
                    states[i] ? (Filter<object>)new AnyFilter<object>() : new NoneFilter<object>());

            FilterSet<object> filterSet = new FilterSet<object>(filterRules);
            Assert.AreEqual(expectedResult, filterSet.Evaluate(null));
        }
Exemple #3
0
        /// <summary>
        /// Creates a filter rule.
        /// </summary>
        /// <param name="ruleType">The rule type: inclusion or exclusion.</param>
        /// <param name="filter">The filter.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="filter"/> is null.</exception>
        public FilterRule(FilterRuleType ruleType, Filter <T> filter)
        {
            if (filter == null)
            {
                throw new ArgumentNullException("filter");
            }

            this.ruleType = ruleType;
            this.filter   = filter;
        }
Exemple #4
0
        public IRule CreateRule(FilterRuleType type)
        {
            switch (type)
            {
            case FilterRuleType.Regex:
                return(new RegexRule());

            case FilterRuleType.Simplified:
                return(new SimplifiedRule());

            default:
                throw new NotImplementedException($"Filter rule of type '{type}' is not yet implemented!");
            }
        }
        public void ToFilterSetExpr_Always_FormatsRulesInOrder(string expectedResult, FilterRuleType[] ruleTypes, bool[] states)
        {
            FilterRule<object>[] filterRules = new FilterRule<object>[ruleTypes.Length];
            for (int i = 0; i < ruleTypes.Length; i++)
                filterRules[i] = new FilterRule<object>(ruleTypes[i],
                    states[i] ? (Filter<object>)new AnyFilter<object>() : new NoneFilter<object>());

            FilterSet<object> filterSet = new FilterSet<object>(filterRules);
            Assert.AreEqual(expectedResult, filterSet.ToFilterSetExpr());
        }