public List <ActivityTest> AcvityLint()
{
//make sure logictest was run
var runLogicTests = this.LogicLint();
/*for each root activity
* need to get all equations involved
* merge those test cases from top down without adding duplicates on EvaluatorID|context
* example
* if (a & b) -> X ->
* if !a & c -> y
* result should be
* a, b, c (not a,!a,b,c)
*
*/
List <ActivityTest> toReturn = new List <ActivityTest>();
string rootName = this.WorkflowManager.RootActivityId;
Activity rootActivity = this.WorkflowManager.GetActivity(rootName);
List <string> equationsWithCases = new List <string>();
equationsWithCases = (from z in logicTests where z.TestCases.Count > 0 select z.EquationId).ToList();
List <List <string> > cases = new List <List <string> >();
foreach (string eq in equationsWithCases)
{
LogicTest eqTest = logicTests.First(g => g.EquationId == eq);
List <List <string> > thisRun = new List <List <string> >();
foreach (Case testCase in eqTest.TestCases)
{
List <string> ruleCases = (from g in testCase.Rules select g.ToString()).ToList();
if (cases.Count == 0)
{
thisRun.Add(ruleCases);
}
else
{
foreach (List <string> lastRun in cases)
{
List <string> copyOfLastRun = (from s in lastRun select s).ToList();
//whittle out any dupes where id and context match.
List <string> justIdsFromLastRun = (from s in lastRun select((Rule)s).RuleIdWithContext).ToList();
List <string> deduped = (from s in ruleCases where !justIdsFromLastRun.Contains(((Rule)s).RuleIdWithContext) select s).ToList();
List <string> thisCase = copyOfLastRun;
if (deduped.Count > 0)
{
thisCase = copyOfLastRun.Union(deduped).ToList();
thisRun.Add(thisCase);
}
}
}
}
if (thisRun.Count > 0)
{
cases = thisRun;
}
}
List <Case> testCases = (from z in cases select new Case((from x in z select(Rule) x).ToList())).ToList();
ActivityTest toAdd = new ActivityTest(rootName)
{
TestCases = testCases
};
toReturn.Add(toAdd);
int counter = 0;
toReturn.ForEach(t =>
{
t.TestCases.ForEach(c => { counter++; c.Id = counter; });
});
return(toReturn);
}
public List <LogicTest> LogicLint()
{
int id = 1;
Func <int> newId = () =>
{
return(id += 1);
};
List <bool> tf = new List <bool>()
{
true, false
};
Func <Equation, List <Rule> > getAllRulesForEquation = null;
getAllRulesForEquation = (eq) =>
{
List <Rule> rules = new List <Rule>();
//left hand side of equation
if (ConventionHelper.MatchesConvention(NamePrefixOptions.Equation, eq.First.Id, this.configuration.Convention))
{
Equation traverse = this.WorkflowManager.GetEquation(eq.First.Id);
List <Rule> parsed = getAllRulesForEquation(traverse);
rules = rules.Union(parsed, new RuleEqualityComparer()).ToList();
}
else
{
if (!rules.Contains(eq.First, new RuleEqualityComparer()))
{
rules.Add((Rule)eq.First.Clone());
}
}
if (ConventionHelper.MatchesConvention(NamePrefixOptions.Equation, eq.Second.Id, this.configuration.Convention))
{
Equation traverse = this.WorkflowManager.GetEquation(eq.Second.Id);
List <Rule> parsed = getAllRulesForEquation(traverse);
rules = rules.Union(parsed, new RuleEqualityComparer()).ToList();
}
else
{
if (!rules.Contains(eq.Second, new RuleEqualityComparer()))
{
rules.Add((Rule)eq.Second.Clone());
}
}
string trueId = ConventionHelper.TrueEvaluator(this.configuration.Convention);
return((from r in rules where r.Id != trueId select r).ToList());
};
Func <Stack <List <Case> >, List <Case> > mergeCases = null;
mergeCases = (llc) =>
{
List <Case> merged = llc.Pop();
if (llc.Count > 0)
{
List <Case> toMerge = mergeCases(llc);
List <Case> newMerge = new List <Case>();
merged.ForEach(m =>
{
toMerge.ForEach(g =>
{
List <Rule> newCaseRules = new List <Rule>(from r in m.Rules select(Rule) r.Clone());
newCaseRules.AddRange(from r in g.Rules select(Rule) r.Clone());
Case newCase = new Case(newCaseRules);
newMerge.Add(newCase);
});
});
merged = newMerge;
}
return(merged);
};
if (this.logicTests == default)
{
this.logicTests = new List <LogicTest>();
//get the root
foreach (string rootEquationId in this.roots)
{
Stack <List <Case> > preMerge = new Stack <List <Case> >();
Equation root = this.WorkflowManager.GetEquation(rootEquationId);
List <Rule> evalRules = getAllRulesForEquation(root);
foreach (Rule evalRule in evalRules)
{
List <Case> evalRuleCases = new List <Case>();
if (evalRule.Context == null)
{
evalRuleCases.AddRange(from c in tf
select new Case(new List <Rule>()
{
new Rule()
{
Context = evalRule.Context,
Id = evalRule.Id,
TrueCondition = c
}
}));
}
else
{
Stack <List <Case> > contextCases = new Stack <List <Case> >();
evalRule.Context.Keys.ForEach(k =>
{
List <Case> cases = new List <Case>();
cases.AddRange(from c in tf
select new Case(new List <Rule>()
{
new Rule()
{
Context = new Context(new List <string>()
{
k
}, evalRule.Context.Name),
Id = evalRule.Id,
TrueCondition = c
}
}));
contextCases.Push(cases);
evalRuleCases = mergeCases(contextCases);
contextCases.Push(evalRuleCases);
});
var contextDef = this.WorkflowManager.GetContextDefinition(evalRule.Context.Name);
if (contextDef.Validate == ValidateOptions.OneOf)
{
evalRuleCases.RemoveAll(c => c.Rules.Count(r => r.TrueCondition) != 1 && c.Rules.Any(r => r.TrueCondition));
}
if (contextDef.Exclusive)
{
evalRuleCases.RemoveAll(c => c.Rules.Count(r => !r.TrueCondition) == c.Rules.Count() && c.Rules.Count == contextDef.Items.Count);
}
}
preMerge.Push(evalRuleCases);
}
List <Case> finalCases = mergeCases(preMerge);
LogicTest eqTest = new LogicTest(rootEquationId, true)
{
TestCases = finalCases
};
this.logicTests.Add(eqTest);
}
}
return(this.logicTests);
}
