public void Test_CheckForCircularReferences_False()
{
TestTask task1 = new TestTask();
task1.Title = "Task1";
TestTask task2 = new TestTask();
task2.Title = "Task2";
TestTask task3 = new TestTask();
task3.Title = "Task3";
//task1.Prerequisites = new TestTask[] {task3};
//task2.Prerequisites = new TestTask[] {task1};
//task3.Prerequisites = new TestTask[] {task2};
TestTask[] tasks = new TestTask[] { task1, task2, task3 };
ReferenceValidator validator = new ReferenceValidator();
bool isCircularReference = validator.ContainsCircularReference <TestTask>(tasks);
Assert.IsFalse(isCircularReference, "Indicated a circular reference when there isn't one.");
}
public void ReferencesAreValid()
{
var parsingData = Program.CreateParsingData();
var referencedMatchers = parsingData.ReferencedMatchers;
var statMatchers = parsingData.StatMatchers;
Assert.DoesNotThrow(() => ReferenceValidator.Validate(referencedMatchers, statMatchers));
}
protected TR CheckReferenceNotNull <TR>(TR reference, string errorKey)
{
if (!ReferenceValidator.ValidateReferenceIsNotNull(reference))
{
throw CreateEntityReferenceNullException(errorKey);
}
return(reference);
}
public void ReferencesAreValid()
{
var parsingData = new CompositionRoot().ParsingData;
var referencedMatchers = parsingData.ReferencedMatchers;
var statMatchers = parsingData.StatMatchers;
Assert.DoesNotThrow(() => ReferenceValidator.Validate(referencedMatchers, statMatchers));
}
public async Task ReferencesAreValid()
{
var parsingData = await ParsingDataTask;
var referencedMatchers = parsingData.ReferencedMatchers;
var statMatchers = parsingData.StatMatchers;
Assert.DoesNotThrow(() => ReferenceValidator.Validate(referencedMatchers, statMatchers));
}
public void ValidateDoesNotThrowIfStatMatchersWithoutReferenceNamesContainsValues()
{
var statMatchersList = new[]
{
MockStatMatchers(new string[0], "#")
};
Assert.DoesNotThrow(() =>
ReferenceValidator.Validate(DefaultReferencedMatchersList, statMatchersList));
}
public void ValidateThrowsIfStatMatchersWithReferenceNamesContainsValues()
{
var statMatchersList = new[]
{
MockStatMatchers(new[] { "SMatchers1" }, "#")
};
Assert.Throws <ParseException>(() =>
ReferenceValidator.Validate(DefaultReferencedMatchersList, statMatchersList));
}
public void ValidateThrowsIfReferenceNameIsUsedInReferencedMatchersAndStatMatchers()
{
var referencedMatchersList = new[]
{
MockReferencedMatchers("SMatchers1", "b"),
};
Assert.Throws <ParseException>(() =>
ReferenceValidator.Validate(referencedMatchersList, DefaultStatMatchersList));
}
public void ValidateThrowsIfReferencedMatcherContainsInvalidGroupNames(string groupName)
{
var referencedMatchersList = new[]
{
MockReferencedMatchers("Matchers1", $"text (?<{groupName}>stuff)")
};
Assert.Throws <ParseException>(() =>
ReferenceValidator.Validate(referencedMatchersList, DefaultStatMatchersList));
}
public void ValidateThrowsIfStatMatcherContainsUnknownReferences()
{
var statMatchersList = new[]
{
MockStatMatchers(new[] { "SMatchers1" }, "({SMatchers2})")
};
Assert.Throws <ParseException>(() =>
ReferenceValidator.Validate(DefaultReferencedMatchersList, statMatchersList));
}
public void ValidateThrowsIfReferencedMatchersContainsValues()
{
var referencedMatchersList = new[]
{
MockReferencedMatchers("Matchers1", "text # stuff"),
};
Assert.Throws <ParseException>(() =>
ReferenceValidator.Validate(referencedMatchersList, DefaultStatMatchersList));
}
public void ValidateDoesNotThrowIfStatMatchersNamesAreNotUnique()
{
var statMatchersList = new[]
{
MockStatMatchers(new[] { "SMatchers1" }),
MockStatMatchers(new[] { "SMatchers1" })
};
Assert.DoesNotThrow(() =>
ReferenceValidator.Validate(DefaultReferencedMatchersList, statMatchersList));
}
public void ValidateThrowsIfReferencedMatchersNamesAreNotUnique()
{
var referencedMatchersList = new[]
{
MockReferencedMatchers("Matchers1", "b"),
MockReferencedMatchers("Matchers1", "a"),
};
Assert.Throws <ParseException>(() =>
ReferenceValidator.Validate(referencedMatchersList, DefaultStatMatchersList));
}
public void ValidateDoesNotThrowIfStatMatchersContainReferences()
{
var statMatchersList = new[]
{
MockStatMatchers(new[] { "SMatchers1" }, "({SMatchers2})"),
MockStatMatchers(new[] { "SMatchers2" }, "({Matchers1})"),
};
Assert.DoesNotThrow(() =>
ReferenceValidator.Validate(DefaultReferencedMatchersList, statMatchersList));
}
public void ValidateThrowsIfStatMatchersContainCyclicalReferencesComplex()
{
var statMatchersList = new[]
{
MockStatMatchers(new[] { "SMatchers1" }, "({SMatchers2}) ({SMatchers2})"),
MockStatMatchers(new[] { "SMatchers2" }, "({SMatchers5})"),
MockStatMatchers(new[] { "SMatchers2" }, "({SMatchers3}) ({SMatchers4}) ({Matchers2})"),
MockStatMatchers(new[] { "SMatchers3", "SMatchers4" }, "({Matchers2})"),
MockStatMatchers(new[] { "SMatchers4" }, "({Matchers1}) ({SMatchers1})"),
MockStatMatchers(new[] { "SMatchers5" }, "({Matchers1})"),
};
Assert.Throws <ParseException>(() =>
ReferenceValidator.Validate(DefaultReferencedMatchersList, statMatchersList));
}
private void root_AttributeChanged(object sender, AttributeEventArgs e)
{
ItemChanged.Raise(this, new ItemChangedEventArgs <object>(e.DomNode));
// because references use the name of the referenced item as their label, we should
// update all references to this DomNode. Fortunately, we can use the ReferenceValidator
// which is attached to this (root) node to get all the references.
if (e.AttributeInfo.Equivalent(UISchema.UIObjectType.nameAttribute))
{
ReferenceValidator validator = this.As <ReferenceValidator>();
//foreach (Pair<DomNode, AttributeInfo> reference in validator.GetReferences(e.DomNode))
//{
// if ((reference.First.Type == UISchema.UIRefType.Type) &&
// (reference.Second.Equivalent(UISchema.UIRefType.refAttribute)))
// {
// ItemChanged.Raise(this, new ItemChangedEventArgs<object>(reference.First));
// }
//}
}
}
public void Test_CheckForCircularReferences_True()
{
TestTask task1 = new TestTask();
task1.Title = "Task1";
TestTask task2 = new TestTask();
task2.Title = "Task2";
TestTask task3 = new TestTask();
task3.Title = "Task3";
task1.Prerequisites = new TestTask[] {task3};
task2.Prerequisites = new TestTask[] {task1};
task3.Prerequisites = new TestTask[] {task2};
TestTask[] tasks = new TestTask[]{task1, task2, task3};
ReferenceValidator validator = new ReferenceValidator();
bool isCircularReference = validator.ContainsCircularReference<TestTask>(tasks);
Assert.IsTrue(isCircularReference, "Failed to indicate a circular reference when there is one.");
}
public Results Conclude()
{
var trashValidator = new TrashValidator();
var trashResult = trashValidator.Validate(_questions);
if (trashResult.IsValid)
{
return(Results.Trash);
}
var referenceValidator = new ReferenceValidator();
var referenceResult = referenceValidator.Validate(_questions);
if (referenceResult.IsValid)
{
return(Results.Reference);
}
var maybeValidator = new MaybeValidator();
var maybeResult = maybeValidator.Validate(_questions);
if (maybeResult.IsValid)
{
return(Results.MaybeLater);
}
var projectsValidator = new ProjectsValidator();
var projectsResult = projectsValidator.Validate(_questions);
if (projectsResult.IsValid)
{
return(Results.Projects);
}
var nowValidator = new NowValidator();
var nowResult = nowValidator.Validate(_questions);
if (nowResult.IsValid)
{
return(Results.DoItNow);
}
var rightPersonValidator = new RightPersonValidator();
var rightPersonResult = rightPersonValidator.Validate(_questions);
if (rightPersonResult.IsValid)
{
return(Results.Delegate);
}
var calendarValidator = new CalendarValidator();
var calendarResult = calendarValidator.Validate(_questions);
if (calendarResult.IsValid)
{
return(Results.Calendar);
}
var nextActionValidator = new NextActionValidator();
var nextActionResult = nextActionValidator.Validate(_questions);
if (nextActionResult.IsValid)
{
return(Results.NextAction);
}
return(Results.None);
}
