public void RedundantRemoverWithNestedAndNoRemoval()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = false };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = true };
var activityD = new Activity("D", "somename4") { Included = false };
var activityE = new Activity("E", "somename5") { Included = false };
var activityF = new Activity("F", "somename6") { Included = true };
dcrGraph.AddActivities(activityA,activityB,activityC,activityD,activityE,activityF);
dcrGraph.AddIncludeExclude(true, activityC.Id, activityD.Id);
dcrGraph.AddIncludeExclude(true, activityC.Id, activityE.Id); //non-Redundant include
dcrGraph.AddCondition(activityE.Id, activityF.Id); //outgoing relation
//ingoing relation
dcrGraph.AddCondition(activityA.Id, activityC.Id);
dcrGraph.AddCondition(activityA.Id, activityD.Id);
dcrGraph.AddCondition(activityA.Id, activityE.Id);
dcrGraph.MakeNestedGraph(new HashSet<Activity>() { activityC, activityD, activityE });
var newGraph = new RedundancyRemover().RemoveRedundancy(dcrGraph);
//we check that the Nested graph has not removed a relation.
Assert.IsTrue(newGraph.InRelation(activityE, newGraph.IncludeExcludes));
}
public void GetGeneralizationTest()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true, Pending = true };
var activityB = new Activity("B", "somename2") { Included = false };
var activityC = new Activity("C", "somename3") { Included = false };
dcrGraph.AddActivities(activityA, activityB, activityC);
dcrGraph.AddIncludeExclude(true, activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(true, activityB.Id, activityC.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityA.Id);
dcrGraph.AddIncludeExclude(false, activityB.Id, activityB.Id);
var log = new Log();
log.AddTrace(new LogTrace('A', 'B'));
log.AddTrace(new LogTrace('A', 'B', 'C'));
log.AddTrace(new LogTrace('A', 'B', 'C')); //duplicate trace should not matter
log.AddTrace(new LogTrace('A', 'B', 'C', 'A')); //illegal execution should count down
log.AddTrace(new LogTrace('A', 'B', 'C', 'A', 'A')); //this one should not matter, as we've already seen A been illegally executed from this state.
var log2 = new Log();
log2.AddTrace(new LogTrace('A', 'B'));
var qd1 = QualityDimensionRetriever.Retrieve(dcrGraph, log);
var qd2 = QualityDimensionRetriever.Retrieve(dcrGraph, log2);
Assert.IsTrue(qd1.Generality > qd2.Generality);
}
public void CopyNestedTest()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = true };
var activityD = new Activity("D", "somename4") { Included = false };
var activityE = new Activity("E", "somename5") { Included = true };
var activityF = new Activity("F", "somename6") { Included = true };
dcrGraph.AddActivity(activityC.Id, activityC.Name);
dcrGraph.AddActivity(activityD.Id, activityD.Name);
dcrGraph.AddActivity(activityE.Id, activityE.Name);
dcrGraph.AddIncludeExclude(true, activityC.Id, activityD.Id);
dcrGraph.AddActivity(activityA.Id, activityA.Name);
dcrGraph.AddActivity(activityB.Id, activityB.Name);
dcrGraph.AddActivity(activityF.Id, activityF.Name);
dcrGraph.AddCondition(activityE.Id, activityF.Id); //outgoing relation
//ingoing relations
dcrGraph.AddCondition(activityA.Id, activityC.Id);
dcrGraph.AddCondition(activityA.Id, activityD.Id);
dcrGraph.AddCondition(activityA.Id, activityE.Id);
dcrGraph.MakeNestedGraph(new HashSet<Activity>() { activityC, activityD, activityE });
var copy = dcrGraph.Copy();
Assert.AreEqual(dcrGraph.ToString(), copy.ToString());
}
private void StoreCurrentGraph()
{
var dcrGraph = new DcrGraph(DcrText.Text, _dcrGraph.StrictActivities, DcrText.Text, Model.CurrentGraphName);
dcrGraph.StoredTraces = Model.Traces.ToList();
Model.StoredDcrGraphs[Model.StoredDcrGraphs.IndexOf(Model.StoredDcrGraphs.First(x => x.Name.Equals(Model.CurrentGraphName)))].DcrGraph = dcrGraph;
}
public void FitnessOnNestedGraph()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = true };
var activityD = new Activity("D", "somename4") { Included = false };
var activityE = new Activity("E", "somename5") { Included = true };
var activityF = new Activity("F", "somename6") { Included = true };
dcrGraph.AddActivities(activityA,activityB,activityC,activityD,activityE,activityF);
dcrGraph.AddIncludeExclude(true, activityC.Id, activityD.Id);
dcrGraph.AddCondition(activityE.Id, activityF.Id); //outgoing relation
//ingoing relations
dcrGraph.AddCondition(activityA.Id, activityC.Id);
dcrGraph.AddCondition(activityA.Id, activityD.Id);
dcrGraph.AddCondition(activityA.Id, activityE.Id);
dcrGraph.MakeNestedGraph(new HashSet<Activity>() { activityC, activityD, activityE });
var log = new Log();
log.AddTrace(new LogTrace('A', 'C','D'));
log.AddTrace(new LogTrace('A', 'B', 'C'));
log.AddTrace(new LogTrace('A', 'E', 'F'));
log.AddTrace(new LogTrace('C', 'E','D')); //illegal trace should count down
//expecting fitness = 75%
var qd = UlrikHovsgaardAlgorithm.QualityMeasures.QualityDimensionRetriever.Retrieve(dcrGraph, log);
Assert.AreEqual(75d, qd.Fitness);
}
private static void ParseActivities(DcrGraph graph, XDocument doc)
{
IEnumerable<XElement> events = doc.Descendants("event").Where(element => element.HasElements); //Only takes event elements in events!
foreach (var eve in events)
{
ParseActivity(graph, doc, eve);
}
}
public static Dictionary<byte[], int> GetUniqueStatesWithRunnableActivityCount(DcrGraph inputGraph)
{
// Start from scratch
_seenStates = new List<DcrGraph>();
_seenStatesWithRunnableActivityCount = new Dictionary<byte[], int>(new ByteArrayComparer());
FindUniqueStatesInclRunnableActivityCountDepthFirstBytes(new ByteDcrGraph(inputGraph));
return _seenStatesWithRunnableActivityCount;
}
public LogGenerator9001(int terminationIndex, DcrGraph inputGraph)
{
if (terminationIndex < 10)
{
terminationIndex = 10;
}
_terminationIndex = terminationIndex;
_inputGraph = inputGraph;
_rnd = new Random();
}
public static DcrGraph ParseDcrGraph(string xml)
{
XDocument doc = XDocument.Parse(xml);
var graph = new DcrGraph {Title = ParseGraphTitle(doc)};
ParseActivities(graph, doc);
ParseRelations(graph, doc);
return graph;
}
public void GetActivityTest()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true, Pending = true };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = false };
dcrGraph.AddActivities(activityA, activityB, activityC);
var retrievedActivity = dcrGraph.GetActivity(activityB.Id);
Assert.AreSame(activityB, retrievedActivity);
}
private void LoadNewGraph(string dcrGraphName)
{
StoreCurrentGraph();
var dcrGraph = Model.StoredDcrGraphs.FirstOrDefault(x => x.Name.Equals(dcrGraphName))?.DcrGraph ??
_dcrGraph;
Model.CurrentGraphName = dcrGraph.Name;
Model.Traces.Clear();
Model.Traces = new ObservableCollection <Trace>(dcrGraph.StoredTraces);
DcrText.Text = dcrGraph.EditWindowString;
_dcrGraph = dcrGraph;
RebuildDcr(DcrText.Text, DcrText.Text);
TestAll();
}
// Data
//...
public static QualityDimensions Retrieve(DcrGraph inputGraph, Log inputLog)
{
_inputGraph = inputGraph;
_inputLog = inputLog;
var result = new QualityDimensions
{
Fitness = GetFitness(),
Simplicity = _newMeasures ? GetSimplicityNew() : GetSimplicity(),
Precision = _newMeasures ? GetPrecisionNew() : GetPrecision(null),
Generality = GetGenerality()
};
return result;
}
private String RunRandomActivity(HashSet<Activity> set, DcrGraph graph)
{
var next = _rnd.Next(set.Count);
var i = 0;
foreach (var act in set)
{
if (i++ != next) continue;
graph.Execute(act);
return act.Id;
}
return "";
}
public void RetrieveImageWithResponseRelationTest()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true };
var activityB = new Activity("B", "somename2") { Included = false };
dcrGraph.AddActivities(activityA, activityB);
dcrGraph.AddResponse(activityA.Id, activityB.Id);
var img = GraphImageRetriever.Retrieve(dcrGraph).Result;
Assert.IsNotNull(img);
}
public static QualityDimensions Retrieve(DcrGraph inputGraph, Log inputLog,
Dictionary<byte[], int> uniqueStatesWithRunnableActivityCount)
{
_inputGraph = inputGraph;
_inputLog = inputLog;
var result = new QualityDimensions
{
Fitness = GetFitness(),
Simplicity = _newMeasures ? GetSimplicityNew() : GetSimplicity(),
Precision = _newMeasures ? GetPrecisionNew() : GetPrecision(uniqueStatesWithRunnableActivityCount),
Generality = GetGenerality()
};
return result;
}
public TraceWindow(Trace trace, DcrGraph dcrGraph)
{
InitializeComponent();
DcrGraph = dcrGraph;
Model = new TraceWindowModel(trace);
this.DataContext = Model;
this.Title = Model.Trace.Name;
var res = "";
foreach (var activity in Model.Trace.ActivitySequence)
{
res += "\"" + activity + "\" ";
}
this.TraceSequenceText.Text = res;
ContextStrictness.IsChecked = Model.Trace.Context.Strict;
TrackAccepeting.IsChecked = Model.Trace.TrackAccepting;
}
public void CopyTest()
{
DcrGraph dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true, Pending = true };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = false };
dcrGraph.AddActivities(activityA, activityB, activityC);
dcrGraph.AddIncludeExclude(true, activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(true, activityB.Id, activityC.Id);
var copy = dcrGraph.Copy();
Assert.AreEqual(dcrGraph.ToString(), copy.ToString());
}
public static async Task<DrawingImage> Retrieve(DcrGraph graph)
{
var body = "src=" + graph.ExportToXml();
var tempFilePath = Path.Combine(Path.GetTempPath(), "SaveFile.svg");
using (WebClient wc = new WebClient())
{
wc.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
//var encodedBody = SharpVectors.HttpUtility.UrlEncode(body);
//if (encodedBody == null)
//{
// return null;
//}
var encodedBody = Regex.Replace(body, @"[^\w\s<>/""=]", "");
//var encodedBody = body.Replace(" & ", "and"); // TODO: Replace all illegal characters...?
if (encodedBody.Contains("_")) encodedBody = encodedBody.Replace("_", "");
var result = await wc.UploadStringTaskAsync("http://dcr.itu.dk:8023/trace/dcr", encodedBody);
//TODO: don't save it as a file
System.IO.File.WriteAllText(tempFilePath, result);
}
//conversion options
WpfDrawingSettings settings = new WpfDrawingSettings();
settings.IncludeRuntime = true;
settings.TextAsGeometry = true;
FileSvgReader converter = new FileSvgReader(settings);
var xamlFile = converter.Read(tempFilePath);
return new DrawingImage(xamlFile);
}
private void AddGraph_Click(object sender, RoutedEventArgs e)
{
string name = "";
do
{
name = PromptDialog.Prompt("Name your new dcrgraph", "Confirm");
if (name == null)
{
return;
}
} while (Model.StoredDcrGraphs.Any(x => x.Name.Equals(name)));
var dcrGraph = new DcrGraph("\"A new graph\"", null, "\"A new graph\"", name);
Model.StoredDcrGraphs.Add(new DcrGraphContainer()
{
DcrGraph = dcrGraph, Name = name
});
LoadNewGraph(dcrGraph.Name);
}
public void RedundancyTestCase7()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = false, Pending = true };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = true };
dcrGraph.Activities.Add(activityA);
dcrGraph.Activities.Add(activityB);
dcrGraph.Activities.Add(activityC);
dcrGraph.AddResponse(activityB.Id, activityA.Id);
dcrGraph.AddIncludeExclude(true, activityC.Id, activityA.Id);
dcrGraph.AddIncludeExclude(true, activityB.Id, activityA.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityB.Id);
var newGraph = new RedundancyRemover().RemoveRedundancy(dcrGraph);
//Now either the redundant response relation or A's initial pending state should be removed:");
Assert.IsFalse(newGraph.InRelation(activityA, newGraph.Responses) && newGraph.GetActivity(activityA.Id).Pending);
}
public void CreateNestsTest()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true, Pending = true };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = true };
var activityD = new Activity("D", "somename4") { Included = true };
var activityE = new Activity("E", "somename5") { Included = true, Pending = true };
var activityF = new Activity("F", "somename6") { Included = true };
var activityG = new Activity("G", "somename7") { Included = true };
dcrGraph.AddActivities(activityA, activityB, activityC, activityD, activityE, activityF, activityG);
dcrGraph.AddResponse(activityB.Id, activityC.Id); //inner nest condition
//From A to all inner
dcrGraph.AddIncludeExclude(false, activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityC.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityD.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityE.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(false, activityD.Id, activityF.Id); //from in to out
dcrGraph.AddMileStone(activityF.Id, activityG.Id);
//From G to all inner and F
dcrGraph.AddCondition(activityG.Id, activityB.Id);
dcrGraph.AddCondition(activityG.Id, activityC.Id);
dcrGraph.AddCondition(activityG.Id, activityD.Id);
dcrGraph.AddCondition(activityG.Id, activityE.Id);
dcrGraph.AddCondition(activityG.Id, activityF.Id);
var exhaust = new ContradictionApproach(dcrGraph.Activities) { Graph = dcrGraph };
exhaust.Graph = ContradictionApproach.CreateNests(exhaust.Graph);
Assert.IsTrue(exhaust.Graph.Activities.Any(a => a.IsNestedGraph));
}
private async void RebuildDcr(string rawDcr, string editWindowString, string name = "Full merge graph", bool buildInMemoryDcr = true)
{
var dcrGraph = _dcrGraph;
try
{
var svg = await DcrToSvg.GetSvgFromDcr(rawDcr);
var settings = new WpfDrawingSettings
{
IncludeRuntime = true,
TextAsGeometry = true,
OptimizePath = true
};
var converter = new FileSvgReader(settings);
var drawingGroup = converter.Read(new MemoryStream(Encoding.UTF8.GetBytes(svg)));
Model.DcrImage = new DrawingImage(drawingGroup);
if (buildInMemoryDcr)
{
dcrGraph = new DcrGraph(rawDcr, dcrGraph?.StrictActivities, editWindowString, name);
}
}
catch (Exception e)
{
return;
}
_dcrGraph = dcrGraph;
//Used if need to be able to execute
//Model.Events.Clear();
//foreach (var activity in _dcrGraph.GetExecutableActivityNames())
//{
// Model.Events.Add(activity);
//}
}
private static void FindUniqueStatesInclRunnableActivityCount(DcrGraph inputGraph)
{
Counter++;
var activitiesToRun = inputGraph.GetRunnableActivities();
var iterations = new List<DcrGraph>();
_seenStates.Add(inputGraph);
var hashed = DcrGraph.HashDcrGraph(inputGraph);
if (! _seenStatesWithRunnableActivityCount.ContainsKey(hashed))
{
_seenStatesWithRunnableActivityCount.Add(hashed, activitiesToRun.Select(x => x.Id).ToList().Count);
}
foreach (var activity in activitiesToRun)
{
// Spawn new work
var inputGraphCopy = inputGraph.Copy();
inputGraphCopy.Running = true;
inputGraphCopy.Execute(inputGraphCopy.GetActivity(activity.Id));
var stateSeen = _seenStates.Any(seenState => seenState.AreInEqualState(inputGraphCopy));
if (!stateSeen)
{
// Register wish to continue
iterations.Add(inputGraphCopy);
}
}
// For each case where we want to go deeper, recurse
foreach (var unseenState in iterations)
{
FindUniqueStatesInclRunnableActivityCount(unseenState);
}
}
private static void FindUniqueStatesInclRunnableActivityCountDepthFirst(DcrGraph inputGraph)
{
Counter++;
var activitiesToRun = inputGraph.GetRunnableActivities();
var hashed = DcrGraph.HashDcrGraph(inputGraph);
_seenStatesWithRunnableActivityCount.Add(hashed, activitiesToRun.Select(x => x.Id).ToList().Count);
foreach (var activity in activitiesToRun)
{
// Spawn new work
var inputGraphCopy = inputGraph.Copy();
inputGraphCopy.Running = true;
inputGraphCopy.Execute(inputGraphCopy.GetActivity(activity.Id));
var stateSeen = _seenStatesWithRunnableActivityCount.ContainsKey(DcrGraph.HashDcrGraph(inputGraphCopy));
if (!stateSeen)
{
// Register wish to continue
FindUniqueStatesInclRunnableActivityCountDepthFirst(inputGraphCopy);
}
}
}
private static Activity ParseActivity(DcrGraph graph, XDocument doc, XElement eve)
{
var nestedEvents = eve.Descendants("event").Where(element => element.HasElements).ToList(); //Only takes event elements in events!
bool isNestedGraph = nestedEvents.Count > 0;
// Retrieve Id
var id = eve.Attribute("id").Value;
// Retrieve Name:
var name = (from labelMapping in doc.Descendants("labelMapping")
where labelMapping.Attribute("eventId").Value.Equals(id)
select labelMapping.Attribute("labelId").Value).FirstOrDefault();
// Check to see if Activity was already parsed
if (graph.GetActivities().ToList().Exists(x => x.Id == id && x.Name == name)) return null;
Activity activityToReturn;
if (isNestedGraph)
{
var nestedActivities = new HashSet<Activity>();
foreach (var nestedEvent in nestedEvents)
{
nestedActivities.Add(ParseActivity(graph, doc, nestedEvent));
}
activityToReturn = graph.MakeNestedGraph(id, name, nestedActivities);
}
else // Not a nested graph --> Treat as single activity
{
// Add activity to graph
activityToReturn = graph.AddActivity(id, name);
// Assigning Roles:
var roles = eve.Descendants("role");
var rolesList = new List<string>();
foreach (var role in roles)
{
if (role.Value != "") graph.AddRolesToActivity(id,role.Value);
}
// Mark Included
if ((from includedEvent in doc.Descendants("included").Elements()
select includedEvent.FirstAttribute.Value).Contains(id)) graph.SetIncluded(true, id);
// Mark Pending:
if ((from pendingEvent in doc.Descendants("pendingResponses").Elements()
select pendingEvent.FirstAttribute.Value).Contains(id)) graph.SetPending(true, id);
// Mark Executed:
if ((from executedEvent in doc.Descendants("executed").Elements()
select executedEvent.FirstAttribute.Value).Contains(id)) graph.SetExecuted(true, id);
}
return activityToReturn;
}
private static void ParseRelations(DcrGraph graph, XDocument doc)
{
foreach (var condition in doc.Descendants("conditions").Elements())
{
graph.AddCondition(condition.Attribute("sourceId").Value, condition.Attribute("targetId").Value);
}
foreach (var condition in doc.Descendants("responses").Elements())
{
graph.AddResponse(condition.Attribute("sourceId").Value, condition.Attribute("targetId").Value);
}
foreach (var condition in doc.Descendants("excludes").Elements())
{
graph.AddIncludeExclude(false, condition.Attribute("sourceId").Value, condition.Attribute("targetId").Value);
}
foreach (var condition in doc.Descendants("includes").Elements())
{
graph.AddIncludeExclude(true, condition.Attribute("sourceId").Value, condition.Attribute("targetId").Value);
}
foreach (var condition in doc.Descendants("milestones").Elements())
{
graph.AddMileStone(condition.Attribute("sourceId").Value, condition.Attribute("targetId").Value);
}
}
public void TestActivityAlwaysExcludedRedundant()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = false };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = true };
dcrGraph.Activities.Add(activityA);
dcrGraph.Activities.Add(activityB);
dcrGraph.Activities.Add(activityC);
dcrGraph.AddCondition(activityA.Id, activityB.Id);
dcrGraph.AddMileStone(activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityC.Id);
dcrGraph.AddResponse(activityA.Id, activityB.Id);
dcrGraph.AddResponse(activityB.Id, activityA.Id);
var newGraph = new RedundancyRemover().RemoveRedundancy(dcrGraph);
//Now all the relations from or to A should be removed:");
Assert.IsTrue(!newGraph.InRelation(activityA, newGraph.Conditions)
&& !newGraph.InRelation(activityA, newGraph.IncludeExcludes)
&& !newGraph.InRelation(activityA, newGraph.Responses)
&& !newGraph.InRelation(activityA, newGraph.Milestones));
}
public void TestAlwaysIncludeIncludedRedundant()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = false };
dcrGraph.Activities.Add(activityA);
dcrGraph.Activities.Add(activityB);
dcrGraph.Activities.Add(activityC);
dcrGraph.AddCondition(activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(true, activityB.Id, activityC.Id);
dcrGraph.AddIncludeExclude(true, activityA.Id, activityC.Id);
var newDcr = new RedundancyRemover().RemoveRedundancy(dcrGraph);
//we should now have removed include b -> c. so we are asserting that B no longer has a include relation
Assert.IsFalse(newDcr.GetIncludeOrExcludeRelation(activityB, true).Contains(activityC));
}
private static int GetNestedGraphCount(DcrGraph graph)
{
var result = 0;
foreach (var nestedGraph in graph.Activities.Where(a => a.IsNestedGraph).Select(b => b.NestedGraph))
{
result++;
result += GetNestedGraphCount(nestedGraph);
}
return result;
}
public void TestConditionMilestoneRedundancy()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = false };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = true };
dcrGraph.Activities.Add(activityA);
dcrGraph.Activities.Add(activityB);
dcrGraph.Activities.Add(activityC);
dcrGraph.AddCondition(activityA.Id, activityB.Id);
dcrGraph.AddMileStone(activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(true, activityC.Id, activityA.Id);
dcrGraph.AddResponse(activityC.Id, activityA.Id);
var newGraph = new RedundancyRemover().RemoveRedundancy(dcrGraph);
//Now either the redundant Condition or Milestone relation should be removed:");
Assert.IsFalse(newGraph.InRelation(activityA, newGraph.Conditions) && newGraph.InRelation(activityA, newGraph.Milestones));
}
public void TestResponseAndExcludeRedundantIfNoTargetInclude()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true };
var activityB = new Activity("B", "somename2") { Included = true };
dcrGraph.Activities.Add(activityA);
dcrGraph.Activities.Add(activityB);
dcrGraph.AddResponse(activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityB.Id);
var newGraph = new RedundancyRemover().RemoveRedundancy(dcrGraph);
//Now the redundant response relation should be removed:
Assert.IsFalse(newGraph.InRelation(activityB, newGraph.Responses));
}
public void TestRedundantActivityIsRemoved()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = false };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = true };
dcrGraph.Activities.Add(activityA);
dcrGraph.Activities.Add(activityB);
dcrGraph.Activities.Add(activityC);
dcrGraph.AddResponse(activityB.Id, activityA.Id);
var newGraph = new RedundancyRemover().RemoveRedundancy(dcrGraph);
Assert.IsNull(newGraph.GetActivity(activityA.Id));
}
public void TestNonRedundantResponseIsNotRemoved2()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true };
var activityB = new Activity("B", "somename2") { Included = false };
dcrGraph.Activities.Add(activityA);
dcrGraph.Activities.Add(activityB);
dcrGraph.AddResponse(activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(true, activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityA.Id);
var newGraph = new RedundancyRemover().RemoveRedundancy(dcrGraph);
Assert.IsTrue(newGraph.InRelation(activityA, newGraph.Responses));
}
public void TestIncludesToIncludedRedundant()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true };
var activityB = new Activity("B", "somename2") { Included = true };
dcrGraph.Activities.Add(activityA);
dcrGraph.Activities.Add(activityB);
dcrGraph.AddIncludeExclude(true, activityA.Id, activityB.Id);
//Now the redundant include relation should be removed:");
var newGraph = new RedundancyRemover().RemoveRedundancy(dcrGraph);
Assert.IsFalse(newGraph.InRelation(activityA, newGraph.IncludeExcludes));
}
public void TestIncludeConditionRedundancy()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true };
var activityB = new Activity("B", "somename2") { Included = false };
dcrGraph.Activities.Add(activityA);
dcrGraph.Activities.Add(activityB);
dcrGraph.AddCondition(activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(true, activityA.Id, activityB.Id);
var newGraph = new RedundancyRemover().RemoveRedundancy(dcrGraph);
//Now the redundant condition relation from A to B should be removed:
Assert.IsFalse(newGraph.InRelation(activityB, newGraph.Conditions));
}
