public void RuleSetReportingSizeCheckMultiTop() { RuleMSX rmsx = new RuleMSX(); string newRuleSetName = "TestRuleSet"; RuleSet rs = rmsx.createRuleSet(newRuleSetName); rs.AddRule(new Rule("TestRule1", new GenericBoolRule(true), rmsx.createAction("TestAction1", new GenericAction("TestAction1")))); Rule r2 = new Rule("TestRule2", new GenericBoolRule(false), rmsx.createAction("TestAction4", new GenericAction("TestAction4"))); rs.AddRule(r2); r2.AddRule(new Rule("TestRule5", new GenericBoolRule(true), rmsx.createAction("TestAction3", new GenericAction("TestAction3")))); r2.AddRule(new Rule("TestRule6", new GenericBoolRule(false), rmsx.createAction("TestAction5", new GenericAction("TestAction5")))); rs.AddRule(new Rule("TestRule3", new GenericBoolRule(false))); Rule r4 = new Rule("TestRule4", new GenericBoolRule(true), rmsx.createAction("TestAction2", new GenericAction("TestAction2"))); rs.AddRule(r4); r4.AddRule(new Rule("TestRule7", new GenericBoolRule(false), rmsx.createAction("TestAction6", new GenericAction("TestAction6")))); r4.AddRule(new Rule("TestRule8", new GenericBoolRule(true), rmsx.createAction("TestAction7", new GenericAction("TestAction7")))); string report = rs.report(); System.Console.WriteLine(report); Assert.That(report.Length, Is.EqualTo(664)); }
void Start() { vector = new Vector(); savedVectors = new List <Vector>(); allRules = new List <RuleSet>(); axiom = Rule.GetRulesFromString("I"); sizeLine = Random.Range(2f, 7.5f); widthLine = Random.Range(sizeLine / 2, sizeLine * 2); angle = Random.Range(40f, 80f); widthScaleFactor = Random.Range(0.9f, 0.98f); rules = new RuleSet(); rules.AddRule('I', "FS"); rules.AddRule('S', "[[F-F+&SF*]F&[^F+F-FS]]"); allRules.Add(rules); rules = new RuleSet(); rules.AddRule('I', "FFS"); rules.AddRule('S', "F[+F&-F+F-F^F*][-^&F+[F-F^F&+^F*]*]"); allRules.Add(rules); foreach (Rule r in axiom) { r.Run(this); } }
// Use this for initialization void Start() { List <Variable> vars = new List <Variable>(); vars.Add(new Variable('S', branchTime)); vars.Add(new Variable('X', branchTime)); vars.Add(new Variable('F', maxStemAge)); RuleSet rules = new RuleSet(); Symbol maxSSym = new Symbol('S', branchTime); Symbol maxXSym = new Symbol('X', branchTime); rules.AddRule(maxSSym, 0.3f, new SymbolString("[@[@/@/@+@FAXA]@\\@+@FAXA]@\\@-@FAXA")); rules.AddRule(maxSSym, 0.3f, new SymbolString("[@\\@+@FAXA]@\\@-@FAXA")); rules.AddRule(maxSSym, 0.2f, new SymbolString("FAXA")); rules.AddRule(maxXSym, 0.16f, new SymbolString("[@[@\\@\\@+@FAXA]@/@+@FAXA]@/@-@FAXA")); rules.AddRule(maxXSym, 0.16f, new SymbolString("[@[@/@/@+@FAXA]@\\@+@FAXA]@\\@-@FAXA")); rules.AddRule(maxXSym, 0.32f, new SymbolString("[@\\@+@FAXA]@\\@-@FAXA")); rules.AddRule(maxXSym, 0.32f, new SymbolString("[@/@+@FAXA]@/@-@FAXA")); rules.AddRule(maxXSym, 0.03f, new SymbolString("\\@-@FAXA")); rules.AddRule(maxXSym, 0.03f, new SymbolString("/@-@FAXA")); this.lSystem = new LSystem(vars, new Symbol('S', 10), rules, yaw, pitch, roll, numIterations); if (root == null) { root = Instantiate <Stem>(stemPrefab, transform.position, transform.rotation); root.age = 1; } }
//TESTING/DEMO ONLY!!! public string FireMergeEngine() { var readyToMerge = S3Interface.GetReadyToMerge(); foreach (var m in readyToMerge) { var ccdList = S3Interface.GetMergeSetCcds(Guid.Parse(m)).Select(x => XDocument.Parse(x)).ToList(); var sRuleSet = S3Interface.GetMergeSetRules(Guid.Parse(m)); RuleSet ruleSet; if (!sRuleSet.Contains("{\"UseDefault\": \"true\"}")) { ruleSet = new RuleSet(sRuleSet); } else { ruleSet = new RuleSet(); ruleSet.AddRule("StripText", 0, RuleType.PreFormat); ruleSet.AddRule("PrimaryMergeRuleWithValidation", 0, RuleType.Primary); ruleSet.AddRule("MedicationRule1", 0, RuleType.DeDuplication); ruleSet.AddRule("AlertsSection", 0, RuleType.DeDuplication); ruleSet.AddRule("SocialHistory_EtohUser", 0, RuleType.DeDuplication); ruleSet.AddRule("SocialHistory_SmokingConsolidation", 0, RuleType.DeDuplication); ruleSet.AddRule("TestProblemsDedup", 0, RuleType.DeDuplication); ruleSet.AddRule("AddFormatedText", 0, RuleType.PostFormat); } S3Interface.AddMergedZip(Guid.Parse(m), RunMerge.runMergeWithRuleSet(ccdList, ruleSet, Guid.Parse(m), "")); } return(string.Empty); }
public void ShouldForwardChainRules() { var ruleBase = new RuleBase<Target>(); var ruleSet = new RuleSet<Target>(); var rule = new Rule<Target>("rule 1", "description of rule 1", t => t.Number == 0, t => t.Number = 1); var rule2 = new Rule<Target>("rule 2", "", t => t.Number == 1, t => t.Number = 2); ruleSet.AddRule(rule); ruleSet.AddRule(rule2); ruleBase.AddRuleSet(ruleSet); var target = new Target(); var ruleEngine = new RuleEngine<Target>(ruleBase); ruleEngine.Execute(target); Assert.Equal(2, target.Number); }
private void BuildRules() { log("Building rules..."); log("Creating RuleSet rsAutoRouteFromIOI"); RuleSet rsAutoRouteFromIOI = this.rmsx.CreateRuleSet("AutoRouteFromIOI"); log("Creating rule for ValidIOI"); Rule ruleValidIOI = rsAutoRouteFromIOI.AddRule("ValidIOI"); /* ioi must be instrument type 'stock' * ioi must not be expired */ ruleValidIOI.AddRuleCondition(new RuleCondition("IsStockInstrumentType", new GenericStringMatch("ioitype", "stock"))); ruleValidIOI.AddRuleCondition(new RuleCondition("IsNotExpired", new IsIOINotExpired())); ruleValidIOI.AddAction(this.rmsx.CreateAction("MarkIOIValid", ActionType.ON_TRUE, new MarkIOIValid())); Action purgeDataSet = this.rmsx.CreateAction("PurgeDataSet", ActionType.ON_FALSE, new PurgeDataSet(rsAutoRouteFromIOI)); ruleValidIOI.AddAction(purgeDataSet); log("Creating rule for ValidOrder"); Rule ruleValidOrder = rsAutoRouteFromIOI.AddRule("ValidOrder"); /* Order must be for Equity */ ruleValidOrder.AddRuleCondition(new RuleCondition("IsEquity", new GenericStringMatch("orderAssetClass", "Equity"))); ruleValidOrder.AddAction(this.rmsx.CreateAction("MarkOrderValid", ActionType.ON_TRUE, new MarkOrderValid())); ruleValidOrder.AddAction(purgeDataSet); log("Creating rule for ValidPair"); Rule ruleValidPair = rsAutoRouteFromIOI.AddRule("ValidPair"); /* both order and ioi must be valid * matching side */ ruleValidPair.AddRuleCondition(new RuleCondition("IOIAndOrderReady", new IOIAndOrderReady())); ruleValidPair.AddRuleCondition(new RuleCondition("MatchingTicker", new MatchingTicker())); ruleValidPair.AddRuleCondition(new RuleCondition("MatchingSide", new MatchingSideAndAmount())); /* Create new route */ ruleValidPair.AddAction(this.rmsx.CreateAction("CreateRoute", ActionType.ON_TRUE, new CreateRoute(this))); ruleValidOrder.AddAction(purgeDataSet); }
public void RuleSet(params RuleExpression <TTarget>[] ruleExpressions) { var ruleSet = new RuleSet <TTarget>(); ruleExpressions.ToList().ForEach(ruleExpression => ruleSet.AddRule(ruleExpression)); _ruleBaseExpression.AddRuleSet(ruleSet); }
public void SingleRuleITest() { Log.logLevel = Log.LogLevels.DETAILED; RuleMSX rmsx = new RuleMSX(); string newRuleSetName = "SingleIterationRuleSet"; string newDataSetName = "SingleIterationDataSet"; string newRuleName = "IsBooleanTrue"; string actionMessage = "ActionMessage"; RuleSet rs = rmsx.createRuleSet(newRuleSetName); DataSet ds = rmsx.createDataSet(newDataSetName); RuleAction rai = rmsx.createAction("RuleActionIn", new GenericAction(actionMessage)); Rule r = new Rule(newRuleName, new GenericBoolRule(true), rai); rs.AddRule(r); ds.addDataPoint("TestDataPoint", new StringDataPoint("test_data_point")); rs.Execute(ds); // We have to wait for the action to take place. Under normal circumstances there // would be no interation with the data from outside the evaluators/actions. System.Threading.Thread.Sleep(100); GenericAction rao = (GenericAction)rai.getExecutor(); Assert.That(rao.getOutgoing(), Is.EqualTo(actionMessage)); }
private void BuildRules() { log("Building rules..."); log("Creating RuleCondition condRouteFillOccurred"); RuleCondition condRouteFillOccurred = new RuleCondition("RouteFillOccurred", new RouteFillOccurred(this)); log("RuleCondition condRouteFillOccurred created."); log("Creating Action actShowRouteFill"); Action actShowRouteFill = this.rmsx.CreateAction("ShowRouteFill", new ShowRouteFill(this)); log("Action actShowRouteFill created"); log("Creating RuleSet demoRouteRuleSet"); RuleSet demoRouteRuleSet = this.rmsx.CreateRuleSet("DemoRouteRuleSet"); log("RuleSet demoRouteRuleSet created"); log("Creating Rule ruleRouteFilled"); Rule ruleRouteFilled = demoRouteRuleSet.AddRule("RouteFilled"); log("Rule ruleRouteFilled created"); log("Assign RuleCondition condRouteFillOccurred to Rule ruleRouteFilled"); ruleRouteFilled.AddRuleCondition(condRouteFillOccurred); log("Assign Action actShowRouteFill to Rule ruleRouteFilled"); ruleRouteFilled.AddAction(actShowRouteFill); log("Rules built."); }
private static void AddDefaultRuleSet(List <RuleExpression <TTarget> > ruleExpressions, RuleBase <TTarget> ruleBase) { var defaultRuleSet = new RuleSet <TTarget>(); ruleExpressions.ForEach(ruleBuilder => defaultRuleSet.AddRule(ruleBuilder)); ruleBase.AddRuleSet(defaultRuleSet); }
public void ShouldForwardChainRules() { var ruleBase = new RuleBase <Target>(); var ruleSet = new RuleSet <Target>(); var rule = new Rule <Target>("rule 1", "description of rule 1", t => t.Number == 0, t => t.Number = 1); var rule2 = new Rule <Target>("rule 2", "", t => t.Number == 1, t => t.Number = 2); ruleSet.AddRule(rule); ruleSet.AddRule(rule2); ruleBase.AddRuleSet(ruleSet); var target = new Target(); var ruleEngine = new RuleEngine <Target>(ruleBase); ruleEngine.Execute(target); Assert.Equal(2, target.Number); }
private void AddRulesToRuleSet(List <RuleExpression <T> > ruleExpressions) { var ruleSet = new RuleSet <T>(); ruleExpressions.ForEach(ruleExpression => ruleSet.AddRule(ruleExpression)); AddRuleSet(ruleSet); }
public void RuleSetAddRuleGetRuleShouldReturnNewRule() { RuleMSX rmsx = new RuleMSX(); string newRuleSetName = "NewRuleSet"; string newRuleName = "Rule1"; RuleSet rs = rmsx.CreateRuleSet(newRuleSetName); rs.AddRule(newRuleName); Assert.That(rs.GetRule(newRuleName).GetName(), Is.EqualTo(newRuleName)); }
public static RuleSet GetDefaultRuleset() { var retVal = new RuleSet(); retVal.AddRule("StripText", 0, RuleType.PreFormat); retVal.AddRule("PrimaryMergeRuleWithValidation", 0, RuleType.Primary); retVal.AddRule("Author", 0, RuleType.DeDuplication); retVal.AddRule("Confidentiality", 0, RuleType.DeDuplication); retVal.AddRule("MedicationRule1", 0, RuleType.DeDuplication); retVal.AddRule("SocialHisotry_EtohUse", 0, RuleType.DeDuplication); retVal.AddRule("SocialHistory_SmokingConsolidation", 0, RuleType.DeDuplication); retVal.AddRule("TestProblemsDedup", 0, RuleType.DeDuplication); retVal.AddRule("AddFormatedText", 0, RuleType.PostFormat); return(retVal); }
public void TestInitialize() { _ruleset = new RuleSet(); Tuple <char, int>[] itemCountPairList = new Tuple <char, int>[] { new Tuple <char, int>('C', 1), new Tuple <char, int>('D', 1) }; _ruleset.AddRule(new PromoRule(itemCountPairList, 30)); _ruleset.AddRule(new PromoRule('A', 3, 130)); _ruleset.AddRule(new PromoRule('B', 2, 45)); _itemPricePair = new Dictionary <char, int>() { { 'A', 50 }, { 'B', 30 }, { 'C', 20 }, { 'D', 15 } }; }
public void GetRulesReturnsCorrectListOfRules() { RuleMSX rmsx = new RuleMSX(); string newRuleSetName = "NewRuleSet"; string newRuleName = "NewRuleName"; RuleSet rs = rmsx.CreateRuleSet(newRuleSetName); Rule ri = rs.AddRule(newRuleName); List <Rule> rl = rs.GetRules(); Rule ro = rl[0]; Assert.That(ro.GetName(), Is.EqualTo(newRuleName)); }
static void De_Duplicate() { //Create a ccd list of XDocuments Stopwatch sw = new Stopwatch(); RuleSet ruleSet; ruleSet = new RuleSet(); // ruleSet.AddRule("StripText", 0, RuleType.PreFormat); ruleSet.AddRule("PrimaryMergeRuleWithValidation", 0, RuleType.Primary); ruleSet.AddRule("Author", 0, RuleType.DeDuplication); ruleSet.AddRule("Confidentiality", 0, RuleType.DeDuplication); ruleSet.AddRule("MedicationRule1", 0, RuleType.DeDuplication); ruleSet.AddRule("AlertsSection", 0, RuleType.DeDuplication); //ruleSet.AddRule("SocialHistory_DailyCaffeine", 0, RuleType.DeDuplication); //ruleSet.AddRule("SocialHistory_EtohUser", 0, RuleType.DeDuplication); //ruleSet.AddRule("SocialHistory_SmokingConsolidation", 0, RuleType.DeDuplication); ruleSet.AddRule("VitalSigns", 0, RuleType.DeDuplication); ruleSet.AddRule("TestProblemsDedup", 0, RuleType.DeDuplication); // ruleSet.AddRule("AddFormatedText", 0, RuleType.PostFormat); string guid = "{3F2504E0-4F89-41D3-9A0C-0305E82C3301}"; foreach (string folder in Directory.GetDirectories(folderPath)) { string fileName = Path.GetFileName(folder); var ccdList = new List <XDocument>(); foreach (string file in Directory.GetFiles(folder)) { ccdList.Add(XDocument.Load(file)); } sw.Start(); Stream ms = RunMerge.runMergeWithRuleSet(ccdList, ruleSet, Guid.Parse(guid), fileName); sw.Stop(); } Console.WriteLine("------------------ Consolidation is done! --------------------------"); Console.WriteLine("CountDedup.txt", "Vital Count: " + DeDupRule.vitalDedupCount); Console.WriteLine("Problem Count: " + DeDupRule.problemsDedupCount); Console.WriteLine("Alert Count: " + DeDupRule.alertDedupCount); Console.WriteLine("Medication Count: " + DeDupRule.medicationDedupCount); Console.WriteLine("Confidentiality Count: " + DeDupRule.confidentialityDedupCount); Console.WriteLine("Author Count: " + DeDupRule.authorDedupCount); Console.WriteLine("Overall deduplication time: " + sw.Elapsed); Console.ReadKey(); }
public void RuleSet_Simple() { RuleSet <bool> rs = new RuleSet <bool>(TestSetup.BoolRegistrySimple); rs.AddRule(RuleNames.R001); //True rs.AddRule(RuleNames.R002); //False rs.AddRule(RuleNames.R003); //True rs.AddRule(RuleNames.R004); //False rs.AddRule(RuleNames.R005); //True rs.AddRule(RuleNames.R006); //False var results = rs.Execute(); IRuleResult <bool> result; result = results[RuleNames.R001]; Assert.IsTrue(result.Result); result = results[RuleNames.R002]; Assert.IsFalse(result.Result); result = results[RuleNames.R003]; Assert.IsTrue(result.Result); result = results[RuleNames.R004]; Assert.IsFalse(result.Result); result = results[RuleNames.R005]; Assert.IsTrue(result.Result); result = results[RuleNames.R006]; Assert.IsFalse(result.Result); }
private void BuildRules() { log("Building rules..."); log("Creating RuleSet rsOrderStates"); RuleSet rsOrderStates = this.rmsx.CreateRuleSet("OrderStates"); log("Creating rule for ORDER_NEW"); Rule ruleOrderNew = rsOrderStates.AddRule("OrderNew"); ruleOrderNew.AddRuleCondition(new RuleCondition("OrderNew", new OrderNew())); ruleOrderNew.AddAction(this.rmsx.CreateAction("ShowOrderNew", new ShowOrderState(this, "New Order"))); }
public void RuleGetEvaluatorReturnsCorrectEvaluator() { RuleMSX rmsx = new RuleMSX(); string newRuleSetName = "NewRuleSet"; string newDataSetName = "NewDataSet"; string newRuleName = "Rule1"; RuleSet rs = rmsx.createRuleSet(newRuleSetName); Rule r = new Rule(newRuleName, new GenericBoolRule(true)); DataSet ds = rmsx.createDataSet(newDataSetName); rs.AddRule(r); Assert.That(r.GetEvaluator().Evaluate(ds), Is.EqualTo(true)); }
public void RuleMSXStopShouldReturnTrueWithActiveRuleSet() { RuleMSX rmsx = new RuleMSX(); string newRuleSetName = "NewRuleSet"; string newDataSetName = "NewDataSet"; string newRuleName = "Rule1"; RuleSet rs = rmsx.createRuleSet(newRuleSetName); Rule r = new Rule(newRuleName, new GenericBoolRule(true)); DataSet ds = rmsx.createDataSet(newDataSetName); rs.AddRule(r); rs.Execute(ds); Assert.That(rmsx.Stop(), Is.EqualTo(true)); }
public void RuleMSXStopShouldReturnTrueWithUnexecutedRuleSet() { RuleMSX rmsx = new RuleMSX(); string newRuleSetName = "NewRuleSet"; string newDataSetName = "NewDataSet"; string newRuleName = "Rule1"; RuleSet rs = rmsx.createRuleSet(newRuleSetName); Rule r = new Rule(newRuleName, new GenericBoolRule(true)); DataSet ds = rmsx.createDataSet(newDataSetName); rs.AddRule(r); // We are deliberately not executing the ruleset... //rs.Execute(ds); Assert.That(rmsx.Stop(), Is.EqualTo(true)); }
public void ShouldExecuteRuleEngineOnSeveralTargets() { var ruleBase = new RuleBase<Target>(); var ruleSet = new RuleSet<Target>(); var rule = new Rule<Target>("rule 1", "", t => t.Number == 0, t => t.Number = 1); ruleSet.AddRule(rule); ruleBase.AddRuleSet(ruleSet); var ruleEngine = new RuleEngine<Target>(ruleBase); var target = new Target(); ruleEngine.Execute(target); Assert.Equal(1, target.Number); var newTarget = new Target(); ruleEngine.Execute(newTarget); Assert.Equal(1, newTarget.Number); }
public void ShouldExecuteRuleEngineOnSeveralTargets() { var ruleBase = new RuleBase <Target>(); var ruleSet = new RuleSet <Target>(); var rule = new Rule <Target>("rule 1", "", t => t.Number == 0, t => t.Number = 1); ruleSet.AddRule(rule); ruleBase.AddRuleSet(ruleSet); var ruleEngine = new RuleEngine <Target>(ruleBase); var target = new Target(); ruleEngine.Execute(target); Assert.Equal(1, target.Number); var newTarget = new Target(); ruleEngine.Execute(newTarget); Assert.Equal(1, newTarget.Number); }
public void AddRuleRangeTest() { RuleSet rules = RuleSet.FromDirectory(Path.Combine("rules", "valid"), null); // Add Range RuleSet testRules = new RuleSet(); testRules.AddRange(rules.ByLanguages(new string[] { "javascript" })); Assert.IsTrue(testRules.Count() > 0, "AddRange testRules is empty"); // Add Rule testRules = new RuleSet(); IEnumerable <Rule> list = rules.ByLanguages(new string[] { "javascript" }); foreach (Rule r in list) { testRules.AddRule(r); } Assert.IsTrue(testRules.Count() > 0, "AddRule testRules is empty"); }
public void RuleSetReportingSizeCheckSingleRule() { RuleMSX rmsx = new RuleMSX(); string newRuleSetName = "TestRuleSet"; string newDataSetName = "TestDataSet"; string newRuleName = "IsBooleanTrue"; RuleSet rs = rmsx.createRuleSet(newRuleSetName); DataSet ds = rmsx.createDataSet(newDataSetName); Rule r = new Rule(newRuleName, new GenericBoolRule(true)); rs.AddRule(r); string report = rs.report(); System.Console.WriteLine(report); Assert.That(report.Length, Is.EqualTo(126)); }
public void RuleAddActionGetActionReturnsCorrectAction() { RuleMSX rmsx = new RuleMSX(); string newRuleSetName = "NewRuleSet"; string newDataSetName = "NewDataSet"; string newRuleName = "Rule1"; string actionMessage = "ActionMessage"; RuleSet rs = rmsx.createRuleSet(newRuleSetName); DataSet ds = rmsx.createDataSet(newDataSetName); Rule r = new Rule(newRuleName, new GenericBoolRule(true)); rs.AddRule(r); RuleAction rai = rmsx.createAction("RuleActionIn", new GenericAction(actionMessage)); r.AddAction(rai); ActionExecutor rae = r.GetActions()[0].getExecutor(); rae.Execute(ds); GenericAction ga = (GenericAction)rae; Assert.That(ga.getOutgoing, Is.EqualTo(actionMessage)); }
public void IsValid_WhenARuleSetIsValid_ShouldReturnTrue() { string name = _fixture.Create <string>(); string description = _fixture.Create <string>(); string version = _fixture.Create <string>(); RuleSet ruleSet = new RuleSet(name, description, version); string code = _fixture.Create <string>(); string message = _fixture.Create <string>(); Rule rule = new Rule(code, message); string leftPredicate = _fixture.Create <string>(); OperatorType operatorType = OperatorType.Equal; string rightPredicate = _fixture.Create <string>(); RuleItem ruleItem = new ConstantRuleItem(leftPredicate, operatorType, rightPredicate); rule.AddRuleItem(ruleItem); ruleSet.AddRule(rule); ruleSet.IsValid().Should().BeTrue(); }
//converts from genomes to _rulesets public void DecodeGenomes() { for (int i = 0; i < _childCount; i++) { var temp = _gaAxioms.Population._genomes[i]._genome[0]; string evolvedAxiom = _gaAxioms.Encoder.Decode(temp); //issue here because the rule keys aren't attached to their rules so the order matters when passing/reversing //so all systems currently need to have fghi defined in that order string ruleNames = "FGHI"; RuleSet rsTemp = new RuleSet("Fractal", evolvedAxiom, ruleNames, 90f); for (int j = 0; j < _gaRules.Population._genomes[i]._genome.Length; j++) { var tempGenome = _gaRules.Population._genomes[i]._genome[j]; string specimen = _gaRules.Encoder.Decode(tempGenome); rsTemp.AddRule(ruleNames[j].ToString(), specimen); } rsTemp.Validate(); _rulesets[i] = rsTemp; } }
public IRuleBasedDataGeneratorConfigurator AddRule(IRule rule) { _ruleSet.AddRule(rule); return(this); }
public void RuleSet_Object() { RuleSet <bool> rs = new RuleSet <bool>(TestSetup.BoolRegistryObject); rs.AddRule(RuleNames.R001); //Negative Rule rs.AddRule(RuleNames.R002); //Even Rule rs.AddRule(RuleNames.R003); //Negative Rule rs.AddRule(RuleNames.R004); //NonNegative Rule rs.AddRule(RuleNames.R005); //Even Rule rs.AddRule(RuleNames.R006); //Odd Rule rs.AddRule(RuleNames.R007); //True Rule List <TestObject> validationList = new List <TestObject>(); TestObject obj1 = new TestObject() { IntegerProperty = -1 //Negative, Odd }; TestObject obj2 = new TestObject() { IntegerProperty = 2 //NonNegative, Even }; validationList.Add(obj1); validationList.Add(obj2); var validationMap = new Dictionary <TestObject, Dictionary <string, IRuleResult <bool> > >(); validationList.ForEach((obj) => { var results = rs.Execute((rule) => { //cast IRule to specific rule instance and perform setup before rule execution var genericRule = rule as Rule <TestObject, bool>; if (genericRule != null) { genericRule.Object = obj; } var codedRule = rule as TestObjectRuleBase; if (codedRule != null) { codedRule.ObjectInstance = obj; } }); validationMap.Add(obj, results); }); IRuleResult <bool> result; //obj1 result = validationMap[obj1][RuleNames.R001]; Assert.IsTrue(result.Result); result = validationMap[obj1][RuleNames.R002]; Assert.IsFalse(result.Result); result = validationMap[obj1][RuleNames.R003]; Assert.IsTrue(result.Result); result = validationMap[obj1][RuleNames.R004]; Assert.IsFalse(result.Result); result = validationMap[obj1][RuleNames.R005]; Assert.IsFalse(result.Result); result = validationMap[obj1][RuleNames.R006]; Assert.IsTrue(result.Result); result = validationMap[obj1][RuleNames.R007]; Assert.IsTrue(result.Result); //obj2 result = validationMap[obj2][RuleNames.R001]; Assert.IsFalse(result.Result); result = validationMap[obj2][RuleNames.R002]; Assert.IsTrue(result.Result); result = validationMap[obj2][RuleNames.R003]; Assert.IsFalse(result.Result); result = validationMap[obj2][RuleNames.R004]; Assert.IsTrue(result.Result); result = validationMap[obj2][RuleNames.R005]; Assert.IsTrue(result.Result); result = validationMap[obj2][RuleNames.R006]; Assert.IsFalse(result.Result); result = validationMap[obj2][RuleNames.R007]; Assert.IsTrue(result.Result); }
public void CounterTest() { Log.logLevel = Log.LogLevels.BASIC; RuleMSX rmsx = new RuleMSX(); RuleSet ruleSet = rmsx.createRuleSet("CounterTestRuleSet"); DataSet dataSet = rmsx.createDataSet("CounterTestDataSet"); dataSet.addDataPoint("counter", new GenericIntDataPointSource(0)); int maxVal = 10000; RuleAction counterSignalAndStep10 = rmsx.createAction("CounterSignalAndStep10", new CounterSignalAndStep(10)); RuleAction counterSignalAndStep100 = rmsx.createAction("CounterSignalAndStep100", new CounterSignalAndStep(100)); RuleAction counterSignalAndStep1000 = rmsx.createAction("CounterSignalAndStep1000", new CounterSignalAndStep(1000)); RuleAction counterSignalAndStepMax = rmsx.createAction("CounterSignalAndStepMax", new CounterSignalAndStep(maxVal)); EqualSignal equalSignal = new EqualSignal(); RuleAction equalSignalMax = rmsx.createAction("EqualSignalMax", equalSignal); Rule lessThan10 = new Rule("LessThan10", new IntMinMaxEvaluator(0, 9), counterSignalAndStep10); Rule greaterThanOrEqualTo10LessThan100 = new Rule("GreaterThanOrEqualTo10LessThan100", new IntMinMaxEvaluator(10, 99), counterSignalAndStep100); Rule greaterThanOrEqualTo100LessThan1000 = new Rule("GreaterThanOrEqualTo100LessThan1000", new IntMinMaxEvaluator(100, 999), counterSignalAndStep1000); Rule greaterThanOrEqualTo1000LessThanMax = new Rule("GreaterThanOrEqualTo1000LessThanMax", new IntMinMaxEvaluator(1000, maxVal - 1), counterSignalAndStepMax); Rule equalMax = new Rule("EqualMax", new EqualEvaluator(maxVal), equalSignalMax); ruleSet.AddRule(lessThan10); ruleSet.AddRule(greaterThanOrEqualTo10LessThan100); ruleSet.AddRule(greaterThanOrEqualTo100LessThan1000); ruleSet.AddRule(greaterThanOrEqualTo1000LessThanMax); ruleSet.AddRule(equalMax); System.Console.WriteLine(ruleSet.report()); ruleSet.Execute(dataSet); int maxMS = 400000; int step = 10; while (maxMS > 0) { if (equalSignal.fired) { System.Console.WriteLine("Target reached"); break; } System.Threading.Thread.Sleep(step); maxMS -= step; } if (maxMS == 0) { System.Console.WriteLine("Timeout"); } ruleSet.Stop(); System.Console.WriteLine("Execution Time (ms): " + ruleSet.GetLastCycleExecutionTime()); Assert.That(equalSignal.fired, Is.EqualTo(true)); }