protected RawAbstractItem([NotNull] ItemType itemType, [NotNull] string namespaceName, [NotNull] string className,
[NotNull] string assemblyName, [CanBeNull] string assemblyVersion, [CanBeNull] string assemblyCulture,
[CanBeNull] string memberName, [CanBeNull, ItemNotNull] string[] markers, [NotNull] WorkingGraph readingGraph)
{
if (itemType == null)
{
throw new ArgumentNullException(nameof(itemType));
}
if (namespaceName == null)
{
throw new ArgumentNullException(nameof(namespaceName));
}
if (className == null)
{
throw new ArgumentNullException(nameof(className));
}
if (assemblyName == null)
{
throw new ArgumentNullException(nameof(assemblyName));
}
ItemType = itemType;
NamespaceName = string.Intern(namespaceName);
ClassName = string.Intern(className);
AssemblyName = string.Intern(assemblyName);
_assemblyVersion = string.Intern(assemblyVersion ?? "");
_assemblyCulture = string.Intern(assemblyCulture ?? "");
MemberName = string.Intern(memberName ?? "");
_markers = markers;
_readingGraph = readingGraph;
}
public void TestWriteOverlappingCycles()
{
const string cycleMarkerPrefix = "X";
var gc = new GlobalContext();
WorkingGraph graph = gc.CurrentGraph;
var a = graph.CreateItem(ItemType.SIMPLE, "a");
var b = graph.CreateItem(ItemType.SIMPLE, "b");
var c = graph.CreateItem(ItemType.SIMPLE, "c");
var d = graph.CreateItem(ItemType.SIMPLE, "d");
var e = graph.CreateItem(ItemType.SIMPLE, "e");
List <Dependency> dependencies = CreateDependenciesAndFindCycles(gc, a, b, c, d, e, keepOnlyCyclesOption: false, markerPrefix: cycleMarkerPrefix);
using (var s = new MemoryStream()) {
var w = new FlatPathWriter();
w.RenderToStreamForUnitTests(gc, dependencies, s, cycleMarkerPrefix + "* -sm");
string result = Encoding.ASCII.GetString(s.ToArray());
Assert.AreEqual(@"-- X0
SIMPLE:a'X0
SIMPLE:c'X1
SIMPLE:d
SIMPLE:e
<= SIMPLE:a'X0 $
-- X1
SIMPLE:c'X1
SIMPLE:d
<= SIMPLE:c'X1 $", result.Trim());
}
}
public void TestOverlappingCycles()
{
var gc = new GlobalContext();
WorkingGraph graph = gc.CurrentGraph;
var a = graph.CreateItem(ItemType.SIMPLE, "a");
var b = graph.CreateItem(ItemType.SIMPLE, "b");
var c = graph.CreateItem(ItemType.SIMPLE, "c");
var d = graph.CreateItem(ItemType.SIMPLE, "d");
var e = graph.CreateItem(ItemType.SIMPLE, "e");
List <Dependency> result = CreateDependenciesAndFindCycles(gc, a, b, c, d, e, keepOnlyCyclesOption: true, markerPrefix: "Kreis");
Assert.AreEqual(5, result.Count);
Assert.AreEqual(a, result[0].UsingItem);
Assert.AreEqual(1, result[0].BadCt);
Assert.AreEqual(c, result[1].UsingItem);
Assert.AreEqual(1, result[1].BadCt);
Assert.AreEqual(d, result[2].UsingItem);
Assert.AreEqual(1, result[2].BadCt);
Assert.AreEqual(d, result[3].UsingItem);
Assert.AreEqual(1, result[3].BadCt);
Assert.AreEqual(e, result[4].UsingItem);
Assert.AreEqual(1, result[4].BadCt);
}
public void TestSimpleFlatPathWriterForOnePath()
{
var gc = new GlobalContext {
IgnoreCase = true
};
WorkingGraph graph = gc.CurrentGraph;
ItemType t3 = ItemType.New("T3(ShortName:MiddleName:LongName)");
var RegexPathMarker = "P0";
Item a = graph.CreateItem(t3, "a:aa:aaa".Split(':'));
a.MarkPathElement(RegexPathMarker, 0, isStart: false, isEnd: false, isMatchedByCountSymbol: false,
isLoopBack: false);
Item b = graph.CreateItem(t3, "b:bb:bbb".Split(':'));
b.SetMarker(RegexPathMarker, 1);
var d = CreateDependency(graph, a, b, RegexPathMarker, true, true, false, false);
Dependency[] dependencies = { d };
using (var s = new MemoryStream()) {
var w = new FlatPathWriter();
w.RenderToStreamForUnitTests(gc, dependencies, s, "P*");
string result = Encoding.ASCII.GetString(s.ToArray());
Assert.AreEqual(@"-- P0
a:aa:aaa
b:bb:bbb $", result.Trim());
}
}
private static List <Dependency> CreateDependenciesAndFindCycles(GlobalContext gc, Item a, Item b, Item c, Item d, Item e, bool keepOnlyCyclesOption, string markerPrefix)
{
WorkingGraph graph = gc.CurrentGraph;
var deps = new[] {
// "Confusing" edges to sink b
graph.CreateDependency(a, b, null, "", 1),
graph.CreateDependency(b, b, null, "", 1),
graph.CreateDependency(c, b, null, "", 1),
graph.CreateDependency(d, b, null, "", 1),
// a->c->d->e
graph.CreateDependency(a, c, null, "", 1),
graph.CreateDependency(c, d, null, "", 1),
graph.CreateDependency(d, e, null, "", 1),
// Cycle edges c<-d and a<-e
graph.CreateDependency(d, c, null, "", 1),
graph.CreateDependency(e, a, null, "", 1),
};
var result = new List <Dependency>();
new MarkCycleDeps().Transform(gc, Ignore.Om,
new MarkCycleDeps.TransformOptions {
KeepOnlyCycleDependencies = keepOnlyCyclesOption,
IndexedMarkerPrefix = markerPrefix
},
deps, result);
result.Sort((x, y) => string.Compare(x.UsingItemAsString, y.UsingItemAsString, StringComparison.Ordinal));
return(result);
}
public void TestLoopIsNotEndless()
{
var gc = new GlobalContext();
WorkingGraph graph = gc.CurrentGraph;
Item a = graph.CreateItem(ItemType.SIMPLE, "a");
Item b = graph.CreateItem(ItemType.SIMPLE, "b");
Item c = graph.CreateItem(ItemType.SIMPLE, "c");
Item d = graph.CreateItem(ItemType.SIMPLE, "d");
graph.AddDependencies(new[] {
graph.CreateDependency(a, b, null, "", 1),
// Loop on b & c; but we never reach d!
graph.CreateDependency(b, c, null, "", 1),
graph.CreateDependency(c, b, null, "", 1),
// Loop on d so that it remains in graph
graph.CreateDependency(d, d, null, "", 1)
});
// We want to go from a to d - this will never succeed; but we must make sure that
// there is no endless loop around b and c.
var traverser = new TestTraverser(graph.VisibleDependencies, new PathRegex("a.(b.c.)*d"));
traverser.Traverse(a);
Assert.AreEqual(0, traverser.RecordedPaths.Count());
}
private Dependency NewDependency(WorkingGraph workingGraph, string usingA, string usingN, string usingC, string usedA, string usedN,
string usedC)
{
return(workingGraph.CreateDependency(workingGraph.CreateItem(ITEMTYPE, usingA, usingN, usingC),
workingGraph.CreateItem(ITEMTYPE, usedA, usedN, usedC),
null, "Test", ct: 1));
}
private Dependency ResolveItemProxies(WorkingGraph readingGraph, Dependency d, Dictionary <Item, Item> itemsDictionary)
{
return(d.UsingItem is ItemProxy || d.UsedItem is ItemProxy
? readingGraph.CreateDependency(itemsDictionary[d.UsingItem], itemsDictionary[d.UsedItem],
d.Source, d.MarkerSet, d.Ct, d.QuestionableCt, d.BadCt, d.NotOkReason, d.ExampleInfo)
: d);
}
private FromTo ProjectDependency(WorkingGraph currentWorkingGraph, Dependency d, Dictionary <FromTo, Dependency> localCollector,
Func <bool> onMissingPattern)
{
Item usingItem = _projector.Project(cachingGraph: currentWorkingGraph, item: d.UsingItem, left: true);
Item usedItem = _projector.Project(cachingGraph: currentWorkingGraph, item: d.UsedItem, left: false);
if (usingItem == null)
{
if (onMissingPattern())
{
Log.WriteWarning("No projection pattern found for " + d.UsingItem.AsString() + " - I ignore it");
}
return(null);
}
else if (usedItem == null)
{
if (onMissingPattern())
{
Log.WriteWarning("No projection pattern found for " + d.UsedItem.AsString() + " - I ignore it");
}
return(null);
}
else if (usingItem.IsEmpty() || usedItem.IsEmpty())
{
// ignore this edge!
return(null);
}
else
{
return(new FromTo(usingItem, usedItem).AggregateDependency(currentWorkingGraph, d, localCollector));
}
}
public void TestToTooFewFields()
{
var pi = new ProjectItems((p, i) => new ProjectItems.SelfOptimizingPrefixTrieProjector(p, i, 2, "prefixTrie"));
var gc = new GlobalContext();
const string THREE_FIELDS = "THREE_FIELDS";
pi.Configure(gc, $@"{{ -pl
$ {THREE_FIELDS}(F1:F2:F3) ---% {THREE_FIELDS}
! a:b:c ---% ::
! a:b ---% : // this threw an exception before a fix
! a ---%
}}", forceReload: false);
ItemType threeFields = ItemType.Find(THREE_FIELDS);
WorkingGraph graph = gc.CurrentGraph;
Item abc = graph.CreateItem(threeFields, "a:b:c");
Item ab = graph.CreateItem(threeFields, "a:b:-");
Item a = graph.CreateItem(threeFields, "a:-:-");
var result = new List <Dependency>();
pi.Transform(gc, new[] {
graph.CreateDependency(abc, abc, null, "abc", 1),
graph.CreateDependency(ab, ab, null, "ab", 1),
graph.CreateDependency(a, a, null, "a", 1),
}, "", result, s => null);
Assert.AreEqual(0, result.Count);
}
public override IEnumerable <Dependency> CreateSomeTestDependencies(WorkingGraph transformingGraph)
{
var s1 = transformingGraph.CreateItem(ItemType.SIMPLE, "S1");
var s2 = transformingGraph.CreateItem(ItemType.SIMPLE, "S2");
var a = transformingGraph.CreateItem(ItemType.SIMPLE, "A");
var t1 = transformingGraph.CreateItem(ItemType.SIMPLE, "T1");
var t2 = transformingGraph.CreateItem(ItemType.SIMPLE, "T2");
var b = transformingGraph.CreateItem(ItemType.SIMPLE, "B");
var c = transformingGraph.CreateItem(ItemType.SIMPLE, "C");
var d = transformingGraph.CreateItem(ItemType.SIMPLE, "D");
var t3 = transformingGraph.CreateItem(ItemType.SIMPLE, "T3");
var t4 = transformingGraph.CreateItem(ItemType.SIMPLE, "T4");
return(new[] {
transformingGraph.CreateDependency(s1, a, source: null, markers: "1", ct: 10, questionableCt: 5, badCt: 3, notOkReason: "test"),
transformingGraph.CreateDependency(s1, d, source: null, markers: "D", ct: 10, questionableCt: 5, badCt: 3, notOkReason: "test"),
transformingGraph.CreateDependency(s1, t4, source: null, markers: "D", ct: 10, questionableCt: 5, badCt: 3, notOkReason: "test"),
transformingGraph.CreateDependency(s2, a, source: null, markers: "2", ct: 10, questionableCt: 5, badCt: 3, notOkReason: "test"),
transformingGraph.CreateDependency(a, t1, source: null, markers: "1", ct: 1, questionableCt: 0, badCt: 0),
transformingGraph.CreateDependency(a, t2, source: null, markers: "2", ct: 2, questionableCt: 0, badCt: 0),
transformingGraph.CreateDependency(a, t2, source: null, markers: "2", ct: 3, questionableCt: 0, badCt: 0),
transformingGraph.CreateDependency(a, b, source: null, markers: "", ct: 1, questionableCt: 0, badCt: 0),
transformingGraph.CreateDependency(b, c, source: null, markers: "", ct: 1, questionableCt: 0, badCt: 0),
transformingGraph.CreateDependency(c, b, source: null, markers: "", ct: 1, questionableCt: 0, badCt: 0),
transformingGraph.CreateDependency(c, t3, source: null, markers: "3", ct: 5, questionableCt: 0, badCt: 2, notOkReason: "test"),
transformingGraph.CreateDependency(d, t4, source: null, markers: "4", ct: 5, questionableCt: 0, badCt: 2, notOkReason: "test"),
});
}
private ItemTail ExtractCustomSections(WorkingGraph readingGraph, CustomAttribute customAttribute, ItemTail parent)
{
TypeReference customAttributeTypeReference = customAttribute.AttributeType;
TypeDefinition attributeType = Resolve(customAttributeTypeReference);
bool isSectionAttribute = attributeType != null && attributeType.Interfaces.Any(i => i.FullName == "NDepCheck.ISectionAttribute");
if (isSectionAttribute)
{
string[] keys = attributeType.Properties.Select(property => property.Name).ToArray();
FieldDefinition itemTypeNameField = attributeType.Fields.FirstOrDefault(f => f.Name == "ITEM_TYPE");
if (itemTypeNameField == null)
{
//??? Log.WriteError();
throw new Exception("string constant ITEM_TYPE not defined in " + attributeType.FullName);
}
else
{
string itemTypeName = "" + itemTypeNameField.Constant;
ItemType itemType = GetOrDeclareType(itemTypeName, Enumerable.Repeat("CUSTOM", keys.Length), keys.Select(k => "." + k));
var args = keys.Select((k, i) => new {
Key = k,
Index = i,
Property = customAttribute.Properties.FirstOrDefault(p => p.Name == k)
});
string[] values = args.Select(a => a.Property.Name == null
? parent?.Values[a.Index]
: "" + a.Property.Argument.Value).ToArray();
return(ItemTail.New(readingGraph.ItemTailCache, itemType, values));
}
}
else
{
return(parent);
}
}
public Dependency ToDependencyWithTail(WorkingGraph readingGraph, int depth, string containerUri)
{
// ?? fires if reader == null (i.e., target assembly is not read in), or if assemblies do not match (different compiles) and hence a used item is not found in target reader.
Item usedItem = (_readerForUsedItem == null ? null : UsedItem.ToItemWithTail(readingGraph, _readerForUsedItem, depth)) ?? UsedItem.ToItem();
return(ToDependency(readingGraph, usedItem, containerUri));
}
private Dependency ToDependency(WorkingGraph readingGraph, Item usedItem, string containerUri)
{
return(readingGraph.CreateDependency(UsingItem.ToItem(), usedItem, _sequencePoint == null
? (ISourceLocation) new LocalSourceLocation(containerUri, UsingItem.NamespaceName + "." + UsingItem.ClassName + (string.IsNullOrWhiteSpace(UsingItem.MemberName) ? "" : "." + UsingItem.MemberName))
: new ProgramFileSourceLocation(containerUri, _sequencePoint.Document.Url, _sequencePoint.StartLine, _sequencePoint.StartColumn, _sequencePoint.EndLine, _sequencePoint.EndColumn),
Usage.ToString(), 1));
}
public void TestSimpleFlatPathWriterForYPath()
{
ItemType t3 = ItemType.New("T3(ShortName:MiddleName:LongName)");
var gc = new GlobalContext();
WorkingGraph graph = gc.CurrentGraph;
var a = graph.CreateItem(t3, "a:aa:aaa".Split(':'));
var b = graph.CreateItem(t3, "b:bb:bbb".Split(':'));
var c = graph.CreateItem(t3, "c:cc:ccc".Split(':'));
var d = graph.CreateItem(t3, "d:dd:ddd".Split(':'));
var dependencies = new[] {
FromTo(graph, a, b),
FromTo(graph, b, c),
FromTo(graph, b, d),
};
string result = FindPathsAndWriteFlat(gc, dependencies, "A", CreateDefaultOptions("A"));
Assert.AreEqual(@"-- A0
T3:a:aa:aaa'A0
T3:b:bb:bbb'A $
T3:d:dd:ddd'A $", result.Trim());
}
public override IEnumerable <Dependency> CreateSomeTestDependencies(WorkingGraph renderingGraph)
{
ItemType amo = ItemType.New("AMO(Assembly:Module:Order)");
var bac = renderingGraph.CreateItem(amo, "BAC:BAC:0100".Split(':'));
var kst = renderingGraph.CreateItem(amo, "KST:KST:0200".Split(':'));
var kah = renderingGraph.CreateItem(amo, "KAH:KAH:0300".Split(':'));
var kah_mi = renderingGraph.CreateItem(amo, "Kah.MI:KAH:0301".Split(':'));
var vkf = renderingGraph.CreateItem(amo, "VKF:VKF:0400".Split(':'));
var vkf1_mi = renderingGraph.CreateItem(amo, "Vkf1.MI:VKF:0401".Split(':'));
var vkf2_mi = renderingGraph.CreateItem(amo, "Vkf2.MI:VKF:0402".Split(':'));
//var vkf3_mi = renderingGraph.ItemAndDependencyFactory.New(amo, "Vkf3.MI:VKF:0402".Split(':'));
//var vkf4_mi = renderingGraph.ItemAndDependencyFactory.New(amo, "Vkf4.MI:VKF:0402".Split(':'));
var wlg = renderingGraph.CreateItem(amo, "WLG:WLG:0500".Split(':'));
var wlg1_mi = renderingGraph.CreateItem(amo, "Wlg1.MI:WLG:0501".Split(':'));
var wlg2_mi = renderingGraph.CreateItem(amo, "Wlg2.MI:WLG:0502".Split(':'));
//var imp = renderingGraph.ItemAndDependencyFactory.New(amo, "IMP:IMP:0600".Split(':'));
var imp_mi = renderingGraph.CreateItem(amo, "Imp.MI:IMP:0601".Split(':'));
//var top = renderingGraph.ItemAndDependencyFactory.New(amo, "Top:TOP:0700".Split(':'));
return(new[] {
FromTo(renderingGraph, kst, bac), FromTo(renderingGraph, kst, kah_mi),
FromTo(renderingGraph, kst, vkf1_mi), FromTo(renderingGraph, kst, vkf2_mi),
FromTo(renderingGraph, kst, wlg1_mi), FromTo(renderingGraph, kst, wlg2_mi),
FromTo(renderingGraph, kah, bac), FromTo(renderingGraph, kah, vkf1_mi),
FromTo(renderingGraph, kah, vkf2_mi), FromTo(renderingGraph, kah, wlg, 4, 3) /* ===> */,
FromTo(renderingGraph, vkf, bac), FromTo(renderingGraph, vkf, kst),
FromTo(renderingGraph, vkf, kah, 3), FromTo(renderingGraph, vkf, kah_mi, 2, 2) /* <:: */,
FromTo(renderingGraph, vkf, imp_mi), FromTo(renderingGraph, vkf1_mi, bac),
FromTo(renderingGraph, vkf2_mi, bac),
// ... more to come
});
}
public void TestOldCountPaths() {
ItemType xy = ItemType.New("NL(Name:Layer)");
var gc = new GlobalContext();
WorkingGraph graph = gc.CurrentGraph;
Item a = graph.CreateItem(xy, "a", "1");
Item b = graph.CreateItem(xy, "b", "2");
Item c = graph.CreateItem(xy, "c", "2");
Item d = graph.CreateItem(xy, "d", "3");
Item e = graph.CreateItem(xy, "e", "4");
Item f = graph.CreateItem(xy, "f", "4");
Item g = graph.CreateItem(xy, "g", "5");
Dependency[] dependencies = {
FromTo(graph, a, b),
FromTo(graph, a, c),
FromTo(graph, b, d),
FromTo(graph, c, d),
FromTo(graph, d, e),
FromTo(graph, d, f),
FromTo(graph, e, g),
FromTo(graph, f, g)
};
string o = FindPathsAndWriteFlat(gc, dependencies, "A", "{ -im A -pi a -ci 2 -pi g }".Replace(" ", Environment.NewLine));
Console.WriteLine(o);
Assert.IsTrue(o.Contains("b:2 #"));
Assert.IsTrue(o.Contains("c:2 #"));
Assert.IsTrue(o.Contains("d:3'A=2"));
Assert.IsTrue(o.Contains("e:4'A=2"));
Assert.IsTrue(o.Contains("g:5'A=2 $"));
}
protected override IEnumerable <RawUsingItem> ReadUsingItems(int depth, WorkingGraph readingGraph)
{
Log.WriteInfo("Reading " + FullFileName);
AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(FullFileName);
try {
assembly.MainModule.ReadSymbols();
} catch (Exception ex) {
Log.WriteWarning(
$"Loading symbols for assembly {FullFileName} failed - maybe .PDB file is missing. ({ex.Message})", FullFileName, 0);
}
ItemTail customSections = GetCustomSections(readingGraph, assembly.CustomAttributes, null);
foreach (TypeDefinition type in assembly.MainModule.Types)
{
if (type.Name == "<Module>")
{
continue;
}
foreach (var usingItem in AnalyzeType(type, customSections, readingGraph))
{
yield return(usingItem);
}
}
AssemblyNameDefinition currentAssembly = assembly.Name;
yield return(RawUsingItem.New(_rawUsingItemsCache, DOTNETASSEMBLY,
namespaceName: "", className: "", assemblyName: currentAssembly.Name,
assemblyVersion: currentAssembly.Version.ToString(), assemblyCulture: currentAssembly.Culture,
memberName: "", markers: null, tail: null, readingGraph: readingGraph));
}
public void TestFindAllGraphs()
{
// All graphs in a->b-->b1->b2->b3->b4->b5
// / \\_
// +-+ \->c
// are:
WorkingGraph graph = CreateGraphWithLongTail();
var traverser = new TestTraverser(graph.VisibleDependencies, new PathRegex(":(.:)*"));
traverser.Traverse(graph.VisibleDependencies.First().UsingItem);
Assert.AreEqual(15, traverser.RecordedPaths.Count());
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:0");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:0", "b:0");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:0", "c:");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:0", "b:1");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:0", "b:1", "b:2");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:0", "b:1", "b:2", "b:3");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:0", "b:1", "b:2", "b:3", "b:4");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:0", "b:1", "b:2", "b:3", "b:4", "b:5");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "c:");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:1");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:1", "b:2");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:1", "b:2", "b:3");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:1", "b:2", "b:3", "b:4");
AssertRecordedDependenciesContainPath(traverser.RecordedPaths, "a:", "b:0", "b:1", "b:2", "b:3", "b:4", "b:5");
}
private FromTo ProjectDependency(WorkingGraph currentWorkingGraph, Dependency d,
Dictionary <Item, Item> leftSideCache, Dictionary <Item, Item> rightSideCache,
Dictionary <FromTo, Dependency> localCollector, int dependencyProjectCountForLogging, Func <bool> onMissingPattern)
{
Item usingItem = ProjectItem(currentWorkingGraph, leftSideCache, d.UsingItem, left: true,
dependencyProjectCountForLogging: dependencyProjectCountForLogging);
Item usedItem = ProjectItem(currentWorkingGraph, rightSideCache, d.UsedItem, left: false,
dependencyProjectCountForLogging: dependencyProjectCountForLogging);
if (usingItem == null)
{
if (onMissingPattern())
{
Log.WriteWarning("No projection pattern found for " + d.UsingItem.AsString() + " - I ignore it");
}
return(null);
}
else if (usedItem == null)
{
if (onMissingPattern())
{
Log.WriteWarning("No projection pattern found for " + d.UsedItem.AsString() + " - I ignore it");
}
return(null);
}
else if (usingItem.IsEmpty() || usedItem.IsEmpty())
{
// ignore this edge!
return(null);
}
else
{
return(new FromTo(usingItem, usedItem).AggregateDependency(currentWorkingGraph, d, localCollector));
}
}
protected IEnumerable <RawDependency> ReadRawDependencies(int depth, WorkingGraph readingGraph)
{
Log.WriteInfo(new string(' ', 2 * depth) + "Reading " + FullFileName);
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(Path.GetDirectoryName(FullFileName));
// readingGraph: Additional search directories should be specifiable in options
resolver.AddSearchDirectory(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\Silverlight\v5.0");
AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(FullFileName, new ReaderParameters {
AssemblyResolver = resolver
});
try {
assembly.MainModule.ReadSymbols();
} catch (Exception ex) {
Log.WriteWarning($"Loading symbols for assembly {FullFileName} failed - maybe .PDB file is missing. ({ex.Message})", FullFileName, 0);
}
ItemTail customSections = GetCustomSections(readingGraph, assembly.CustomAttributes, null);
foreach (TypeDefinition type in assembly.MainModule.Types)
{
if (type.Name == "<Module>")
{
continue;
}
foreach (var dependency in AnalyzeType(type, customSections, readingGraph))
{
yield return(dependency);
}
}
}
public override IEnumerable <Dependency> CreateSomeTestDependencies(WorkingGraph transformingGraph)
{
ItemType t3 = ItemType.New("T3(ShortName:MiddleName:LongName)");
var a = transformingGraph.CreateItem(t3, "a:aa:aaa".Split(':'));
var b = transformingGraph.CreateItem(t3, "b:bb:bbb".Split(':'));
var c = transformingGraph.CreateItem(t3, "c:cc:ccc".Split(':'));
var d = transformingGraph.CreateItem(t3, "d:dd:ddd".Split(':'));
var e = transformingGraph.CreateItem(t3, "e:ee:eee".Split(':'));
var f = transformingGraph.CreateItem(t3, "f:ff:fff".Split(':'));
var g = transformingGraph.CreateItem(t3, "g:gg:ggg".Split(':'));
var h = transformingGraph.CreateItem(t3, "h:hh:hhh".Split(':'));
return(new[] {
FromTo(transformingGraph, a, b),
FromTo(transformingGraph, a, h),
FromTo(transformingGraph, b, c),
FromTo(transformingGraph, c, d),
FromTo(transformingGraph, d, e),
FromTo(transformingGraph, d, b),
FromTo(transformingGraph, e, f),
FromTo(transformingGraph, b, g),
FromTo(transformingGraph, h, g),
});
}
public void TestSimpleCycle()
{
var gc = new GlobalContext();
WorkingGraph graph = gc.CurrentGraph;
var nodes = new[] {
graph.CreateItem(ItemType.SIMPLE, new[] { "n1" }),
graph.CreateItem(ItemType.SIMPLE, new[] { "n2" }),
graph.CreateItem(ItemType.SIMPLE, new[] { "n3" })
};
var edges = new[] {
CreateDependency(graph, nodes[2], nodes[1], 55),
CreateDependency(graph, nodes[2], nodes[0], 111),
CreateDependency(graph, nodes[1], nodes[0], 77),
CreateDependency(graph, nodes[0], nodes[2], 7),
CreateDependency(graph, nodes[0], nodes[0], 999),
};
using (var s = new MemoryStream()) {
new MatrixRenderer1().RenderToStreamForUnitTests(gc, edges, s, "");
Assert.AreEqual(@"Id ;Name;001; ;002; ;003;
001;n3 ; ; ; ; ;# 7;
002;n2 ; 55; ; ; ; ;
003;n1 ; 111; ; 77; ; 999;
", Encoding.ASCII.GetString(s.ToArray()));
}
}
public override IEnumerable <Dependency> CreateSomeTestDependencies(WorkingGraph transformingGraph)
{
Item a = transformingGraph.CreateItem(ItemType.SIMPLE, "Ax");
Item b = transformingGraph.CreateItem(ItemType.SIMPLE, "Bx");
Item c = transformingGraph.CreateItem(ItemType.SIMPLE, "Cloop");
Item d = transformingGraph.CreateItem(ItemType.SIMPLE, "Dloop");
Item e = transformingGraph.CreateItem(ItemType.SIMPLE, "Eselfloop");
Item f = transformingGraph.CreateItem(ItemType.SIMPLE, "Fy");
Item g = transformingGraph.CreateItem(ItemType.SIMPLE, "Gy");
Item h = transformingGraph.CreateItem(ItemType.SIMPLE, "Hy");
Item i = transformingGraph.CreateItem(ItemType.SIMPLE, "Iy");
Item j = transformingGraph.CreateItem(ItemType.SIMPLE, "Jy");
return(new[] {
// Pure sources
transformingGraph.CreateDependency(a, b, source: null, markers: "", ct: 10, questionableCt: 5, badCt: 3, notOkReason: "test data"),
transformingGraph.CreateDependency(b, c, source: null, markers: "", ct: 1, questionableCt: 0, badCt: 0),
// Long cycle
transformingGraph.CreateDependency(c, d, source: null, markers: "", ct: 5, questionableCt: 0, badCt: 2, notOkReason: "test data"),
transformingGraph.CreateDependency(d, c, source: null, markers: "", ct: 5, questionableCt: 0, badCt: 2, notOkReason: "test data"),
transformingGraph.CreateDependency(d, e, source: null, markers: "", ct: 5, questionableCt: 3, badCt: 2, notOkReason: "test data"),
// Self cycle
transformingGraph.CreateDependency(e, e, source: null, markers: "", ct: 5, questionableCt: 3, badCt: 2, notOkReason: "test data"),
// Pure sinks
transformingGraph.CreateDependency(e, f, source: null, markers: "", ct: 5, questionableCt: 3, badCt: 2, notOkReason: "test data"),
transformingGraph.CreateDependency(f, g, source: null, markers: "", ct: 5, questionableCt: 3, badCt: 2, notOkReason: "test data"),
transformingGraph.CreateDependency(g, h, source: null, markers: "", ct: 5, questionableCt: 3, badCt: 2, notOkReason: "test data"),
transformingGraph.CreateDependency(h, i, source: null, markers: "", ct: 5, questionableCt: 3, badCt: 2, notOkReason: "test data"),
transformingGraph.CreateDependency(h, j, source: null, markers: "", ct: 5, questionableCt: 3, badCt: 2, notOkReason: "test data"),
});
}
private static List <Dependency> FindLaterCycle(string cycleMarkerPrefix)
{
var gc = new GlobalContext();
WorkingGraph graph = gc.CurrentGraph;
var a = graph.CreateItem(ItemType.SIMPLE, "a");
var b = graph.CreateItem(ItemType.SIMPLE, "b");
var c = graph.CreateItem(ItemType.SIMPLE, "c");
var d = graph.CreateItem(ItemType.SIMPLE, "d");
var e = graph.CreateItem(ItemType.SIMPLE, "e");
var deps = new[] {
graph.CreateDependency(a, b, null, "", 1),
graph.CreateDependency(b, c, null, "", 1),
graph.CreateDependency(c, d, null, "", 1),
graph.CreateDependency(d, e, null, "", 1),
graph.CreateDependency(e, c, null, "", 1),
};
var result = new List <Dependency>();
new MarkCycleDeps().Transform(gc, Ignore.Om, new MarkCycleDeps.TransformOptions {
IndexedMarkerPrefix = cycleMarkerPrefix
}, deps, result);
result.Sort((x, y) => string.Compare(x.UsingItemAsString, y.UsingItemAsString, StringComparison.Ordinal));
return(result);
}
public void TestMarkCutFromMultipleSources()
{
var gc = new GlobalContext();
Dependency[] exampleDependencies = CreateExampleGraph(gc);
Item s = exampleDependencies[0].UsingItem;
WorkingGraph graph = gc.CurrentGraph;
Item r0 = graph.CreateItem(ItemType.SIMPLE, "r0");
Item r1 = graph.CreateItem(ItemType.SIMPLE, "r1");
Item r2 = graph.CreateItem(ItemType.SIMPLE, "r2");
Dependency[] dependencies = exampleDependencies.Concat(new[] {
graph.CreateDependency(r0, s, null, "r0_s", 1000, 0, 1000, notOkReason: "test data"),
graph.CreateDependency(r1, s, null, "r1_s", 1000, 0, 1000, notOkReason: "test data"),
graph.CreateDependency(r2, s, null, "r2_s", 1000, 0, 1000, notOkReason: "test data"),
}).ToArray();
const string mark = "CUT";
IEnumerable <Dependency> result = Run(gc, new MarkMinimalCutDeps.TransformOptions {
SourceMatches = new List <ItemMatch> {
new ItemMatch("r*", false, anyWhereMatcherOk: true)
},
TargetMatches = new List <ItemMatch> {
new ItemMatch("t", false, anyWhereMatcherOk: true)
},
MarkerToAddToCut = mark
}, dependencies);
Assert.IsTrue(result.All(z => z.MarkersContain(mark) == new[] { 12, 36, 78 }.Contains(z.Ct)),
string.Join("\r\n", result.Select(z => z.AsLimitableStringWithTypes(withExampleInfo: false, threeLines: false))));
}
public void TestMarkLaterCycleWithExplicitAsserts()
{
var gc = new GlobalContext();
WorkingGraph graph = gc.CurrentGraph;
var a = graph.CreateItem(ItemType.SIMPLE, "a");
var b = graph.CreateItem(ItemType.SIMPLE, "b");
var c = graph.CreateItem(ItemType.SIMPLE, "c");
var d = graph.CreateItem(ItemType.SIMPLE, "d");
var e = graph.CreateItem(ItemType.SIMPLE, "e");
var deps = new[] {
graph.CreateDependency(a, b, null, "", 1),
graph.CreateDependency(b, c, null, "", 1),
graph.CreateDependency(c, d, null, "", 1),
graph.CreateDependency(d, e, null, "", 1),
graph.CreateDependency(e, c, null, "", 1),
};
var result = new List <Dependency>();
new MarkCycleDeps().Transform(gc, Ignore.Om,
new MarkCycleDeps.TransformOptions {
KeepOnlyCycleDependencies = true
}, deps, result);
result.Sort((x, y) => string.Compare(x.UsingItemAsString, y.UsingItemAsString, StringComparison.Ordinal));
Assert.AreEqual(3, result.Count);
Assert.AreEqual(c, result[0].UsingItem);
Assert.AreEqual(1, result[0].BadCt);
Assert.AreEqual(d, result[1].UsingItem);
Assert.AreEqual(1, result[1].BadCt);
Assert.AreEqual(e, result[2].UsingItem);
Assert.AreEqual(1, result[2].BadCt);
}
public void TestMarkTrivialCut()
{
var gc = new GlobalContext();
WorkingGraph graph = gc.CurrentGraph;
Item a = graph.CreateItem(ItemType.SIMPLE, "a");
Item b = graph.CreateItem(ItemType.SIMPLE, "b");
Item c = graph.CreateItem(ItemType.SIMPLE, "c");
Item d = graph.CreateItem(ItemType.SIMPLE, "d");
var dependencies = new[] {
graph.CreateDependency(a, b, null, "D10", 10, 0, 4, notOkReason: "test data"),
graph.CreateDependency(b, c, null, "D20", 20, 0, 2, notOkReason: "test data"), // critical edge
graph.CreateDependency(c, d, null, "D30", 30, 0, 1, notOkReason: "test data"),
graph.CreateDependency(c, d, null, "D40", 40, 0, 3, notOkReason: "test data"),
};
const string mark = "CUT";
IEnumerable <Dependency> result = Run(gc,
new MarkMinimalCutDeps.TransformOptions {
SourceMatches = new List <ItemMatch> {
new ItemMatch("a", false, anyWhereMatcherOk: true)
},
TargetMatches = new List <ItemMatch> {
new ItemMatch("d", false, anyWhereMatcherOk: true)
},
MarkerToAddToCut = mark
}, dependencies);
Assert.IsTrue(result.All(z => z.MarkersContain(mark) == (z.Ct == 20)), string.Join("\r\n", result.Select(z => z.AsLimitableStringWithTypes(withExampleInfo: false, threeLines: false))));
}
public override IEnumerable <Dependency> CreateSomeTestDependencies(WorkingGraph transformingGraph)
{
Item a = transformingGraph.CreateItem(ItemType.SIMPLE, "A");
Item b = transformingGraph.CreateItem(ItemType.SIMPLE, "B");
Item c = transformingGraph.CreateItem(ItemType.SIMPLE, "C");
Item d = transformingGraph.CreateItem(ItemType.SIMPLE, "D");
Item e = transformingGraph.CreateItem(ItemType.SIMPLE, "E");
Item f = transformingGraph.CreateItem(ItemType.SIMPLE, "F");
Item g = transformingGraph.CreateItem(ItemType.SIMPLE, "G");
Item h = transformingGraph.CreateItem(ItemType.SIMPLE, "H");
Item i = transformingGraph.CreateItem(ItemType.SIMPLE, "I");
Item j = transformingGraph.CreateItem(ItemType.SIMPLE, "J");
// a<=>b->c->d->e<=>f->g
// ^ ^ |
// h<=>i->j-+ +---------+
return(new[] {
transformingGraph.CreateDependency(a, b, source: null, markers: "", ct: 1), // on cycle
transformingGraph.CreateDependency(b, a, source: null, markers: "", ct: 1), // on cycle
transformingGraph.CreateDependency(b, c, source: null, markers: "", ct: 1),
transformingGraph.CreateDependency(c, d, source: null, markers: "", ct: 1),
transformingGraph.CreateDependency(d, e, source: null, markers: "", ct: 1), // on cycle
transformingGraph.CreateDependency(e, f, source: null, markers: "", ct: 1), // on cycle
transformingGraph.CreateDependency(f, e, source: null, markers: "", ct: 1), // on cycle
transformingGraph.CreateDependency(f, g, source: null, markers: "", ct: 1), // on cycle
transformingGraph.CreateDependency(g, d, source: null, markers: "", ct: 1), // on cycle
transformingGraph.CreateDependency(h, i, source: null, markers: "", ct: 1), // on cycle
transformingGraph.CreateDependency(i, h, source: null, markers: "", ct: 1), // on cycle
transformingGraph.CreateDependency(i, j, source: null, markers: "", ct: 1),
transformingGraph.CreateDependency(j, c, source: null, markers: "", ct: 1),
});
}
/// <summary>
/// Return projected string for some item.
/// </summary>
/// <param name="cachingGraph"></param>
/// <param name="item">Iitem to be projected.</param>
/// <param name="left">Item is on left side of dependency</param>
/// <returns>Projected item; or <c>null</c> if item does not
/// match projection</returns>
public Item Match(WorkingGraph cachingGraph, [NotNull] Item item, bool left)
{
if (left && !_forLeftSide || !left && !_forRightSide)
{
return(null);
}
else
{
var matchResultGroups = ItemMatch.Matches(item);
if (!matchResultGroups.Success)
{
return(null);
}
else
{
IEnumerable <string> targets = _targetSegments;
for (int i = 0; i < matchResultGroups.Groups.Length; i++)
{
int matchResultIndex = i;
targets = targets.Select(s => s.Replace("\\" + (matchResultIndex + 1), matchResultGroups.Groups[matchResultIndex]));
}
_matchCount++;
return(cachingGraph.CreateItem(_targetItemType, targets.Select(t => GlobalContext.ExpandHexChars(t)).ToArray()));
}
}
}