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