/// <summary>
/// Returns a list of the consumers enumerated in this object.
/// </summary>
/// <returns></returns>
public string ListOfConsumers()
{
IList <string> consumerLists = new List <string>();
if (InputParameters.Any())
{
consumerLists.Add($"input parameters = {string.Join(",", InputParameters)}");
}
if (EquivalenceClasses.Any())
{
consumerLists.Add($"equivalence classes = {string.Join(",", EquivalenceClasses)}");
}
if (ExpectedResults.Any())
{
consumerLists.Add($"expected results = {string.Join(",", ExpectedResults)}");
}
if (CoverageGroups.Any())
{
consumerLists.Add($"coverage groups = {string.Join(",", CoverageGroups)}");
}
if (!consumerLists.Any())
{
return(null);
}
return(string.Join(";", consumerLists));
}
private static void AssertBehaviorResults(TestVM vm, ExpectedResults results)
{
ValidationAssert.AreEqual(
results.Properties,
vm.GetResultFromBehavior(ValidationResultScope.PropertiesOnly)
);
ValidationAssert.AreEqual(
results.ViewModel,
vm.GetResultFromBehavior(ValidationResultScope.ViewModelValidationsOnly)
);
ValidationAssert.AreEqual(
results.Self,
vm.GetResultFromBehavior(ValidationResultScope.Self)
);
ValidationAssert.AreEqual(
results.Descenants,
vm.GetResultFromBehavior(ValidationResultScope.Descendants)
);
ValidationAssert.AreEqual(
results.All,
vm.GetResultFromBehavior(ValidationResultScope.All)
);
}
public void AddExpectedResultAsNeeded(string expectedResult)
{
if (!ExpectedResults.Contains(expectedResult))
{
ExpectedResults.Add(expectedResult);
}
}
/// <summary>
/// Removes the expression objects from parameters, equivalence classes, and expected results.
/// </summary>
private bool ClearExpressions()
{
bool compositeResult = true;
if ((InputParameters != null) && InputParameters.Any())
{
foreach (InputParameter parameter in InputParameters.Values)
{
parameter.ConditionExpression = null;
if ((parameter.EquivalenceClasses != null) && parameter.EquivalenceClasses.Any())
{
foreach (EquivalenceClass equivalenceClass in parameter.EquivalenceClasses.Values)
{
equivalenceClass.ConditionExpression = null;
}
}
}
}
if ((ExpectedResults != null) && ExpectedResults.Any())
{
foreach (ExpectedResult result in ExpectedResults.Values)
{
result.ConditionExpression = null;
}
}
return(compositeResult);
}
public override string ToString()
{
return(string.Join(Environment.NewLine, $"{{",
$"Update Time: {UpdatedTime}",
$"Expected Results:",
(ExpectedResults.Any() ? $"{string.Join(Environment.NewLine, ExpectedResults.Select(row => $"{{{string.Join(", ", row)}}}"))}" : "{}") +
$"}}"));
}
public bool DetermineFile()
#endif
{
if (ExpectedResults.Count == 0)
{
throw new Exception(ResourceHelper.GetString("NoExpectedResultsInQueueForUnitTest"));
}
return(ExpectedResults.Dequeue().Invoke());
}
public virtual void AddExpectedResult(ExpectedResult result)
{
if (result == null || ExpectedResults.Contains(result))
{
return;
}
ExpectedResults.Add(result);
result.ParentEffect = this;
OnChanged(new CMEntitiesEventArgs("ExpectedResults", null, result));
}
public virtual void RemoveExpectedResult(ExpectedResult result)
{
if (result == null || !ExpectedResults.Contains(result))
{
return;
}
ExpectedResults.Remove(result);
result.ParentEffect = null;
OnChanged(new CMEntitiesEventArgs("ExpectedResults", result, null));
}
public void TestStandardFizzBuzz()
{
//Arrange
int Length = 100;
FizzBuzzService fizzBuzz = new FizzBuzzService(Length);
//Act
var results = fizzBuzz.GetFizzBuzzResult();
//Assert
Assert.AreEqual(ExpectedResults.ToString(), results.ToString());
}
public void HandleChange_WithValidationResultChangedOfOwnViewModel_UpdatesCachedResults()
{
var vm = new TestVM();
var expected = new ExpectedResults {
ViewModel = CreateValidationResult("View model error")
};
vm.ViewModelResultSetup = expected.ViewModel;
vm.CallHandleChangeForViewModel();
AssertBehaviorResults(vm, expected);
}
public void HandleChange_WithValidationResultChangedOfOwnProperty_UpdatesCachedResults()
{
var vm = new TestVM();
var expected = new ExpectedResults {
Properties = CreateValidationResult("First property error")
};
vm.FirstPropertyResultSetup = expected.Properties;
vm.CallHandleChangeForFirstProperty();
AssertBehaviorResults(vm, expected);
}
public void ProcessInput(string line)
{
string[] items;
int i = TrainingData.Count;
TrainingData.Add(i, new List <int>(64));
items = line.Split(',');
for (int j = 0; j < 64; j++)
{
TrainingData[i].Add(int.Parse(items[j]));
}
ExpectedResults.Add(int.Parse(items[64]));
//Console.WriteLine(line);
}
public void TestBackwardsFizzBuzz()
{
//Arrange
int Length = 100;
bool Backwards = true;
string[] expected = ExpectedResults.Reverse().ToArray();
FizzBuzzService fizzBuzz = new FizzBuzzService(Length, false, false, Backwards);
//Act
var results = fizzBuzz.GetFizzBuzzResult();
//Assert
Assert.AreEqual(expected.ToString(), results.ToString());
}
/// <summary>
/// Validates the test specification and returns true if successful; otherwise false
/// and returns an informative error message.
/// </summary>
public bool Validate(IList <string> errors)
{
bool validated = true;
if ((InputParameters == null) || !InputParameters.Any())
{
errors.Add($"specification {Name} has no input parameters");
validated = false;
}
else
{
foreach (InputParameter parameter in InputParameters.Values)
{
validated = parameter.Validate(errors) && validated;
}
}
if ((ExpectedResults == null) || !ExpectedResults.Any())
{
errors.Add($"specification {Name} has no expected results");
validated = false;
}
else
{
foreach (ExpectedResult expectedResult in ExpectedResults.Values)
{
validated = expectedResult.Validate(errors) && validated;
}
}
if ((CoverageGroups == null) || !CoverageGroups.Any())
{
errors.Add($"specification {Name} has no coverage groups");
validated = false;
}
else
{
foreach (CoverageGroup coverageGroup in CoverageGroups)
{
validated = coverageGroup.Validate(errors) && validated;
}
}
return(validated && (errors.Count == 0));
}
public void HandleChange_UpdatesBehaviorOfParentViewModelBeforeCallingHandleChangeNext()
{
var child = new TestVM();
var parent = new TestVM();
child.FirstPropertyResultSetup = CreateValidationResult("Property error");
child.Kernel.Parents.Add(parent);
child.NextChangeHandler.HandleChangeNext += delegate {
// Assert parent was already updated
var expected = new ExpectedResults {
Descenants = child.FirstPropertyResultSetup
};
AssertBehaviorResults(parent, expected);
};
child.CallHandleChangeForFirstProperty();
}
private void Read(string path) //@"C:\Users\Serban\Pictures\LeafsVeins\maxPoints.txt"
{
string[] lines = File.ReadAllLines(path);
int categoriesCount = int.Parse(lines[0]);
var linesList = lines.ToList();
linesList.RemoveAt(0);
foreach (var line in linesList)
{
List <double> inputs = line
.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => double.Parse(s))
.ToList();
var category = (int)inputs[0];
inputs.RemoveAt(0);
ExpectedResults.Add(CreateExpectedResults(categoriesCount, category)); // should totally be read
InputValues.Add(inputs);
}
}
/// <summary>
/// Parses strings containing expressions into recursive expression objects; returns true if successful.
/// </summary>
private bool NormalizeExpressions()
{
bool compositeResult = true;
if ((InputParameters != null) && InputParameters.Any())
{
foreach (InputParameter parameter in InputParameters.Values)
{
if (!parameter.ParseConditions())
{
compositeResult = false;
}
if ((parameter.EquivalenceClasses != null) && parameter.EquivalenceClasses.Any())
{
foreach (EquivalenceClass equivalenceClass in parameter.EquivalenceClasses.Values)
{
if (!equivalenceClass.ParseConditions())
{
compositeResult = false;
}
}
}
}
}
if ((ExpectedResults != null) && ExpectedResults.Any())
{
foreach (ExpectedResult result in ExpectedResults.Values)
{
if (!result.ParseConditions())
{
compositeResult = false;
}
}
}
return(compositeResult);
}
public override string ToString()
{
//string parameters="", expectedResults="", finalResults="";
//foreach (var item in Parameters)
// parameters += item.ToString();
//foreach (var item in ExpectedResults)
// expectedResults += item.ToString();
//foreach (var item in FinalResults)
// finalResults += item.ToString();
return(string.Format("\nQuestion ID: {0}\nFileName: {1}\nQuestion Text: {2}\nParameters: {3}\nExpected Results {4}\nFinal Results: {5}", QuestionId, FileName, QuestionText, Parameters.ToString(), ExpectedResults.ToString(), FinalResults.ToString()));
}
/// <summary>
///
/// </summary>
/// <param name="solver"></param>
/// <param name="source"></param>
/// <param name="callback"></param>
/// <returns></returns>
protected bool TryResolve(CpSolver solver, CpModel source, TryResolveCallback callback)
{
var result = callback.Invoke(solver, source).FromSolver();
return(ExpectedResults.Contains(result));
}
public void CreateTestData(string path)
{
var noOfCategories = ExpectedResults[0].Count;
var itemsInCategory = 10;
for (int itemToRemove = 0; itemToRemove < itemsInCategory; itemToRemove++)
{
List <List <double> > expectedResults = new List <List <double> >();
List <List <double> > inputValues = new List <List <double> >();
for (int i = noOfCategories - 1; i >= 0; i--)
{
var index = i * itemsInCategory + itemToRemove;
try
{
inputValues.Add(InputValues[index]);
expectedResults.Add(ExpectedResults[index]);
InputValues.RemoveAt(index);
ExpectedResults.RemoveAt(index);
}
catch { }
}
var trainDataPath = path + "data" + itemToRemove + ".txt";
var trainDataAveragePath = path + "average" + itemToRemove + ".txt";
var testDataPath = path + "test" + itemToRemove + ".txt";
string dataToWrite = noOfCategories.ToString() + Environment.NewLine;
for (int i = 0; i < noOfCategories; i++)
{
var averages = new List <double>();
int averagesNo = 1;
averages = InputValues[i * itemsInCategory].ToList();
for (int itemInCategory = 1; itemInCategory < itemsInCategory; itemInCategory++)
{
var index = i * itemsInCategory + itemInCategory;
for (int x = 0; x < InputValues[0].Count; x++)
{
try
{
averages[x] += InputValues[index][x];
averagesNo++;
}
catch { }
}
}
averages = averages.Select(average => average / averagesNo).ToList();
dataToWrite += GetExpectedCategory(ExpectedResults[i * itemsInCategory + 2]) +
" " +
string.Join(" ", string.Join(" ", averages)) +
Environment.NewLine;
}
File.AppendAllText(trainDataAveragePath, dataToWrite);
dataToWrite = noOfCategories.ToString() + Environment.NewLine;
for (int itemIndex = 0; itemIndex < InputValues.Count; itemIndex++)
{
dataToWrite +=
GetExpectedCategory(ExpectedResults[itemIndex]) +
" " +
string.Join(" ", InputValues[itemIndex]) +
Environment.NewLine;
}
File.AppendAllText(trainDataPath, dataToWrite);
dataToWrite = noOfCategories + Environment.NewLine;
for (int itemIndex = 0; itemIndex < inputValues.Count; itemIndex++)
{
dataToWrite +=
GetExpectedCategory(expectedResults[itemIndex]) +
" " +
string.Join(" ", inputValues[itemIndex]) +
Environment.NewLine;
}
File.AppendAllText(testDataPath, dataToWrite);
for (int i = 0; i < noOfCategories; i++)
{
var index = i * itemsInCategory + itemToRemove;
try
{
inputValues.Add(InputValues[index]);
expectedResults.Add(ExpectedResults[index]);
InputValues.Insert(index, inputValues.Last());
ExpectedResults.Insert(index, expectedResults.Last());
inputValues.RemoveAt(inputValues.Count - 1);
expectedResults.RemoveAt(expectedResults.Count - 1);
}
catch { }
}
}
}
