public RuleRunnerTest() { IRule rule; rule = new BeginWithRule(); RulesPrototypes.Add(rule.TypeName, rule); rule = new EndWithRule(); RulesPrototypes.Add(rule.TypeName, rule); rule = new AndRule(); RulesPrototypes.Add(rule.TypeName, rule); }
public FeatureFlagState AndRule(FeatureFlagState p1, FeatureFlagState p2) { var or = new AndRule { Rules = new Rule[] { new ConstantRule { Value = p1 }, new ConstantRule { Value = p2 } } }; return(or.Evaluate(null)); }
public void IsValidIfAllRulesAreValid() { var r1 = new Mock<IRule<int>>(); var r2 = new Mock<IRule<int>>(); r1.Setup(r => r.IsValid(It.IsAny<int>())).Returns(true); r2.Setup(r => r.IsValid(It.IsAny<int>())).Returns(true); var combination = new AndRule<int>(new List<IRule<int>> { r1.Object, r2.Object }); var candidate = combination.IsValid(2); Assert.IsTrue(candidate); r1.Verify(r => r.IsValid(It.IsAny<int>()), Times.Once()); r2.Verify(r => r.IsValid(It.IsAny<int>()), Times.Once()); }
public void IsValidIfAllRulesAreValid() { var r1 = new Mock <IRule <int> >(); var r2 = new Mock <IRule <int> >(); r1.Setup(r => r.IsValid(It.IsAny <int>())).Returns(true); r2.Setup(r => r.IsValid(It.IsAny <int>())).Returns(true); var combination = new AndRule <int>(new List <IRule <int> > { r1.Object, r2.Object }); var candidate = combination.IsValid(2); Assert.IsTrue(candidate); r1.Verify(r => r.IsValid(It.IsAny <int>()), Times.Once()); r2.Verify(r => r.IsValid(It.IsAny <int>()), Times.Once()); }
protected override string DescribeAndRule(AndRule <T> rule) { var leftDescription = Describe(rule.Left); if (NeedsParenthesis(rule, rule.Left)) { leftDescription = string.Format("({0})", leftDescription); } var rightDescription = Describe(rule.Right); if (NeedsParenthesis(rule, rule.Right)) { rightDescription = string.Format("({0})", rightDescription); } return(string.Format("{0} AND {1}", leftDescription, rightDescription)); }
public void NotValidIfARuleFails() { var msg = "r2 message"; var r1 = new Mock<IRule<int>>(); var r2 = new Mock<IRule<int>>(); var r3 = new Mock<IRule<int>>(); r1.Setup(r => r.IsValid(It.IsAny<int>())).Returns(true); r2.Setup(r => r.IsValid(It.IsAny<int>())).Returns(false); r2.Setup(r => r.Message).Returns(msg); r3.Setup(r => r.IsValid(It.IsAny<int>())).Returns(true); var combination = new AndRule<int>(new List<IRule<int>> { r1.Object, r2.Object, r3.Object }); var candidate = combination.IsValid(2); Assert.IsFalse(candidate); Assert.AreEqual(msg + Environment.NewLine, combination.Message); r1.Verify(r => r.IsValid(It.IsAny<int>()), Times.Once()); r2.Verify(r => r.IsValid(It.IsAny<int>()), Times.Once()); r3.Verify(r => r.IsValid(It.IsAny<int>()), Times.Once()); }
protected override string DescribeAndRule(AndRule <T> rule) { var result = DescribeResult(rule.IsTrueFor(evaluateWith)); var leftDescription = Describe(rule.Left); if (NeedsParenthesis(rule, rule.Left)) { leftDescription = string.Format("({0})", leftDescription); } var rightDescription = Describe(rule.Right); if (NeedsParenthesis(rule, rule.Right)) { rightDescription = string.Format("({0})", rightDescription); } return(string.Format("{0} AND[{2}] {1}", leftDescription, rightDescription, result)); }
static IRule CompileNodeForRule(string ruletext, Dictionary <int, RuleCacheItem> ruleSet) { Function Head, BuildingRule; Head = BuildingRule = new AndRule(); foreach (var item in ruletext.Split(' ')) { if (item.Contains("\"")) { var nodeToAdd = new StringRule { toMatch = item[1] };; //Comment this line for multi string rule support return(nodeToAdd); BuildingRule.AddNode(nodeToAdd); } else if (item.Contains("|")) { //Split on left and right Head = new OrRule(); Head.AddNode(BuildingRule); BuildingRule = new AndRule(); Head.AddNode(BuildingRule); } else { var childToExplore = int.Parse(item); //Check if the cached copy hasn't compiled yet and compile it if (ruleSet[childToExplore].CachedRule == null) { ruleSet[childToExplore].CachedRule = CompileNodeForRule(ruleSet[childToExplore].Text, ruleSet); } BuildingRule.AddNode(ruleSet[childToExplore].CachedRule); } } return(Head); }
public void NotValidIfARuleFails() { var msg = "r2 message"; var r1 = new Mock <IRule <int> >(); var r2 = new Mock <IRule <int> >(); var r3 = new Mock <IRule <int> >(); r1.Setup(r => r.IsValid(It.IsAny <int>())).Returns(true); r2.Setup(r => r.IsValid(It.IsAny <int>())).Returns(false); r2.Setup(r => r.Message).Returns(msg); r3.Setup(r => r.IsValid(It.IsAny <int>())).Returns(true); var combination = new AndRule <int>(new List <IRule <int> > { r1.Object, r2.Object, r3.Object }); var candidate = combination.IsValid(2); Assert.IsFalse(candidate); Assert.AreEqual(msg + Environment.NewLine, combination.Message); r1.Verify(r => r.IsValid(It.IsAny <int>()), Times.Once()); r2.Verify(r => r.IsValid(It.IsAny <int>()), Times.Once()); r3.Verify(r => r.IsValid(It.IsAny <int>()), Times.Once()); }
static void Main(string[] args) { var r1 = new EqualRule(); r1.AttributeName = "a1"; r1.TargetValue.Add("test1"); var r2 = new EqualRule(); r2.AttributeName = "b2"; r2.TargetValue.Add("test2"); r2.TargetValue.Add("test2bis"); var r3 = new EqualRule(); r3.AttributeName = "c3"; r3.TargetValue.Add("test3"); var r4 = new NotEqualRule(); r4.AttributeName = "c4"; r4.TargetValue.Add("test4"); var r5 = new EqualRule(); r5.AttributeName = "or5"; r5.TargetValue.Add("test5"); var r6 = new EqualRule(); r6.AttributeName = "or6"; r6.TargetValue.Add("test6"); var orRule = new OrRule(); orRule.ChildRules.Add(r5); orRule.ChildRules.Add(r6); var andRule = new AndRule(); andRule.ChildRules.Add(r1); andRule.ChildRules.Add(r2); andRule.ChildRules.Add(r3); andRule.ChildRules.Add(r4); andRule.ChildRules.Add(orRule); var rc = new RuleContainer(); rc.MetadataInputs.Add(new MetadataEntity() { AttributeName = "a1", AttributeType = typeof(string) }); rc.MetadataInputs.Add(new MetadataEntity() { AttributeName = "b2", AttributeType = typeof(string) }); rc.MetadataInputs.Add(new MetadataEntity() { AttributeName = "c3", AttributeType = typeof(string) }); rc.MetadataInputs.Add(new MetadataEntity() { AttributeName = "c4", AttributeType = typeof(string) }); rc.MetadataInputs.Add(new MetadataEntity() { AttributeName = "or5", AttributeType = typeof(string) }); rc.MetadataInputs.Add(new MetadataEntity() { AttributeName = "or6", AttributeType = typeof(string) }); rc.Rules.Add(andRule); rc.ReturnValue = "false"; rc.CompileExpression(); var res1 = rc.CompiledFunction(new string[] { "test1", "test2", "test3", "test4444", "test5fdsfsd", "test6" }); }
static void Main(string[] args) { Dictionary <int, RuleCacheItem> ruleParse = new Dictionary <int, RuleCacheItem>(); List <string> toCheck = new List <string>(); foreach (var line in System.IO.File.ReadLines("puzzleinput.txt")) { if (line.Contains(':')) { var c = line.Split(':'); ruleParse.Add(int.Parse(c[0]), new RuleCacheItem { Text = c[1].Substring(1) }); } else if (!string.IsNullOrEmpty(line)) { toCheck.Add(line); } } //build tree var currentNode = ruleParse[0]; currentNode.CachedRule = CompileNodeForRule(currentNode.Text, ruleParse); int SuccessCount = toCheck.Count(line => currentNode.CachedRule.Match(0, line, 100).Any(t => t == line.Length)); Console.WriteLine($"Part 1: {SuccessCount}"); //Disgusting hack to replace nodes 8 and 11: var oldEight = ruleParse[8].CachedRule; //Update rule 8 ruleParse[8].CachedRule = new OrRule(); //LHS var lhs = new AndRule(); lhs.AddNode(ruleParse[42].CachedRule); //RHS var rhs = new AndRule(); rhs.AddNode(ruleParse[42].CachedRule); rhs.AddNode(ruleParse[8].CachedRule); ((Function)ruleParse[8].CachedRule).AddNode(lhs); ((Function)ruleParse[8].CachedRule).AddNode(rhs); //Update rule 11 var oldEleven = ruleParse[11].CachedRule; ruleParse[11].CachedRule = new OrRule(); //LHS lhs = new AndRule(); lhs.AddNode(ruleParse[42].CachedRule); lhs.AddNode(ruleParse[31].CachedRule); //RHS rhs = new AndRule(); rhs.AddNode(ruleParse[42].CachedRule); rhs.AddNode(ruleParse[11].CachedRule); rhs.AddNode(ruleParse[31].CachedRule); ((Function)ruleParse[11].CachedRule).AddNode(lhs); ((Function)ruleParse[11].CachedRule).AddNode(rhs); //Replace the old 8's and 11's with the new ones foreach (var node in ruleParse.Values) { if (typeof(Function).IsAssignableFrom(node.CachedRule.GetType())) { ((Function)node.CachedRule).ReplaceNode(oldEight, ruleParse[8].CachedRule); ((Function)node.CachedRule).ReplaceNode(oldEleven, ruleParse[11].CachedRule); } } SuccessCount = toCheck.Count(line => currentNode.CachedRule.Match(0, line, 100).Any(t => t == line.Length)); Console.WriteLine($"Part 2: {SuccessCount}"); Console.ReadLine(); }
private Rule Interpret(Grammar grammar, ISemanticNode node) { Rule rule = null; if (node is BranchSemanticNode branch) { switch ((EbnfNodeType)branch.NodeType) { case EbnfNodeType.Group: rule = Interpret(grammar, branch.Children[0]); break; case EbnfNodeType.Repeat: rule = new RepeatRule(grammar, Interpret(grammar, branch.Children[0])); break; case EbnfNodeType.Optional: rule = new OptionalRule(grammar, Interpret(grammar, branch.Children[0])); break; case EbnfNodeType.Not: rule = new NotRule(grammar, Interpret(grammar, branch.Children[0])); break; case EbnfNodeType.And: rule = new AndRule(grammar, branch.Children.Select(child => Interpret(grammar, child))); break; case EbnfNodeType.Or: rule = new OrRule(grammar, branch.Children.Select(child => Interpret(grammar, child))); break; case EbnfNodeType.None: rule = Interpret(grammar, branch.Children.Single()); break; case EbnfNodeType.Root: case EbnfNodeType.Rule: case EbnfNodeType.Token: default: throw new Exception(); } } else if (node is LeafSemanticNode leaf) { switch ((EbnfNodeType)leaf.NodeType) { case EbnfNodeType.Identifier: rule = grammar.ReferenceRule(leaf.Value); break; case EbnfNodeType.String: case EbnfNodeType.Regex: break; default: throw new Exception(); } } if (rule == null) { throw new Exception(); } else { return(rule); } }
public virtual void Visit(AndRule visitee) => Visit((CompositeRule)visitee);
protected abstract string DescribeAndRule(AndRule <T> rule);
protected override string DescribeAndRule(AndRule <T> rule) { var result = DescribeResult(rule.IsTrueFor(evaluateWith)); return(string.Format("({0} AND {1})[{2}]", Describe(rule.Left), Describe(rule.Right), result)); }
protected override string DescribeAndRule(AndRule <T> rule) { return(string.Format("({0} AND {1})", Describe(rule.Left), Describe(rule.Right))); }