protected override void Action()
{
bool secondFileIsOlder = _inputFile1.CreationTime < _inputFile2.CreationTime;
FileInfo oldModelFile = secondFileIsOlder ? _inputFile1 : _inputFile2;
FileInfo newModelFile = secondFileIsOlder ? _inputFile2 : _inputFile1;
DsiModel oldModel = new DsiModel("Diff", new List <string>(), Assembly.GetExecutingAssembly());
DsiModel newModel = new DsiModel("Diff", new List <string>(), Assembly.GetExecutingAssembly());
oldModel.Load(oldModelFile.FullName, this);
newModel.Load(newModelFile.FullName, this);
DsiModelCompare comparer = new DsiModelCompare(oldModel, newModel, this);
comparer.Compare();
if (comparer.AreIdentical)
{
Logger.LogUserMessage("Models are identical");
}
else
{
Logger.LogUserMessage("Models are different");
ReportDeltas(comparer);
}
}
public void ImportModel(string dsiFilename, string dsmFilename, bool autoPartition, bool recordChanges, bool compressDsmFile, IProgress <ProgressInfo> progress)
{
string processStep = "Builder";
Assembly assembly = Assembly.GetEntryAssembly();
DsiModel dsiModel = new DsiModel(processStep, assembly);
dsiModel.Load(dsiFilename, progress);
IImportPolicy importPolicy;
if (!File.Exists(dsmFilename) || !recordChanges)
{
importPolicy = new CreateNewModelPolicy(_dsmModel);
}
else
{
importPolicy = new UpdateExistingModelPolicy(_dsmModel, dsmFilename, _actionManager, progress);
}
DsmBuilder builder = new DsmBuilder(dsiModel, _dsmModel, importPolicy, autoPartition);
builder.Build(progress);
_actionStore.SaveToModel();
_dsmModel.SaveModel(dsmFilename, compressDsmFile, progress);
}
protected override void Action()
{
DsiModel model = new DsiModel("Transformer", Assembly.GetExecutingAssembly());
model.Load(_transformerSettings.InputFilename, this);
Transformation.Transformer transformer = new Transformation.Transformer(model, _transformerSettings, this);
transformer.Transform();
model.Save(_transformerSettings.OutputFilename, _transformerSettings.CompressOutputFile, this);
}
protected override void Action()
{
DsiModel model = new DsiModel("Analyzer", Assembly.GetExecutingAssembly());
Analysis.Analyzer analyzer = new Analysis.Analyzer(model, _analyzerSettings, this);
analyzer.Analyze();
model.Save(_analyzerSettings.OutputFilename, _analyzerSettings.CompressOutputFile, this);
Logger.LogUserMessage($"Found elements={model.GetElementCount()} relations={model.GetRelationCount()} resolvedRelations={model.ResolvedRelationPercentage:0.0}%");
}
public void AddTransitiveRelations()
{
DsiModel dataModel = new DsiModel("Test", Assembly.GetExecutingAssembly());
IDsiElement element1 = dataModel.AddElement("element1Name", "class", "");
Assert.IsNotNull(element1);
IDsiElement element2 = dataModel.AddElement("element2Name", "class", "");
Assert.IsNotNull(element2);
IDsiElement element3 = dataModel.AddElement("element3Name", "class", "");
Assert.IsNotNull(element3);
IDsiElement element4 = dataModel.AddElement("element4Name", "class", "");
Assert.IsNotNull(element4);
IDsiElement element5 = dataModel.AddElement("element5Name", "class", "");
Assert.IsNotNull(element5);
dataModel.AddRelation(element1.Name, element2.Name, "", 1, "context");
dataModel.AddRelation(element2.Name, element3.Name, "", 1, "context");
dataModel.AddRelation(element3.Name, element4.Name, "", 1, "context");
dataModel.AddRelation(element4.Name, element5.Name, "", 1, "context");
Assert.AreEqual(1, dataModel.GetRelationsOfConsumer(element1.Id).Count);
Assert.IsTrue(dataModel.DoesRelationExist(element1.Id, element2.Id));
Assert.AreEqual(1, dataModel.GetRelationsOfConsumer(element2.Id).Count);
Assert.IsTrue(dataModel.DoesRelationExist(element2.Id, element3.Id));
Assert.AreEqual(1, dataModel.GetRelationsOfConsumer(element3.Id).Count);
Assert.IsTrue(dataModel.DoesRelationExist(element3.Id, element4.Id));
Assert.AreEqual(1, dataModel.GetRelationsOfConsumer(element4.Id).Count);
Assert.IsTrue(dataModel.DoesRelationExist(element4.Id, element5.Id));
Assert.AreEqual(0, dataModel.GetRelationsOfConsumer(element5.Id).Count);
AddTransitiveRelationsAction transformation = new AddTransitiveRelationsAction(dataModel, true, null);
transformation.Execute();
Assert.AreEqual(4, dataModel.GetRelationsOfConsumer(element1.Id).Count);
Assert.IsTrue(dataModel.DoesRelationExist(element1.Id, element2.Id));
Assert.IsTrue(dataModel.DoesRelationExist(element1.Id, element3.Id));
Assert.IsTrue(dataModel.DoesRelationExist(element1.Id, element4.Id));
Assert.IsTrue(dataModel.DoesRelationExist(element1.Id, element5.Id));
Assert.AreEqual(3, dataModel.GetRelationsOfConsumer(element2.Id).Count);
Assert.IsTrue(dataModel.DoesRelationExist(element2.Id, element3.Id));
Assert.IsTrue(dataModel.DoesRelationExist(element2.Id, element4.Id));
Assert.IsTrue(dataModel.DoesRelationExist(element2.Id, element5.Id));
Assert.AreEqual(2, dataModel.GetRelationsOfConsumer(element3.Id).Count);
Assert.IsTrue(dataModel.DoesRelationExist(element3.Id, element4.Id));
Assert.IsTrue(dataModel.DoesRelationExist(element3.Id, element5.Id));
Assert.AreEqual(1, dataModel.GetRelationsOfConsumer(element4.Id).Count);
Assert.IsTrue(dataModel.DoesRelationExist(element4.Id, element5.Id));
Assert.AreEqual(0, dataModel.GetRelationsOfConsumer(element5.Id).Count);
}
public void LoadingAndSavedModelRestoresThePreviousState()
{
string filename = "temp.dsi";
DsiModel dataModel1 = new DsiModel("Test", Assembly.GetExecutingAssembly());
IDsiElement consumer = dataModel1.AddElement("consumerName", "class", "consumerSource");
Assert.IsNotNull(consumer);
IDsiElement provider1 = dataModel1.AddElement("provider1Name", "class", "provider1Source");
Assert.IsNotNull(provider1);
IDsiElement provider2 = dataModel1.AddElement("provider2Name", "class", "provider2Source");
Assert.IsNotNull(provider2);
dataModel1.AddRelation(consumer.Name, provider1.Name, "relationType2", 2, "context");
dataModel1.AddRelation(consumer.Name, provider2.Name, "relationType3", 3, "context");
dataModel1.Save(filename, false, null);
DsiModel dataModel2 = new DsiModel("Test", Assembly.GetExecutingAssembly());
dataModel2.Load(filename, null);
Assert.AreEqual(dataModel1.TotalElementCount, dataModel2.TotalElementCount);
List <IDsiElement> dataModel1Elements = dataModel1.GetElements().ToList();
List <IDsiElement> dataModel2Elements = dataModel2.GetElements().ToList();
for (int elementIndex = 0; elementIndex < dataModel1.TotalElementCount; elementIndex++)
{
Assert.AreEqual(dataModel1Elements[elementIndex].Id, dataModel2Elements[elementIndex].Id);
Assert.AreEqual(dataModel1Elements[elementIndex].Name, dataModel2Elements[elementIndex].Name);
Assert.AreEqual(dataModel1Elements[elementIndex].Type, dataModel2Elements[elementIndex].Type);
Assert.AreEqual(dataModel1Elements[elementIndex].Source, dataModel2Elements[elementIndex].Source);
Assert.AreEqual(dataModel1.GetRelationsOfConsumer(dataModel1Elements[elementIndex].Id).Count, dataModel2.GetRelationsOfConsumer(dataModel1Elements[elementIndex].Id).Count);
List <IDsiRelation> dataModel1Relations = dataModel1.GetRelationsOfConsumer(dataModel1Elements[elementIndex].Id).ToList();
List <IDsiRelation> dataModel2Relations = dataModel2.GetRelationsOfConsumer(dataModel2Elements[elementIndex].Id).ToList();
for (int relationIndex = 0; relationIndex < dataModel1.GetRelationsOfConsumer(dataModel1Elements[elementIndex].Id).Count;
relationIndex++)
{
Assert.AreEqual(dataModel1Relations[relationIndex].ConsumerId, dataModel2Relations[relationIndex].ConsumerId);
Assert.AreEqual(dataModel1Relations[relationIndex].ProviderId, dataModel2Relations[relationIndex].ProviderId);
Assert.AreEqual(dataModel1Relations[relationIndex].Type, dataModel2Relations[relationIndex].Type);
Assert.AreEqual(dataModel1Relations[relationIndex].Weight, dataModel2Relations[relationIndex].Weight);
}
}
}
private void UpdateDocumentStructureInformation()
{
_documentStructureInformation.Clear();
var segment = _activeDocument?.ActiveSegmentPair;
var contexts = segment?.GetParagraphUnitProperties().Contexts;
if (!(contexts?.Contexts?.Count > 0))
{
OnPropertyChanged(nameof(DocumentStructureInformation));
OnPropertyChanged(nameof(HasDocumentStructureInformation));
return;
}
foreach (var context in contexts.Contexts)
{
if (context.DisplayName == null)
{
continue;
}
var color = context.DisplayColor;
var model = new DsiModel
{
DisplayName = context.DisplayName,
Code = context.DisplayCode,
Description = context.ContextType == TMMatchContextTypes.LengthInformation
? GetAdditionalInformation(context)
: context.Description
};
if (color.Name == "0") // it doesn't have a color set
{
model.RowColor = "White";
}
else
{
model.RowColor = "#" + color.R.ToString("X2") + color.G.ToString("X2") + color.B.ToString("X2");
}
_documentStructureInformation.Add(model);
}
OnPropertyChanged(nameof(DocumentStructureInformation));
OnPropertyChanged(nameof(HasDocumentStructureInformation));
}
public void DoNotMergeWhenImplementationDoesNotDependOnHeaderFileWithSameName()
{
DsiModel dataModel = new DsiModel("Test", Assembly.GetExecutingAssembly());
dataModel.AddElement("namespace1.namespace1.element1Name.cpp", "class", "");
dataModel.AddElement("namespace3.namespace4.element1Name.h", "class", "");
Assert.IsNotNull(dataModel.FindElementByName("namespace1.namespace1.element1Name.cpp"));
Assert.IsNotNull(dataModel.FindElementByName("namespace3.namespace4.element1Name.h"));
Assert.IsNull(dataModel.FindElementByName("namespace1.namespace1.element1Name.h"));
MoveHeaderElementsAction transformation = new MoveHeaderElementsAction(dataModel, true, null);
transformation.Execute();
Assert.IsNotNull(dataModel.FindElementByName("namespace1.namespace1.element1Name.cpp"));
Assert.IsNotNull(dataModel.FindElementByName("namespace3.namespace4.element1Name.h"));
Assert.IsNull(dataModel.FindElementByName("namespace1.namespace1.element1Name.h"));
}
public void DoNotMergeWhenImplementationDependsOnHeaderFileWithOtherName()
{
DsiModel dataModel = new DsiModel("Test", Assembly.GetExecutingAssembly());
IDsiElement elementCpp = dataModel.AddElement("namespace1.namespace1.element1Name.cpp", "class", "");
IDsiElement elementH = dataModel.AddElement("namespace3.namespace4.ELEMENT1NAME.h", "class", "");
dataModel.AddRelation(elementCpp.Name, elementH.Name, "", 1, "context");
Assert.IsNotNull(dataModel.FindElementByName("namespace1.namespace1.element1Name.cpp"));
Assert.IsNotNull(dataModel.FindElementByName("namespace3.namespace4.ELEMENT1NAME.h"));
Assert.IsNull(dataModel.FindElementByName("namespace1.namespace1.element1Name.h"));
MoveHeaderElementsAction transformation = new MoveHeaderElementsAction(dataModel, true, null);
transformation.Execute();
Assert.IsNotNull(dataModel.FindElementByName("namespace1.namespace1.element1Name.cpp"));
Assert.IsNotNull(dataModel.FindElementByName("namespace3.namespace4.ELEMENT1NAME.h"));
Assert.IsNull(dataModel.FindElementByName("namespace1.namespace1.element1Name.h"));
}
public void TestAnalyze()
{
AnalyzerSettings analyzerSettings = new AnalyzerSettings
{
LoggingEnabled = true,
InputFilename = "example.dot",
};
IDsiModel model = new DsiModel("Test", Assembly.GetExecutingAssembly());
Jdeps.Analysis.Analyzer analyzer = new Jdeps.Analysis.Analyzer(model, analyzerSettings, null);
analyzer.Analyze();
Assert.AreEqual(5, model.TotalElementCount);
IDsiElement elementJavaxCryptoCipher = model.FindElementByName("javax.crypto.Cipher");
Assert.IsNotNull(elementJavaxCryptoCipher);
IDsiElement elementJavaxCryptoCipherTransform = model.FindElementByName("javax.crypto.Cipher.Transform");
Assert.IsNotNull(elementJavaxCryptoCipherTransform);
IDsiElement elementJavaxCryptoSpecRcsParameterSpec = model.FindElementByName("javax.crypto.spec.RC5ParameterSpec");
Assert.IsNotNull(elementJavaxCryptoSpecRcsParameterSpec);
IDsiElement elementSunSecurityJcaGetInstance = model.FindElementByName("sun.security.jca.GetInstance");
Assert.IsNotNull(elementSunSecurityJcaGetInstance);
IDsiElement elementJavaLangCharSequence = model.FindElementByName("java.lang.CharSequence");
Assert.IsNotNull(elementJavaLangCharSequence);
Assert.AreEqual(3, model.ResolvedRelationCount);
Assert.IsTrue(model.DoesRelationExist(elementJavaxCryptoCipher.Id, elementJavaxCryptoSpecRcsParameterSpec.Id));
Assert.IsTrue(model.DoesRelationExist(elementJavaxCryptoCipher.Id, elementSunSecurityJcaGetInstance.Id));
Assert.IsTrue(model.DoesRelationExist(elementJavaxCryptoCipherTransform.Id, elementJavaLangCharSequence.Id));
}
public void TestAnalyzePhysicalView()
{
AnalyzerSettings analyzerSettings = AnalyzerSettings.CreateDefault();
analyzerSettings.ExternalIncludeDirectories.Clear();
analyzerSettings.ViewMode = ViewMode.PhysicalView;
analyzerSettings.InputFilename = Path.Combine(TestData.SolutionDirectory, "DsmSuite.sln");
analyzerSettings.ExternalIncludeDirectories.Add(new ExternalIncludeDirectory {
Path = Path.Combine(TestData.TestDataDirectory, "DirExternal"), ResolveAs = "External"
});
analyzerSettings.InterfaceIncludeDirectories.Add(Path.Combine(TestData.TestDataDirectory, "DirInterfaces"));
analyzerSettings.RootDirectory = TestData.SolutionDirectory;
DsiModel dataModel = new DsiModel("Test", Assembly.GetExecutingAssembly());
Analyzer.VisualStudio.Analysis.Analyzer analyzer = new Analyzer.VisualStudio.Analysis.Analyzer(dataModel, analyzerSettings, null);
analyzer.Analyze();
HashSet <string> elementNames = new HashSet <string>();
Dictionary <string, HashSet <string> > providerNames = new Dictionary <string, HashSet <string> >();
foreach (IDsiElement element in dataModel.GetElements())
{
elementNames.Add(element.Name);
foreach (IDsiRelation relation in dataModel.GetRelationsOfConsumer(element.Id))
{
if (!providerNames.ContainsKey(element.Name))
{
providerNames[element.Name] = new HashSet <string>();
}
IDsiElement provider = dataModel.FindElementById(relation.ProviderId);
providerNames[element.Name].Add(provider.Name);
}
}
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirA.ClassA1.h"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirA.ClassA1.cpp"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirA.ClassA2.h"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirA.ClassA2.cpp"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirA.ClassA3.h"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirB.ClassB1.h"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirB.ClassB1.cpp"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirC.ClassC1.h"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirC.ClassC1.cpp"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirD.ClassD1.h"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirD.ClassD1.cpp"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirClones.Identical.ClassA1.cpp"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirClones.Identical.CopyClassA1.cpp"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirClones.NotIdentical.ClassA1.cpp"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirIDL.IInterface1.idl"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.IdlOutput.IInterface1.h"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.IdlOutput.IInterface1_i.c"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.IdlOutput.MyTypeLibrary.tlb"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirIDL.IInterface2.idl"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.IdlOutput.IInterface2.h"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.IdlOutput.IInterface2_i.c"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.IdlOutput.DsmSuite.Analyzer.VisualStudio.Test.Data.tlb"));
Assert.IsTrue(elementNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.targetver.h"));
Assert.IsTrue(elementNames.Contains("External.External.h"));
HashSet <string> classA2ProviderNames = providerNames["DsmSuite.Analyzer.VisualStudio.Test.Data.DirA.ClassA2.cpp"];
Assert.IsTrue(classA2ProviderNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirA.ClassA2.h"));
Assert.IsTrue(classA2ProviderNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirA.ClassA1.h"));
Assert.IsTrue(classA2ProviderNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirB.ClassB1.h"));
Assert.IsTrue(classA2ProviderNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirC.ClassC1.h"));
Assert.IsTrue(classA2ProviderNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirD.ClassD1.h"));
Assert.IsTrue(classA2ProviderNames.Contains("External.External.h"));
Assert.IsTrue(classA2ProviderNames.Contains("DsmSuite.Analyzer.VisualStudio.Test.Data.DirA.ClassA3.h"));
}
public void RenameOnlyMatchingElements()
{
DsiModel dataModel = new DsiModel("Test", System.Reflection.Assembly.GetExecutingAssembly());
dataModel.AddElement("element1Name", "class", "element1Source");
dataModel.AddElement("element2Name", "class", "element2Source");
IDsiElement element1Before = dataModel.FindElementByName("element1Name");
Assert.IsNotNull(element1Before);
IDsiElement element2Before = dataModel.FindElementByName("element2Name");
Assert.IsNotNull(element2Before);
IDsiElement element3Before = dataModel.FindElementByName("element3Name");
Assert.IsNull(element3Before);
IDsiElement element4Before = dataModel.FindElementByName("element4Name");
Assert.IsNull(element4Before);
MoveElementsSettings moveElementsSettings = new MoveElementsSettings
{
Enabled = true,
Rules = new List <MoveElementRule>
{
new MoveElementRule()
{
From = "element1Name", To = "element3Name"
},
new MoveElementRule()
{
From = "ELEMENT2NAME", To = "element4Name"
}
}
};
MoveElementsAction transformation = new MoveElementsAction(dataModel, moveElementsSettings, null);
transformation.Execute();
IDsiElement element1After = dataModel.FindElementByName("element1Name");
Assert.IsNull(element1After);
IDsiElement element2After = dataModel.FindElementByName("element2Name");
Assert.IsNotNull(element2After);
IDsiElement element3After = dataModel.FindElementByName("element3Name");
Assert.IsNotNull(element3After);
IDsiElement element4After = dataModel.FindElementByName("element4Name");
Assert.IsNull(element4After);
// Element1 renamed
Assert.AreEqual(element1Before.Id, element3After.Id);
Assert.AreEqual("element3Name", element3After.Name);
Assert.AreEqual(element1Before.Type, element3After.Type);
Assert.AreEqual(element1Before.Source, element3After.Source);
// Element2 not renamed because replace is case sensitive
Assert.AreEqual(element2Before.Id, element2After.Id);
Assert.AreEqual(element2Before.Name, element2After.Name);
Assert.AreEqual(element2Before.Type, element2After.Type);
Assert.AreEqual(element2Before.Source, element2After.Source);
}
public void TestAnalyze()
{
AnalyzerSettings analyzerSettings = new AnalyzerSettings
{
LoggingEnabled = true,
AssemblyDirectory = TestData.RootDirectory,
IgnoredNames = new List <string>()
};
IDsiModel model = new DsiModel("Test", Assembly.GetExecutingAssembly());
DotNet.Analysis.Analyzer analyzer = new DotNet.Analysis.Analyzer(model, analyzerSettings, null);
analyzer.Analyze();
// Main elements
IDsiElement elementMainClient = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.MainClient");
Assert.IsNotNull(elementMainClient);
IDsiElement elementMainType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.MainType");
Assert.IsNotNull(elementMainType);
IDsiElement elementMainTypeMyDelegate = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.MainType/MyDelegate");
Assert.IsNotNull(elementMainTypeMyDelegate);
IDsiElement elementMainTypeAnonymous = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.MainType/<>c");
Assert.IsNotNull(elementMainTypeAnonymous);
IDsiElement elementInterfaceA = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.InterfaceA");
Assert.IsNotNull(elementInterfaceA);
IDsiElement elementBaseType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.BaseType");
Assert.IsNotNull(elementBaseType);
IDsiElement elementNestedType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.MainType/NestedType");
Assert.IsNotNull(elementNestedType);
// Fields
IDsiElement elementFieldType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.FieldType");
Assert.IsNotNull(elementFieldType);
IDsiElement elementGenericFieldType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.GenericFieldType`1");
Assert.IsNotNull(elementGenericFieldType);
IDsiElement elementGenericFieldTypeParameter = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.GenericFieldTypeParameter");
Assert.IsNotNull(elementGenericFieldTypeParameter);
// Properties
IDsiElement elementPropertyType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.PropertyType");
Assert.IsNotNull(elementPropertyType);
IDsiElement elementPropertyEnum = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.PropertyEnum");
Assert.IsNotNull(elementPropertyEnum);
IDsiElement elementGenericPropertyType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.GenericPropertyType`1");
Assert.IsNotNull(elementGenericPropertyType);
IDsiElement elementGenericPropertyTypeParameter = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.GenericPropertyTypeParameter");
Assert.IsNotNull(elementGenericPropertyTypeParameter);
// Method variables
IDsiElement elementMethodVariableType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.MethodVariableType");
Assert.IsNotNull(elementMethodVariableType);
// Parameters
IDsiElement elementParameterEnum = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.ParameterEnum");
Assert.IsNotNull(elementParameterEnum);
IDsiElement elementParameterType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.ParameterType");
Assert.IsNotNull(elementParameterType);
IDsiElement elementGenericParameterType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.GenericParameterType`1");
Assert.IsNotNull(elementGenericParameterType);
IDsiElement elementGenericParameterTypeParameter = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.GenericParameterTypeParameter");
Assert.IsNotNull(elementGenericParameterTypeParameter);
// Return types
IDsiElement elementReturnType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.ReturnType");
Assert.IsNotNull(elementReturnType);
IDsiElement elementReturnEnum = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.ReturnEnum");
Assert.IsNotNull(elementReturnEnum);
IDsiElement elementGenericReturnType = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.GenericReturnType`1");
Assert.IsNotNull(elementGenericReturnType);
IDsiElement elementGenericReturnTypeParameter = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.GenericReturnTypeParameter");
Assert.IsNotNull(elementGenericReturnTypeParameter);
IDsiElement elementDelegateGenericParameter = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.DelegateGenericParameter");
Assert.IsNotNull(elementDelegateGenericParameter);
IDsiElement elementEventsArgsGenericParameter = model.FindElementByName("DsmSuite.Analyzer.DotNet.Test.Data.EventsArgsGenericParameter");
Assert.IsNotNull(elementEventsArgsGenericParameter);
// Main relations
Assert.IsTrue(model.DoesRelationExist(elementMainClient.Id, elementMainType.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainClient.Id, elementEventsArgsGenericParameter.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementNestedType.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementMainTypeAnonymous.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementMainTypeMyDelegate.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainTypeAnonymous.Id, elementMainTypeMyDelegate.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainTypeAnonymous.Id, elementDelegateGenericParameter.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainTypeAnonymous.Id, elementDelegateGenericParameter.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementInterfaceA.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementBaseType.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementEventsArgsGenericParameter.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementDelegateGenericParameter.Id));
// Field relations
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementFieldType.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementGenericFieldType.Id));
// Property relations
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementPropertyType.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementPropertyEnum.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementGenericPropertyType.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementGenericPropertyTypeParameter.Id));
// Method variable relations
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementMethodVariableType.Id));
// Parameters type relations
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementParameterEnum.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementParameterType.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementGenericParameterType.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementGenericParameterTypeParameter.Id));
Assert.IsTrue(model.DoesRelationExist(elementInterfaceA.Id, elementParameterEnum.Id));
Assert.IsTrue(model.DoesRelationExist(elementInterfaceA.Id, elementParameterType.Id));
Assert.IsTrue(model.DoesRelationExist(elementInterfaceA.Id, elementGenericParameterType.Id));
Assert.IsTrue(model.DoesRelationExist(elementInterfaceA.Id, elementGenericParameterTypeParameter.Id));
// Return type relations
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementReturnType.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementReturnEnum.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementGenericReturnType.Id));
Assert.IsTrue(model.DoesRelationExist(elementMainType.Id, elementGenericReturnTypeParameter.Id));
Assert.IsTrue(model.DoesRelationExist(elementInterfaceA.Id, elementReturnType.Id));
Assert.IsTrue(model.DoesRelationExist(elementInterfaceA.Id, elementReturnEnum.Id));
Assert.IsTrue(model.DoesRelationExist(elementInterfaceA.Id, elementGenericReturnType.Id));
Assert.IsTrue(model.DoesRelationExist(elementInterfaceA.Id, elementGenericReturnTypeParameter.Id));
}
