private List <ImplicationRule> DivideComplexImplicationRules(List <ImplicationRule> implicationRules) { List <ImplicationRule> grownRuleList = new List <ImplicationRule>(); foreach (var implicationRule in implicationRules) { if (implicationRule.IfStatement.Count > 1) { foreach (var statementCombination in implicationRule.IfStatement) { ImplicationRule dividedImplicationRule = new ImplicationRule(new List <StatementCombination> { statementCombination }, implicationRule.ThenStatement); grownRuleList.Add(dividedImplicationRule); } } else { grownRuleList.Add(implicationRule); } } return(grownRuleList); }
public void ToString_ReturnsCorrectStringRepresentaionReversedComplexCase() { // Arrange string expectedStringRepresentation = "IF (D >= 5 | (B != 1 & C != 2)) THEN (X = 10 & Y = 7)"; ImplicationRule implicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("D", ComparisonOperation.GreaterOrEqual, "5") }), new StatementCombination(new List <UnaryStatement> { new UnaryStatement("B", ComparisonOperation.NotEqual, "1"), new UnaryStatement("C", ComparisonOperation.NotEqual, "2") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("X", ComparisonOperation.Equal, "10"), new UnaryStatement("Y", ComparisonOperation.Equal, "7") })); // Act string actualStringRepresentation = implicationRule.ToString(); // Assert Assert.AreEqual(expectedStringRepresentation, actualStringRepresentation); }
private Dictionary <int, ImplicationRule> PrepareImplicationRules() { ImplicationRule firstImplicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("Temperature", ComparisonOperation.Greater, "HOT") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("Pressure", ComparisonOperation.Equal, "HIGH") })); ImplicationRule secondImplicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("Volume", ComparisonOperation.GreaterOrEqual, "BIG"), new UnaryStatement("Color", ComparisonOperation.Equal, "RED") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("Danger", ComparisonOperation.Equal, "HIGH") })); ImplicationRule thirdImplicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("Pressure", ComparisonOperation.Equal, "HIGH"), new UnaryStatement("Danger", ComparisonOperation.Equal, "HIGH") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("Evacuate", ComparisonOperation.Equal, "TRUE") })); return(new Dictionary <int, ImplicationRule> { { 1, firstImplicationRule }, { 2, secondImplicationRule }, { 3, thirdImplicationRule } }); }
public static bool ImplicationRulesAreEqual( ImplicationRule implicationRuleToCompare, ImplicationRule implicationRuleToCompareWith) { if (implicationRuleToCompare.IfStatement.Count != implicationRuleToCompareWith.IfStatement.Count) { return(false); } for (int i = 0; i < implicationRuleToCompare.IfStatement.Count; i++) { List <UnaryStatement> ifUnaryStatementsToCompare = implicationRuleToCompare.IfStatement[i].UnaryStatements; List <UnaryStatement> ifUnaryStatementsToCompareWith = implicationRuleToCompareWith.IfStatement[i].UnaryStatements; if (ifUnaryStatementsToCompare.Count != ifUnaryStatementsToCompareWith.Count) { return(false); } for (var j = 0; j < ifUnaryStatementsToCompare.Count; j++) { if (!UnaryStatementsAreEqual(ifUnaryStatementsToCompare[j], ifUnaryStatementsToCompareWith[j])) { return(false); } } } List <UnaryStatement> thenUnaryStatementsToCompare = implicationRuleToCompare.ThenStatement.UnaryStatements; List <UnaryStatement> thenUnaryStatementsToCompareWith = implicationRuleToCompareWith.ThenStatement.UnaryStatements; if (thenUnaryStatementsToCompare.Count != thenUnaryStatementsToCompareWith.Count) { return(false); } for (var i = 0; i < thenUnaryStatementsToCompare.Count; i++) { if (!UnaryStatementsAreEqual(thenUnaryStatementsToCompare[i], thenUnaryStatementsToCompareWith[i])) { return(false); } } return(true); }
public Optional <List <ImplicationRule> > GetImplicationRules(string profileName) { var profile = _profileRepository.GetProfileByName(profileName); if (!profile.IsPresent || profile.Value.Rules == null || !profile.Value.Rules.Any()) { return(Optional <List <ImplicationRule> > .Empty()); } List <ImplicationRule> implicationRules = new List <ImplicationRule>(); foreach (var rule in profile.Value.Rules) { ImplicationRule implicationRule = _implicationRuleCreator.CreateImplicationRuleEntity(rule); implicationRules.Add(implicationRule); } List <ImplicationRule> separatedImplicationRules = DivideComplexImplicationRules(implicationRules); return(Optional <List <ImplicationRule> > .For(separatedImplicationRules)); }
private List <ImplicationRule> PrepareImplicationRules() { // IF(Water IS Cold) THEN (Pressure IS Low) ImplicationRule firstImplicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("Water", ComparisonOperation.Equal, "Cold") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("Pressure", ComparisonOperation.Equal, "Low") })); // IF(Water IS Hot AND Air IS Cold) THEN (Pressure IS Medium) ImplicationRule secondImplicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("Water", ComparisonOperation.Equal, "Hot"), new UnaryStatement("Air", ComparisonOperation.Equal, "Cold") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("Pressure", ComparisonOperation.Equal, "Medium") })); List <ImplicationRule> rules = new List <ImplicationRule> { firstImplicationRule, secondImplicationRule }; return(rules); }
public void ToString_ReturnsCorrectStringRepresentaionSingleUnaryCase() { // Arrange string expectedStringRepresentation = "IF (C != 2) THEN (X = 10)"; ImplicationRule implicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("C", ComparisonOperation.NotEqual, "2") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("X", ComparisonOperation.Equal, "10") })); // Act string actualStringRepresentation = implicationRule.ToString(); // Assert Assert.AreEqual(expectedStringRepresentation, actualStringRepresentation); }
public void GetImplicationRules_ReturnsCorrectListOfRules() { // Arrange var firstImplicationRuleString = "IF(A>10)THEN(X=5)"; var secondImplicationRuleString = "IF(B!=1&C!=2)THEN(X=10)"; var implicationRulesInDatabase = new List <string> { firstImplicationRuleString, secondImplicationRuleString }; var profileName = "profile_name"; var profile = new InferenceProfile { ProfileName = profileName, Rules = implicationRulesInDatabase }; _profileRepositoryMock.Stub(x => x.GetProfileByName(profileName)).Return(Optional <InferenceProfile> .For(profile)); // IF (A > 10) THEN (X = 5) var firstImplicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("A", ComparisonOperation.Greater, "10") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("X", ComparisonOperation.Equal, "5") })); _implicationRuleCreatorMock.Stub(x => x.CreateImplicationRuleEntity(firstImplicationRuleString)).Return(firstImplicationRule); // IF (B != 1 & C != 2) THEN (X = 10) var secondImplicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("B", ComparisonOperation.NotEqual, "1"), new UnaryStatement("C", ComparisonOperation.NotEqual, "2") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("X", ComparisonOperation.Equal, "10") })); _implicationRuleCreatorMock.Stub(x => x.CreateImplicationRuleEntity(secondImplicationRuleString)).Return(secondImplicationRule); var expectedImplicationRules = new List <ImplicationRule> { firstImplicationRule, secondImplicationRule }; var expectedOptional = Optional <List <ImplicationRule> > .For(expectedImplicationRules); // Act var actualOptional = _databaseImplicationRuleProvider.GetImplicationRules(profileName); // Assert Assert.IsTrue(actualOptional.IsPresent); Assert.AreEqual(expectedOptional.Value, actualOptional.Value); }
private Dictionary <int, ImplicationRule> PrepareExpectedImplicationRules() { // IF (A > 10) THEN (X = 5) ImplicationRule firstImplicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("A", ComparisonOperation.Greater, "10") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("X", ComparisonOperation.Equal, "5") })); // IF (B != 1 & C != 2) THEN (X = 10) ImplicationRule secondImplicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("B", ComparisonOperation.NotEqual, "1"), new UnaryStatement("C", ComparisonOperation.NotEqual, "2") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("X", ComparisonOperation.Equal, "10") })); // IF ((A = 5 | B = 10) & C = 6) THEN (X = 7) ImplicationRule thirdImplicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("A", ComparisonOperation.Equal, "5"), new UnaryStatement("C", ComparisonOperation.Equal, "6") }) }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("X", ComparisonOperation.Equal, "7") })); ImplicationRule fourthImplicationRule = new ImplicationRule( new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("B", ComparisonOperation.Equal, "10"), new UnaryStatement("C", ComparisonOperation.Equal, "6") }), }, new StatementCombination(new List <UnaryStatement> { new UnaryStatement("X", ComparisonOperation.Equal, "7") })); return(new Dictionary <int, ImplicationRule> { { 1, firstImplicationRule }, { 2, secondImplicationRule }, { 3, thirdImplicationRule }, { 4, fourthImplicationRule } }); }
public void CreateImplicationRuleEntity_ReturnsImplicationRule() { // Arrange string ifStatementPart = "(A=a|(B=b&C=c))"; string thenStatementPart = "(D=d)"; string implicationRule = $"IF{ifStatementPart}THEN{thenStatementPart}"; ImplicationRuleStrings implicationRuleStrings = new ImplicationRuleStrings(ifStatementPart, thenStatementPart); _implicationRuleParser.Expect(x => x.ExtractStatementParts(implicationRule)).Return(implicationRuleStrings); // (A=a|(B=b&C=c)) List <StatementCombination> ifStatementCombinations = new List <StatementCombination> { new StatementCombination(new List <UnaryStatement> { new UnaryStatement("A", ComparisonOperation.Equal, "a") }), new StatementCombination(new List <UnaryStatement> { new UnaryStatement("B", ComparisonOperation.Equal, "b"), new UnaryStatement("C", ComparisonOperation.Equal, "c") }) }; // (D=d) StatementCombination thenStatementCombination = new StatementCombination(new List <UnaryStatement> { new UnaryStatement("D", ComparisonOperation.Equal, "d") }); ImplicationRule expectedImplicationRule = new ImplicationRule(ifStatementCombinations, thenStatementCombination); List <string> ifStatementParts = new List <string> { "A=a", "B=b&C=c" }; _implicationRuleParser.Expect(irp => irp.ParseImplicationRule(ref ifStatementPart)) .Return(ifStatementParts); List <string> thenStatementParts = new List <string> { "D=d" }; _implicationRuleParser.Expect(irp => irp.ParseStatementCombination(thenStatementPart)) .Return(thenStatementParts); List <string> aIfUnaryStatementStrings = new List <string> { "A=a" }; List <string> bcIfUnaryStatementStrings = new List <string> { "B=b", "C=c" }; _implicationRuleParser.Expect(irp => irp.ParseStatementCombination("A=a")).Return(aIfUnaryStatementStrings); _implicationRuleParser.Expect(irp => irp.ParseStatementCombination("B=b&C=c")).Return(bcIfUnaryStatementStrings); UnaryStatement aUnaryStatement = new UnaryStatement("A", ComparisonOperation.Equal, "a"); UnaryStatement bUnaryStatement = new UnaryStatement("B", ComparisonOperation.Equal, "b"); UnaryStatement cUnaryStatement = new UnaryStatement("C", ComparisonOperation.Equal, "c"); UnaryStatement dUnaryStatement = new UnaryStatement("D", ComparisonOperation.Equal, "d"); _implicationRuleParser.Expect(irp => irp.ParseUnaryStatement("A=a")).Return(aUnaryStatement); _implicationRuleParser.Expect(irp => irp.ParseUnaryStatement("B=b")).Return(bUnaryStatement); _implicationRuleParser.Expect(irp => irp.ParseUnaryStatement("C=c")).Return(cUnaryStatement); _implicationRuleParser.Expect(irp => irp.ParseUnaryStatement("D=d")).Return(dUnaryStatement); // Act ImplicationRule actualImplicationRule = _implicationRuleCreator.CreateImplicationRuleEntity(implicationRule); // Assert Assert.IsTrue(ObjectComparer.ImplicationRulesAreEqual(expectedImplicationRule, actualImplicationRule)); }
public void SetUp() { _implicationRule = new ImplicationRule(_ifUnaryStatements, _thenUnaryStatement); }