public Optional <List <InitialData> > GetInitialData()
{
if (!File.Exists(_filePathProvider.FilePath))
{
throw new FileNotFoundException(nameof(_filePathProvider.FilePath));
}
string initialDataFilePath = _filePathProvider.FilePath;
List <string[]> parsingResult = _csvParser.ParseFile(initialDataFilePath);
ValidationOperationResult operationResult = _validator.Validate(parsingResult);
if (operationResult.Successful)
{
List <InitialData> initialData = parsingResult.Select(
strings => new InitialData(
strings[0],
double.Parse(strings[1], CultureInfo.InvariantCulture),
double.Parse(strings[2], CultureInfo.InvariantCulture)))
.ToList();
return(Optional <List <InitialData> > .For(initialData));
}
_validationOperationResultLogger.LogValidationOperationResultMessages(operationResult);
return(Optional <List <InitialData> > .Empty());
}
public ValidationOperationResult ValidateLinguisticVariables(string linguisticVariable)
{
var regexPattern = @"\[\w+(,\w+)*\]:\w+:\[\w+:\w+:\(\d+(\s*,\s*\d+)*\){1}(\|\w+:\w+:\(\d+(\s*,\s*\d+)*\))*\]";
return(Regex.IsMatch(linguisticVariable, regexPattern) ?
ValidationOperationResult.Success() :
ValidationOperationResult.Fail(new List <string> {
"Linguistic variable is not valid"
}));
}
public void LogValidationOperationResultMessages(ValidationOperationResult validationOperationResult)
{
List <string> errorMessages = validationOperationResult.Messages;
string separatorHeader = DateTime.Now.ToLongTimeString();
errorMessages.Insert(0, separatorHeader);
string pathToFile = AppDomain.CurrentDomain.BaseDirectory + @"\ValidationLog.txt";
_fileOperations.AppendLinesToFile(pathToFile, errorMessages);
}
public void Validate_ReturnsFalse_IfFileIsEmpty()
{
// Arrange
List <string[]> input = new List <string[]>();
// Act
ValidationOperationResult result = _validator.Validate(input);
// Assert
Assert.IsFalse(result.Successful);
Assert.AreEqual(result.Messages.Count, 1);
}
public void ValidateLinguisticVariablesNames_ReturnValidationOperationResultWithError_IfOneOfVariablesInImplicationRulesIsNotKnownToKnowledgeBase()
{
// Arrange
string expectedVariable = "Air";
List <ImplicationRule> implicationRules = PrepareImplicationRules();
List <LinguisticVariable> linguisticVariables = PrepareLinguisticVariables();
string errorMessage = $"Knowledge base: linguistic variable {expectedVariable} is unknown to linguistic variable base";
// Act
ValidationOperationResult validationOperationResult = _knowledgeBaseValidator.ValidateLinguisticVariablesNames(
implicationRules, linguisticVariables);
// Assert
Assert.IsTrue(validationOperationResult.Messages.Contains(errorMessage));
}
public void GetInitialData_ReturnsEmptyOptional_IfValidationFails()
{
// Arrange
_filePathProviderMock.Stub(x => x.FilePath).Return(_csvFilePath);
var expectedValidationResult = ValidationOperationResult.Fail(new List <string> {
"something is not right"
});
_validatorMock.Stub(x => x.Validate(Arg <List <string[]> > .Is.Anything)).Return(expectedValidationResult);
// Act
var initialData = _csvDataProvider.GetInitialData();
// Assert
Assert.IsFalse(initialData.IsPresent);
_validationOperationResultLoggerMock.AssertWasCalled(x => x.LogValidationOperationResultMessages(expectedValidationResult));
}
public ValidationOperationResult ValidateImplicationRule(string implicationRule)
{
var validationMessages = new List <string>();
if (string.IsNullOrWhiteSpace(implicationRule))
{
validationMessages.Add("Implication rule is empty");
return(ValidationOperationResult.Fail(validationMessages));
}
var indexOfIfDelimiter = implicationRule.IndexOf("IF(", StringComparison.Ordinal);
if (indexOfIfDelimiter != 0)
{
validationMessages.Add("No IF statement");
}
var indexOfThenDelimiter = implicationRule.IndexOf(")THEN(", StringComparison.Ordinal);
if (indexOfThenDelimiter == -1)
{
validationMessages.Add("No THEN statement");
}
if (validationMessages.Any())
{
return(ValidationOperationResult.Fail(validationMessages));
}
var ifStatement = implicationRule.Substring(2, indexOfThenDelimiter - 1);
var thenStatement = implicationRule.Substring(indexOfThenDelimiter + 5);
if (ParenthesisMismatched(ifStatement))
{
validationMessages.Add("IF statement parenthesis don't match");
}
if (ParenthesisMismatched(thenStatement))
{
validationMessages.Add("THEN statement parenthesis don't match");
}
return(!validationMessages.Any() ?
ValidationOperationResult.Success() :
ValidationOperationResult.Fail(validationMessages));
}
public void Validate_ReturnsFalse_IfThirdValueIsNotInRange()
{
// Arrange
string wrongValue = "init2";
List <string[]> input = new List <string[]>
{
new [] { "init1", "1", "0.1" },
new [] { wrongValue, "2", "10" }
};
// Act
ValidationOperationResult result = _validator.Validate(input);
// Assert
Assert.IsFalse(result.Successful);
Assert.AreEqual(result.Messages.Count, 1);
Assert.IsTrue(result.Messages[0].Contains(wrongValue));
}
public void Validate_ReturnsFalse_IfOneOfValuesCouldNotBeParsed()
{
// Arrange
string faltedValue = "init2";
List <string[]> input = new List <string[]>
{
new [] { "init1", "1", "0.1" },
new [] { faltedValue, "not_numerical", "0.1" }
};
// Act
ValidationOperationResult result = _validator.Validate(input);
// Assert
Assert.IsFalse(result.Successful);
Assert.AreEqual(result.Messages.Count, 1);
Assert.IsTrue(result.Messages[0].Contains(faltedValue));
}
public void Validate_ReturnsFalse_IfOneOfValuesHaveTooMuchInfo()
{
// Arrange
string wrongValue = "init2";
List <string[]> input = new List <string[]>
{
new [] { "init1", "1", "0.1" },
new [] { wrongValue, "1", "0.1", "not_needed" },
new [] { "init3", "2", "0.1" }
};
// Act
ValidationOperationResult result = _validator.Validate(input);
// Assert
Assert.IsFalse(result.Successful);
Assert.AreEqual(result.Messages.Count, 1);
Assert.IsTrue(result.Messages[0].Contains(wrongValue));
}
public ValidationOperationResult Validate(List <string[]> parsingResult)
{
var validationMessages = new List <string>();
if (parsingResult.Count == 0)
{
validationMessages.Add("No initial data found.");
}
foreach (var strings in parsingResult)
{
if (strings.Length < 3)
{
validationMessages.Add($"Missing data at {strings[0]}.");
continue;
}
if (strings.Length > 3)
{
validationMessages.Add($"Too much information at {strings[0]}.");
continue;
}
if (strings.Length == 3 && !double.TryParse(strings[1], NumberStyles.Any, CultureInfo.InvariantCulture, out var value))
{
validationMessages.Add($"Value for data at {strings[0]} is not numeric.");
}
var parsedResult = double.TryParse(strings[2], NumberStyles.Any, CultureInfo.InvariantCulture, out value);
if (strings.Length == 3 && !parsedResult)
{
validationMessages.Add($"Confidence factor for data at {strings[0]} is not numeric.");
}
if (strings.Length == 3 && parsedResult && (value < 0 || value > 1))
{
validationMessages.Add($"Confidence factor for data at {strings[0]} is not in range.");
}
}
return(validationMessages.Any() ? ValidationOperationResult.Fail(validationMessages) : ValidationOperationResult.Success());
}
public ValidationOperationResult ValidateLinguisticVariablesNames(
List <ImplicationRule> implicationRules,
List <LinguisticVariable> linguisticVariables)
{
var allVariableNames = linguisticVariables.Select(lv => lv.VariableName).ToList();
var ifStatementsLinguisticVariableNames = implicationRules
.SelectMany(ir => ir.IfStatement.SelectMany(ifs => ifs.UnaryStatements.Select(us => us.LeftOperand)))
.ToList();
var thenStatementsLinguisticVariableNames = implicationRules
.SelectMany(ir => ir.ThenStatement.UnaryStatements.Select(us => us.LeftOperand))
.ToList();
var implicationRulesLinguisticVariableNames = new List <string>(ifStatementsLinguisticVariableNames.Concat(thenStatementsLinguisticVariableNames));
var validationMessages = implicationRulesLinguisticVariableNames
.Where(implicationRulesLinguisticVariableName => !allVariableNames.Contains(implicationRulesLinguisticVariableName))
.Select(implicationRulesLinguisticVariableName => $"Knowledge base: linguistic variable {implicationRulesLinguisticVariableName} is unknown to linguistic variable base")
.ToList();
return(validationMessages.Any() ? ValidationOperationResult.Fail(validationMessages) : ValidationOperationResult.Success());
}
public void GetInitialData_ReturnsDictionary_IfValidationSucceeded()
{
// Arrange
_filePathProviderMock.Stub(x => x.FilePath).Return(_csvFilePath);
var expectedParsingResult = new List <string[]>
{
new [] { "I1_1", "55", "0.1" },
new [] { "I1_2", "10.5", "0.1" },
new [] { "Init3", "0.55", "0.1" },
new [] { "Init4", "1", "0.1" },
new [] { "Init5", "2", "0.1" }
};
_csvParserMock.Stub(x => x.ParseFile(_csvFilePath)).Return(expectedParsingResult);
var expectedValidationResult = ValidationOperationResult.Success();
_validatorMock.Stub(x => x.Validate(Arg <List <string[]> > .Is.Anything)).Return(expectedValidationResult);
var expectedData = new List <InitialData>
{
new InitialData("I1_1", 55, 0.1),
new InitialData("I1_2", 10.5, 0.1),
new InitialData("Init3", 0.55, 0.1),
new InitialData("Init4", 1, 0.1),
new InitialData("Init5", 2, 0.1)
};
var expectedResult = Optional <List <InitialData> > .For(expectedData);
// Act
var actualResult = _csvDataProvider.GetInitialData();
// Assert
Assert.IsTrue(actualResult.IsPresent);
Assert.AreEqual(expectedResult.Value.Count, actualResult.Value.Count);
for (var i = 0; i < actualResult.Value.Count; i++)
{
Assert.IsTrue(ObjectComparer.InitialDatasAreEqual(expectedResult.Value[i], actualResult.Value[i]));
}
_validationOperationResultLoggerMock.AssertWasNotCalled(x => x.LogValidationOperationResultMessages(expectedValidationResult));
}
