public void RelationRuleComboTest()
{
// r(x) is true if r2(x) and r3(x) are true
Relation r = new Relation();
Relation r2 = new Relation();
Relation r3 = new Relation();
Pair[] args = new Pair[] { Pair.Variable("x") };
Rule rule = new Rule(args);
rule.AddCondition(r2, args);
rule.AddCondition(r3, args);
r.AddRule(rule);
r2.AddFact(new string[] { "testy" });
r3.AddFact(new string[] { "problemo" });
AssertResults(new string[0, 0, 0], r.Query(args));
// add "testy" to r3 and try again
r3.AddFact(new string[] { "testy" });
AssertResults(new string[, , ] {
{
{ "x", "testy" }
}
}, r.Query(args));
}
public void SaveLoadRules()
{
ArchiverMain archiver = ArchiverMain.Current;
CreateFewChannels();
Assert.IsEmpty(archiver.ChannelsSettings.Rules);
Rule newRule = new Rule();
newRule.Name = "Test rule";
newRule.AddChannel(archiver.ChannelsSettings.Channels[0]);
newRule.AddChannel(archiver.ChannelsSettings.Channels[1]);
newRule.AddCondition(new TimeIntervalCondition(12345));
archiver.ChannelsSettings.AddRule(newRule);
Assert.IsNotEmpty(archiver.ChannelsSettings.Rules);
archiver.ChannelsSettings.Save();
ArchiverMain.Deinitialize();
ArchiverMain.Initialize();
archiver = ArchiverMain.Current;
archiver.ChannelsSettings.Rules = new List <Rule>();
archiver.ChannelsSettings.Load();
Assert.IsNotEmpty(archiver.ChannelsSettings.Rules);
Assert.AreEqual(newRule.Name, archiver.ChannelsSettings.Rules[0].Name);
Assert.AreEqual(newRule.Channels[0].ChannelName, archiver.ChannelsSettings.Rules[0].Channels[0].ChannelName);
Assert.AreEqual(newRule.Channels[1].ChannelName, archiver.ChannelsSettings.Rules[0].Channels[1].ChannelName);
Assert.AreEqual((newRule.Conditions[0] as TimeIntervalCondition).Interval, (archiver.ChannelsSettings.Rules[0].Conditions[0] as TimeIntervalCondition).Interval);
}
public void RelationRuleMultiOptionTest()
{
Relation r = new Relation();
Relation r2 = new Relation();
Relation r3 = new Relation();
// r(x) is true if either r2(x) or r3(x)
Pair[] args1 = new Pair[] { Pair.Fresh() };
Rule rule = new Rule(args1);
rule.AddCondition(r2, args1);
Pair[] args2 = new Pair[] { Pair.Fresh() };
Rule rule2 = new Rule(args2);
rule2.AddCondition(r3, args2);
r.AddRule(rule);
r.AddRule(rule2);
r2.AddFact(new string[] { "r2 testy" });
r3.AddFact(new string[] { "r3 testy" });
AssertResults(new string[, , ] {
{
{ "a", "r2 testy" }
},
{
{ "a", "r3 testy" }
}
}, r.Query(new Pair[] { Pair.Variable("a") }));
}
public void RelationRuleAssocTest()
{
// r is true wherever r2 is true
Relation r = new Relation();
Relation r2 = new Relation();
Pair a = Pair.Variable("a");
Rule rule = new Rule(new Pair[] { a });
rule.AddCondition(r2, new Pair[] { a });
r.AddRule(rule);
r2.AddFact(new string[] { "test" });
AssertResults(new string[, , ] {
{
{ "a", "test" }
}
}, r.Query(new Pair[] { Pair.Variable("a") }));
r2.AddFact(new string[] { "test 2" });
AssertResults(new string[, , ] {
{
{ "a", "test" }
},
{
{ "a", "test 2" }
}
}, r.Query(new Pair[] { Pair.Variable("a") }));
}
internal void LoadController(XmlNodeList xmlNodeList, RuleController ruleController)
{
foreach (XmlNode xmlMainNode in xmlNodeList)
{
if (xmlMainNode.Name.Equals("Rule"))
{
//We got our hands on a rule, lets load it.
var rule = new Rule();
foreach (XmlNode childNode in xmlMainNode)
{
switch (childNode.Name)
{
case "Name":
rule.Name = childNode.InnerText;
break;
case "Script":
rule.Script = childNode.InnerText;
break;
case "MatchAll":
rule.MatchAll = Convert.ToBoolean(childNode.InnerText);
break;
case "ShouldTarget":
rule.ShouldTarget =
(Target)Enum.Parse(typeof(Target), childNode.InnerText);
break;
case "Priority":
rule.Priority = Convert.ToInt32(childNode.InnerText);
break;
case "Action":
rule.LoadAction(childNode);
break;
default:
AbstractCondition condition = LoadConditions(childNode);
if (condition != null)
{
rule.AddCondition(condition);
}
break;
}
}
ruleController.AddRule(rule);
}
}
}
public void RelationRuleRecursiveTest()
{
Relation r = new Relation();
Pair[] args = new Pair[] { Pair.Fresh() };
Rule rule = new Rule(args);
rule.AddCondition(r, args);
try {
r.AddRule(rule);
Assert.Fail("Adding a recursive rule should raise an exception");
} catch (InvalidRelationException) {
//
}
}
public void RuleTest()
{
Relation r1 = new Relation();
r1.AddFact(new string[] { "test" });
Pair[] args = new Pair[] { Pair.Variable("a"), Pair.Variable("b") };
Rule rule = new Rule(args);
rule.AddCondition(r1, new Pair[] { Pair.Variable("a") });
AssertResults(new string[, , ] {
{
{ "a", "test" },
{ "b", null }
}
}, rule.GetGoal(new Pair[] { Pair.Variable("a"), Pair.Variable("b") }));
}
public void RelationRuleFlippyTest()
{
// r(x, y) is true wherever r2(y, x) is true
Relation r = new Relation();
Relation r2 = new Relation();
Pair[] norm_args = new Pair[] { Pair.Variable("x"), Pair.Variable("y") };
Pair[] flip_args = new Pair[] { Pair.Variable("y"), Pair.Variable("x") };
Rule rule = new Rule(norm_args);
rule.AddCondition(r2, flip_args);
r.AddRule(rule);
r2.AddFact(new string[] { "y1", "x1" });
AssertResults(new string[, , ] {
{
{ "x", "x1" },
{ "y", "y1" }
}
}, r.Query(norm_args));
}
public void RulePartiallyBoundTest()
{
Relation r1 = new Relation();
r1.AddFact(new string[] { "chimpy" });
Pair[] args = new Pair[] { Pair.Variable("a"), Pair.Variable("b") };
Rule rule = new Rule(args);
rule.AddCondition(r1, new Pair[] { Pair.Variable("a") });
AssertResults(new string[, , ] {
{
{ "b", null }
}
}, rule.GetGoal(new Pair[] { Pair.Value("chimpy"), Pair.Variable("b") }));
foreach (Stream stream in rule.GetGoal(new Pair[] { Pair.Value("bongo"), Pair.Variable("b") }).Walk(new Stream()))
{
Pair bong = stream.Walk(new Pair("bongo", false));
}
AssertResults(new string[0, 0, 0], rule.GetGoal(new Pair[] { Pair.Value("bongo"), Pair.Variable("b") }));
}
public void TestMethod1()
{
var filename = "Rules.json";
var car = new SerializableCar();
car.Classification = CarClassification.SportUtilityVehicle;
car.WheelCount = 2;
var json = File.ReadAllText(filename);
var deserializedObject = JsonConvert.DeserializeObject <SerializableCar>(json);
var ruleEngine = new RuleEngine <SerializableCar>();
foreach (var deserializedRule in deserializedObject.Rules)
{
var rule = new Rule <SerializableCar>();
foreach (var compositeCondition in deserializedRule.Conditions)
{
foreach (var condition in compositeCondition.Conditions)
{
rule.AddCondition(condition.FieldName, condition.Operation, condition.Value, compositeCondition.LogicalOperation);
}
}
foreach (var action in deserializedRule.Actions)
{
rule.AddAction(action.FieldName, action.Operation, action.Data);
}
ruleEngine.AddRule(rule);
}
ruleEngine.Evaluate(car);
Assert.AreEqual(300, car.WheelCount);
}
private void BtnSave_Click(object sender, EventArgs e)
{
if (CBCastSpell.Checked)
{
if (TBSpellName.Text == "")
{
superTooltip1.SetSuperTooltip(TBSpellName,
new SuperTooltipInfo("", "", "You need to type a spell name.", null,
null, eTooltipColor.Gray));
superTooltip1.ShowTooltip(TBSpellName);
return;
}
Rule.Action = new ActionSpell(TBSpellName.Text);
}
if (CBSendKey.Checked)
{
if (TBKeyName.Text == "")
{
superTooltip1.SetSuperTooltip(TBKeyName,
new SuperTooltipInfo("", "", "You need to type a key name.", null,
null, eTooltipColor.Gray));
superTooltip1.ShowTooltip(TBKeyName);
return;
}
if (TBKey.Text == "")
{
superTooltip1.SetSuperTooltip(TBKeyName,
new SuperTooltipInfo("", "", "You need to type a key.", null, null,
eTooltipColor.Gray));
superTooltip1.ShowTooltip(TBKeyName);
return;
}
Rule.Action = new ActionKey(TBKeyName.Text, ComBBar.SelectedItem.ToString(), TBKey.Text,
ComBSpecail.SelectedItem.ToString(), ComBTimes.Value);
}
if (TBRuleName.Text == "")
{
superTooltip1.SetSuperTooltip(TBSpellName,
new SuperTooltipInfo("", "", "Please give the rule a name.", null, null,
eTooltipColor.Gray));
superTooltip1.ShowTooltip(TBSpellName);
return;
}
if (AllConditions.Nodes.Count == 0)
{
superTooltip1.SetSuperTooltip(TBSpellName,
new SuperTooltipInfo("", "", "Please create one condition", null, null,
eTooltipColor.Gray));
superTooltip1.ShowTooltip(TBSpellName);
return;
}
Rule.MatchAll = SWMatchConditions.Value;
Rule.Name = TBRuleName.Text;
Rule.ClearConditions();
foreach (Node node in AllConditions.Nodes)
{
Rule.AddCondition((AbstractCondition)node.Tag);
}
if (RBEnemy.Checked)
{
Rule.ShouldTarget = Target.Enemy;
}
if (RBNone.Checked)
{
Rule.ShouldTarget = Target.None;
}
if (RBPet.Checked)
{
Rule.ShouldTarget = Target.Pet;
}
if (RBSelf.Checked)
{
Rule.ShouldTarget = Target.Self;
}
if (RBUnchanged.Checked)
{
Rule.ShouldTarget = Target.Unchanged;
}
Save = true;
Close();
}
internal void LoadController(XmlNodeList xmlNodeList, RuleController ruleController)
{
foreach (XmlNode xmlMainNode in xmlNodeList)
{
if (xmlMainNode.Name.Equals("Rule"))
{
//We got our hands on a rule, lets load it.
var rule = new Rule();
foreach (XmlNode childNode in xmlMainNode)
{
switch (childNode.Name)
{
case "Name":
rule.Name = childNode.InnerText;
break;
case "Script":
rule.Script = childNode.InnerText;
break;
case "MatchAll":
rule.MatchAll = Convert.ToBoolean(childNode.InnerText);
break;
case "ShouldTarget":
rule.ShouldTarget =
(Target) Enum.Parse(typeof (Target), childNode.InnerText);
break;
case "Priority":
rule.Priority = Convert.ToInt32(childNode.InnerText);
break;
case "Action":
rule.LoadAction(childNode);
break;
default:
AbstractCondition condition = LoadConditions(childNode);
if (condition != null)
rule.AddCondition(condition);
break;
}
}
ruleController.AddRule(rule);
}
}
}
protected override List <Rule> ReadRules(List <string> WekaFormattedRules)
{
List <Rule> rules = new List <Rule>();
foreach (string line in WekaFormattedRules)
{
if (line.Split(' ')[0] == "DEFAULT:")
{
DefaultClassification = line.Split(' ')[1];
return(rules);
}
string LHSAttribute = "";
List <string> RHSValues = new List <string>();
List <Rule.EComparator> comparators = new List <Rule.EComparator>();
Rule currentRule = new Rule()
{
Classification = line.Split(new string[] { " --> " }, StringSplitOptions.None)[1]
};
string trimmedLine = line.Split(new string[] { " ] ) --> " }, StringSplitOptions.None)[0].Substring(7, line.Split(new string[] { " ] ) --> " }, StringSplitOptions.None)[0].Length - 7);
string[] components = trimmedLine.Split(new string[] { " ] & [ " }, StringSplitOptions.None);
foreach (string component in components)
{
RHSValues = new List <string>();
comparators = new List <Rule.EComparator>();
string[] subComponents = component.Split(new string[] { " OR " }, StringSplitOptions.None);
foreach (string subComponent in subComponents)
{
string[] splitstring = subComponent.Split(' ');
LHSAttribute = splitstring[0];
switch (splitstring[1])
{
case (">"):
comparators.Add(Rule.EComparator.GreaterThan);
break;
case ("<"):
comparators.Add(Rule.EComparator.LessThan);
break;
case ("<="):
comparators.Add(Rule.EComparator.LessThanInclusive);
break;
case (">="):
comparators.Add(Rule.EComparator.GreaterThanInclusive);
break;
case ("="):
comparators.Add(Rule.EComparator.Equal);
break;
}
RHSValues.Add(splitstring[2]);
}
currentRule.AddCondition(new Rule.RuleComponent(LHSAttribute, comparators, RHSValues));
}
rules.Add(currentRule);
}
return(rules);
}
protected override List <Rule> ReadRules(List <string> WekaFormattedRules)
{
string classifierAttribute = WekaFormattedRules[0].Split(new string[] { " = " }, StringSplitOptions.None)[0];
DefaultClassification = WekaFormattedRules[0].Split(new string[] { " = " }, StringSplitOptions.None)[1].Split(' ')[0];
List <Rule> rules = new List <Rule>();
for (int line = 1; line < WekaFormattedRules.Count; ++line)
{
Rule currentRule = new Rule();
string[] splitSpaces = WekaFormattedRules[line].Split(' ');
string trimmedLine = "";
for (int i = 1; i < splitSpaces.Count() - 2; ++i)
{
trimmedLine += splitSpaces[i] + " ";
}
currentRule.Classification = trimmedLine.Split(new string[] { " => " }, StringSplitOptions.None)[1].Split(' ')[2];
string componentString = trimmedLine.Split(new string[] { " => " }, StringSplitOptions.None)[0];
string[] components = componentString.Split(new string[] { " and " }, StringSplitOptions.None);
foreach (string component in components)
{
string[] splitComponent = component.Substring(1, component.Length - 2).Split(' ');
string LHSAttribute = splitComponent[0];
Rule.EComparator comparator = Rule.EComparator.Equal;
switch (splitComponent[1])
{
case (">"):
comparator = Rule.EComparator.GreaterThan;
break;
case ("<"):
comparator = Rule.EComparator.LessThan;
break;
case ("<="):
comparator = Rule.EComparator.LessThanInclusive;
break;
case (">="):
comparator = Rule.EComparator.GreaterThanInclusive;
break;
case ("="):
comparator = Rule.EComparator.Equal;
break;
}
currentRule.AddCondition(new Rule.RuleComponent(splitComponent[0], new List <Rule.EComparator>()
{
comparator
}, new List <string>()
{
splitComponent[2]
}));
}
rules.Add(currentRule);
}
return(rules);
}
protected override List <Rule> ReadRules(List <string> WekaFormattedRules)
{
Rule currentRule = null;
List <Rule> rules = new List <Rule>();
string classification = String.Empty;
string Attribute = String.Empty;
string[] Values = null;
List <string> RHSValuesList = new List <string>();
List <Rule.EComparator> comparators = new List <Rule.EComparator>();
string[] splitLineClassifier;
string[] splitLineRuleComponents;
string[] splitLHSRHS;
string[] splitRHSValues;
foreach (string line in WekaFormattedRules)
{
currentRule = new Rule();
splitLineClassifier = line.Split(new string[] { " (" }, StringSplitOptions.None)[0].Split(new string[] { " : " }, StringSplitOptions.None);
splitLineRuleComponents = splitLineClassifier[1].Split(new string[] { " ^ " }, StringSplitOptions.None);
classification = splitLineClassifier[0];
classification = classification.Substring(6, classification.Length - 9);
currentRule.Classification = classification;
foreach (string ruleComponent in splitLineRuleComponents)
{
comparators = new List <Rule.EComparator>();
RHSValuesList = new List <string>();
if ((splitLHSRHS = ruleComponent.Split(new string[] { " in " }, StringSplitOptions.None)).Length > 1)
{
Attribute = splitLHSRHS[0];
splitLHSRHS[1] = splitLHSRHS[1].Substring(1, splitLHSRHS[1].Length - 2);
splitRHSValues = splitLHSRHS[1].Split(',');
Values = splitRHSValues;
for (int i = 0; i < Values.Length; ++i)
{
comparators.Add(Rule.EComparator.Equal);
}
}
else
{
int Operand1EndIndex = 0;
int Operand3StartIndex = 0;
int Operand2StartIndex = 0;
int Operand2EndIndex = ruleComponent.Length;
int operandCount = 1;
for (int i = 0; i < ruleComponent.Length - 1; ++i)
{
if (Operators.Match(ruleComponent[i].ToString()).Success)
{
operandCount++;
if (Operand1EndIndex == 0)
{
if (Operators.Match(ruleComponent[i + 1].ToString()).Success)
{
Operand1EndIndex = i - 1;
Operand2StartIndex = i + 2;
++i;
}
else
{
Operand1EndIndex = i - 1;
Operand2StartIndex = i + 1;
}
}
else
{
Operand2EndIndex = i - 1;
if (Operators.Match(ruleComponent[i + 1].ToString()).Success)
{
Operand3StartIndex = i + 2;
++i;
}
else
{
Operand3StartIndex = i + 1;
}
}
++i;
}
}
if (operandCount < 3)
{
Attribute = ruleComponent.Substring(0, Operand1EndIndex + 1);
switch (ruleComponent.Substring(Operand1EndIndex + 1, Operand2StartIndex - 1 - (Operand1EndIndex)))
{
case ">":
comparators.Add(Rule.EComparator.GreaterThan);
break;
case "=":
comparators.Add(Rule.EComparator.Equal);
break;
case "<":
comparators.Add(Rule.EComparator.LessThan);
break;
case ">=":
comparators.Add(Rule.EComparator.GreaterThanInclusive);
break;
case "<=":
comparators.Add(Rule.EComparator.LessThanInclusive);
break;
}
RHSValuesList.Add(ruleComponent.Substring(Operand2StartIndex, ruleComponent.Length - Operand2StartIndex));
}
else
{
Attribute = ruleComponent.Substring(Operand2StartIndex, Operand2EndIndex - Operand2StartIndex + 1);
string RHSValue1 = ruleComponent.Substring(0, Operand1EndIndex + 1);
switch (ruleComponent.Substring(Operand1EndIndex + 1, Operand2StartIndex - 1 - (Operand1EndIndex)))
{
case ">":
//comparators.Add(Rule.EComparator.LessThan);
currentRule.AddCondition(new Rule.RuleComponent(Attribute, new List <Rule.EComparator>()
{
Rule.EComparator.LessThan
}, new string[] { RHSValue1 }));
break;
case "=":
currentRule.AddCondition(new Rule.RuleComponent(Attribute, new List <Rule.EComparator>()
{
Rule.EComparator.Equal
}, new string[] { RHSValue1 }));
break;
case "<":
currentRule.AddCondition(new Rule.RuleComponent(Attribute, new List <Rule.EComparator>()
{
Rule.EComparator.GreaterThan
}, new string[] { RHSValue1 }));
break;
case ">=":
currentRule.AddCondition(new Rule.RuleComponent(Attribute, new List <Rule.EComparator>()
{
Rule.EComparator.LessThanInclusive
}, new string[] { RHSValue1 }));
break;
case "<=":
currentRule.AddCondition(new Rule.RuleComponent(Attribute, new List <Rule.EComparator>()
{
Rule.EComparator.GreaterThanInclusive
}, new string[] { RHSValue1 }));
break;
}
switch (ruleComponent.Substring(Operand2EndIndex + 1, Operand3StartIndex - 1 - (Operand2EndIndex)))
{
case ">":
comparators.Add(Rule.EComparator.GreaterThan);
break;
case "=":
comparators.Add(Rule.EComparator.Equal);
break;
case "<":
comparators.Add(Rule.EComparator.LessThan);
break;
case ">=":
comparators.Add(Rule.EComparator.GreaterThanInclusive);
break;
case "<=":
comparators.Add(Rule.EComparator.LessThanInclusive);
break;
}
RHSValuesList.Add(ruleComponent.Substring(Operand3StartIndex, ruleComponent.Length - Operand3StartIndex));
}
Values = RHSValuesList.ToArray();
}
currentRule.AddCondition(new Rule.RuleComponent(Attribute, comparators, Values));
}
rules.Add(currentRule);
}
return(rules);
}
