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);
}
