public void ShouldBeOk()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestProperties.cs"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Namespace, document.First().Kind);
// Namespace item should have 1 member
Assert.AreEqual(1, (document.First() as IMembers).Members.Count);
// Inner item should be a class
var innerClass = (document.First() as IMembers).Members.First() as CodeClassItem;
// Inheriting class should have properties
var propertyGetSet = innerClass.Members.First() as CodeFunctionItem;
Assert.AreEqual(" {get,set}", propertyGetSet.Parameters);
var propertyGet = innerClass.Members[1] as CodeFunctionItem;
Assert.AreEqual(" {get}", propertyGet.Parameters);
var propertySet = innerClass.Members[2] as CodeFunctionItem;
Assert.AreEqual(" {set}", propertySet.Parameters);
var property = innerClass.Members.Last() as CodeFunctionItem;
Assert.IsNull(property.Parameters);
}
internal static string FormatCode(string script, ref int caret)
{
Output.WriteLine("FormatCode");
string code = File.ReadAllText(script);
if (code.IsEmpty())
{
throw new Exception("The file containing code is empty");
}
bool escape_vs_template_var = code.Contains("$safeprojectname$");
if (escape_vs_template_var)
{
code = code.Replace("$safeprojectname$", "_safeprojectname_");
}
string formattedCode = RoslynIntellisense.Formatter.FormatHybrid(code, "code.cs");
if (escape_vs_template_var)
{
formattedCode = formattedCode.Replace("_safeprojectname_", "$safeprojectname$");
}
caret = SyntaxMapper.MapAbsPosition(code, caret, formattedCode);
fullyLoaded = true;
return(formattedCode);
}
public void ShouldBeOkVB()
{
var document = SyntaxMapper.MapDocumentVB(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\VisualBasic\\TestProperties.vb"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Class, document.First().Kind);
// Inner item should be a class
var innerClass = document.First() as CodeClassItem;
// Class should have properties
var propertyGetSet = innerClass.Members.First() as CodeFunctionItem;
Assert.AreEqual(" {get,set}", propertyGetSet.Parameters);
var propertyGet = innerClass.Members[1] as CodeFunctionItem;
Assert.AreEqual(" {get}", propertyGet.Parameters);
var propertySet = innerClass.Members[2] as CodeFunctionItem;
Assert.AreEqual(" {set}", propertySet.Parameters);
var property = innerClass.Members[3] as CodeFunctionItem;
Assert.IsNull(property.Parameters);
var propertyShorthand = innerClass.Members[4] as CodeFunctionItem;
Assert.AreEqual("String", property.Type);
}
public void TestInterfaceShouldBeOk()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestInterface.cs"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Namespace, document.First().Kind);
// Namespace item should have 2 members
Assert.AreEqual(3, (document.First() as IMembers).Members.Count);
// First item should be an interface
var innerInterface = (document.First() as IMembers).Members.First() as CodeInterfaceItem;
Assert.AreEqual(3, innerInterface.Members.Count);
// Second item should be the implementing class
var implementingClass = (document.First() as IMembers).Members[1] as CodeClassItem;
Assert.AreEqual(CodeItemKindEnum.Class, implementingClass.Kind);
Assert.AreEqual(3, implementingClass.Members.Count);
var implementedInterface = implementingClass.Members.Last() as CodeImplementedInterfaceItem;
Assert.AreEqual(CodeItemKindEnum.ImplementedInterface, implementedInterface.Kind);
Assert.AreEqual(3, implementedInterface.Members.Count);
Assert.IsFalse(implementedInterface.Name.StartsWith("#"));
// Items should have proper start lines
Assert.AreEqual(12, implementedInterface.Members[0].StartLine);
Assert.AreEqual(17, implementedInterface.Members[1].StartLine);
Assert.AreEqual(34, implementedInterface.Members[2].StartLine);
}
public void ShouldHaveCorrectStructure()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestNestedNamespaces.cs"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Namespace, document.First().Kind);
// Namespace item should have members
Assert.IsTrue((document.First() as IMembers).Members.Any());
// Inner item should also be a namespace
var innerNamespace = (document.First() as IMembers).Members.First() as CodeNamespaceItem;
Assert.AreEqual(CodeItemKindEnum.Namespace, innerNamespace.Kind);
// That inner namespace should have members
Assert.IsTrue(innerNamespace.Members.Any());
// That member should be a class
var innerClass = (innerNamespace as IMembers).Members.First() as CodeClassItem;
Assert.AreEqual(CodeItemKindEnum.Class, innerClass.Kind);
Assert.AreEqual("ClassInNestedNamespace", innerClass.Name);
}
public void TestInterfaceInRegionShouldBeOk()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestInterface.cs"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Namespace, document.First().Kind);
// Namespace item should have 2 members
Assert.AreEqual(3, (document.First() as IMembers).Members.Count);
// Third item should be a implementing class
var implementingClass = (document.First() as IMembers).Members.Last() as CodeClassItem;
Assert.AreEqual(CodeItemKindEnum.Class, implementingClass.Kind);
Assert.AreEqual(3, implementingClass.Members.Count);
var region = implementingClass.Members.Last() as CodeRegionItem;
var implementedInterface = region.Members.First() as CodeImplementedInterfaceItem;
Assert.AreEqual(CodeItemKindEnum.ImplementedInterface, implementedInterface.Kind);
Assert.AreEqual(3, implementedInterface.Members.Count);
}
public void TestRegionsSpan()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestRegions.cs"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Namespace, document.First().Kind);
// There should be a single class
var regionClass = (document.First() as IMembers).Members.First() as CodeClassItem;
Assert.NotNull(regionClass);
// The class should have a function in it
Assert.NotNull(regionClass.Members.FirstOrDefault(m => m.Name.Equals("OutsideRegionFunction")));
// The class should have a region in it
var regionR1 = regionClass.Members.FirstOrDefault(m => m.Name.Equals("#R1")) as CodeRegionItem;
Assert.NotNull(regionR1, "Region #R1 not found");
// The region should have correct span for outlining usages
Assert.AreEqual(101, regionR1.Span.Start);
Assert.AreEqual(111, regionR1.Span.End);
}
public void TestSealedShouldBeOk()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestSealed.cs"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Namespace, document.First().Kind);
// Namespace item should have 3 members
Assert.AreEqual(3, (document.First() as IMembers).Members.Count);
// Inner item should be a sealed class
var sealedBaseClass = (document.First() as IMembers).Members.First() as CodeClassItem;
Assert.AreEqual(CodeItemKindEnum.Class, sealedBaseClass.Kind);
Assert.AreEqual("SealedBaseClass", sealedBaseClass.Name);
Assert.AreEqual(CodeItemAccessEnum.Sealed, sealedBaseClass.Access);
// Inheriting Class should be there
var inheritingClass = (document.First() as IMembers).Members.Last() as CodeClassItem;
Assert.AreEqual(CodeItemKindEnum.Class, inheritingClass.Kind);
Assert.AreEqual("InheritingClass", inheritingClass.Name);
Assert.AreEqual(CodeItemAccessEnum.Public, inheritingClass.Access);
Assert.AreEqual(" : BaseClass", inheritingClass.Parameters);
// Inheriting class should have sealed property
var sealedProperty = inheritingClass.Members.Last() as CodeFunctionItem;
Assert.AreEqual(CodeItemKindEnum.Property, sealedProperty.Kind);
Assert.AreEqual("BaseProperty", sealedProperty.Name);
Assert.AreEqual(CodeItemAccessEnum.Sealed, sealedProperty.Access);
Assert.AreEqual("BaseProperty {get,set}", sealedProperty.Parameters);
}
public void TestRegions()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestRegions.cs"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Namespace, document.First().Kind);
// There should be a single class
var regionClass = (document.First() as IMembers).Members.First() as CodeClassItem;
Assert.NotNull(regionClass);
// The class should have a function in it
Assert.NotNull(regionClass.Members.FirstOrDefault(m => m.Name.Equals("OutsideRegionFunction")));
// The class should have a region in it
var regionR1 = regionClass.Members.FirstOrDefault(m => m.Name.Equals("#R1")) as CodeRegionItem;
Assert.NotNull(regionR1);
// Region R1 should have a nested region R15 with a constant in it
var regionR15 = regionR1.Members.FirstOrDefault(m => m.Name.Equals("#R15")) as CodeRegionItem;
Assert.NotNull(regionR15);
Assert.NotNull(regionR15.Members.FirstOrDefault(m => m.Name.Equals("nestedRegionConstant")));
// Region R1 should have a function Test1 and Test2 in it
Assert.NotNull(regionR1.Members.FirstOrDefault(m => m.Name.Equals("Test1")));
Assert.NotNull(regionR1.Members.FirstOrDefault(m => m.Name.Equals("Test2")));
}
public void ShouldMapPositionInFormattedCode()
{
string rawCode =
@"void main()
{
Cons|ole.WriteLine(""Hello World!"");
Debug.WriteLine(""Hello World!"");
}";
string formattedCode =
@"void main()
{
Cons|ole.WriteLine(""Hello World!"");
Debug.WriteLine(""Hello World!"");
}";
int pos = rawCode.IndexOf('|');
int expectedNewPos = formattedCode.IndexOf('|');
rawCode = rawCode.Replace("|", "");
formattedCode = formattedCode.Replace("|", "");
int newPos = SyntaxMapper.MapAbsPosition(rawCode, pos, formattedCode);
Assert.Equal(expectedNewPos, newPos);
}
public void ShouldBeOk()
{
SettingsHelper.UseXMLComments = true;
var document = SyntaxMapper.MapDocumentVB(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\VisualBasic\\TestMethodsWithComments.vb"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Class, document.First().Kind);
// Inner item should be a class
var innerClass = document.First() as CodeClassItem;
// Class should have a method
var methodWithComment = innerClass.Members.First() as CodeFunctionItem;
Assert.AreEqual("Super important summary", methodWithComment.Tooltip);
// Class should have a method
var methodWithoutComment = innerClass.Members[1] as CodeFunctionItem;
Assert.AreEqual("Private Object FunctionWithoutComment ()", methodWithoutComment.Tooltip);
// Class should have a method
var methodWithMultipleComment = innerClass.Members[2] as CodeFunctionItem;
Assert.AreEqual("Multiple comment - summary", methodWithMultipleComment.Tooltip);
// Class should have a method
var methodWithReorderedComment = innerClass.Members[3] as CodeFunctionItem;
Assert.AreEqual("Multiple comment - summary", methodWithReorderedComment.Tooltip);
}
private void BackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
try
{
var result = e.Result as BackgroundWorkerResult;
if (result?.CodeItems == null)
{
LogHelper.Log($"CodeNav for '{DocumentHelper.GetName(_window)}' updated, no results");
return;
}
// Filter all null items from the code document
SyntaxMapper.FilterNullItems(result.CodeItems);
// Do we need to update the DataContext?
var areEqual = AreDocumentsEqual(CodeDocumentViewModel.CodeDocument, result.CodeItems);
if (result.ForceUpdate == false && areEqual)
{
LogHelper.Log($"CodeNav for '{DocumentHelper.GetName(_window)}' updated, document did not change");
// Should the margin be shown and are there any items to show, if not hide the margin
VisibilityHelper.SetMarginWidth(_column, CodeDocumentViewModel.CodeDocument);
return;
}
// Set the new list of codeitems as DataContext
CodeDocumentViewModel.CodeDocument = result.CodeItems;
_cache = result.CodeItems;
// Set currently active codeitem
HighlightHelper.SetForeground(CodeDocumentViewModel.CodeDocument);
// Should the margin be shown and are there any items to show, if not hide the margin
VisibilityHelper.SetMarginWidth(_column, CodeDocumentViewModel.CodeDocument);
// Apply current visibility settings to the document
VisibilityHelper.SetCodeItemVisibility(CodeDocumentViewModel.CodeDocument);
// Sync all regions
OutliningHelper.SyncAllRegions(OutliningManager, TextView, CodeDocumentViewModel.CodeDocument);
// Sort items
CodeDocumentViewModel.SortOrder = Settings.Default.SortOrder;
SortHelper.Sort(CodeDocumentViewModel);
// Apply bookmarks
LoadBookmarksFromStorage();
BookmarkHelper.ApplyBookmarks(CodeDocumentViewModel, Dte?.Solution?.FileName);
LogHelper.Log($"CodeNav for '{DocumentHelper.GetName(_window)}' updated");
}
catch (ObjectDisposedException ex)
{
LogHelper.Log($"CodeNav: RunWorkerCompleted exception: {ex.Message}");
LogHelper.Log("RunWorkerCompleted exception", ex);
}
}
public void ShouldHaveCorrectStructure()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestNoNamespace.cs"));
Assert.IsTrue(document.Any());
// First item should be a class
Assert.AreEqual(CodeItemKindEnum.Class, document.First().Kind);
}
public static List <CodeItem> MapFunction(Node function, NodeArray <ParameterDeclaration> parameters, string id, ICodeViewUserControl control)
{
if (function == null)
{
return(null);
}
List <CodeItem> children;
try
{
children = function.Children
.FirstOrDefault(c => c.Kind == SyntaxKind.Block)?.Children
.SelectMany(SyntaxMapperJS.MapMember)
.ToList();
}
catch (NullReferenceException)
{
return(new List <CodeItem>());
}
if (children != null && children.Any())
{
SyntaxMapper.FilterNullItems(children);
var item = BaseMapperJS.MapBase <CodeClassItem>(function, id, control);
item.BorderColor = Colors.DarkGray;
item.Kind = CodeItemKindEnum.Method;
item.Parameters = $"({string.Join(", ", parameters.Select(p => p.IdentifierStr))})";
item.Tooltip = TooltipMapper.Map(item.Access, null, item.Name, item.Parameters);
item.Id = IdMapper.MapId(item.FullName, parameters);
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.Members = children;
return(new List <CodeItem> {
item
});
}
CodeFunctionItem functionItem = BaseMapperJS.MapBase <CodeFunctionItem>(function, id, control);
functionItem.Kind = CodeItemKindEnum.Method;
functionItem.Parameters = $"({string.Join(", ", parameters.Select(p => p.IdentifierStr))})";
functionItem.Tooltip = TooltipMapper.Map(functionItem.Access, null, functionItem.Name, functionItem.Parameters);
functionItem.Id = IdMapper.MapId(functionItem.FullName, parameters);
functionItem.Moniker = IconMapper.MapMoniker(functionItem.Kind, functionItem.Access);
return(new List <CodeItem> {
functionItem
});
}
public void Setup()
{
var document = SyntaxMapper.MapDocumentVB(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\VisualBasic\\TestMethods.vb"));
Assert.IsTrue(document.Any());
// First item should be a class
Assert.AreEqual(CodeItemKindEnum.Class, document.First().Kind);
// Inner item should be a class
_innerClass = document.First() as CodeClassItem;
}
public void TestInterfaceShouldBeOkVB()
{
var document = SyntaxMapper.MapDocumentVB(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\VisualBasic\\TestInterfaces.vb"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Interface, document.First().Kind);
// Namespace item should have 1 member
Assert.AreEqual(1, (document.First() as IMembers).Members.Count);
}
public void ShouldBeOk()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestEmptyInterface.cs"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Namespace, document.First().Kind);
// Namespace item should not have members
Assert.IsTrue(!(document.First() as IMembers).Members.Any());
}
public void ShouldMapPositionInFormattedCodeLineStart()
{
string rawCode =
@"void main()
{
}";
string formattedCode = rawCode;
int pos = 0;
int newPos = SyntaxMapper.MapAbsPosition(rawCode, pos, formattedCode);
Assert.Equal(pos, newPos);
}
public void EnumsShouldBeOkVB()
{
var document = SyntaxMapper.MapDocumentVB(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\VisualBasic\\TestModules.vb"));
Assert.IsTrue(document.Any());
var innerEnum = (document.First() as IMembers).Members.First() as CodeClassItem;
// First inner item should be an enum
Assert.AreEqual(CodeItemKindEnum.Enum, innerEnum.Kind);
// Enum should have 5 members
Assert.AreEqual(5, innerEnum.Members.Count());
}
public void CurrentItemShouldBeHighlighted()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestProperties.cs"));
HighlightHelper.HighlightCurrentItem(document, 13, Brushes.Red, Brushes.Blue, Brushes.Green, Brushes.White);
var highlightedClass = (document.First() as IMembers).Members.First() as CodeClassItem;
var highlightedItem = highlightedClass.Members[2];
Assert.AreEqual(FontWeights.Bold, highlightedItem.FontWeight);
Assert.AreEqual(Brushes.Red, highlightedItem.Foreground);
Assert.AreEqual(Brushes.Blue, highlightedItem.HighlightBackground);
Assert.AreEqual(Brushes.Green, highlightedClass.BorderBrush);
}
public void OnlyOneItemShouldBeHighlighted()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestProperties.cs"));
HighlightHelper.HighlightCurrentItem(document, 13, Brushes.Red, Brushes.Blue, Brushes.Green, Brushes.White);
HighlightHelper.HighlightCurrentItem(document, 18, Brushes.Red, Brushes.Blue, Brushes.Green, Brushes.White);
var highlightedItems = new List <CodeItem>();
FindHighlightedItems(highlightedItems, document);
Assert.AreEqual(1, highlightedItems.Count);
}
private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
if (!_backgroundWorker.CancellationPending)
{
var request = e.Argument as BackgroundWorkerRequest;
if (request == null)
{
return;
}
var codeItems = SyntaxMapper.MapDocument(request.Document, this, _workspace);
e.Result = new BackgroundWorkerResult {
CodeItems = codeItems, ForceUpdate = request.ForceUpdate
};
}
}
public void ClassInheritanceShouldBeOkVB()
{
var document = SyntaxMapper.MapDocumentVB(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\VisualBasic\\TestClasses.vb"));
Assert.IsTrue(document.Any());
// First item should be a base class
Assert.AreEqual(CodeItemKindEnum.Class, document.First().Kind);
var innerClass = document.First() as CodeClassItem;
// Second item should be an inheriting class
Assert.AreEqual(CodeItemKindEnum.Class, document.Last().Kind);
var inheritingClass = document.Last() as CodeClassItem;
Assert.AreEqual(" : Class1", inheritingClass.Parameters);
}
public void ItemsSorting(SortOrderEnum sortOrder, string[] methodNames)
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestSorting.cs"));
var viewModel = new CodeDocumentViewModel {
CodeDocument = document, SortOrder = sortOrder
};
viewModel.CodeDocument = SortHelper.Sort(viewModel);
var sortingClass = (document.First() as IMembers).Members.First() as CodeClassItem;
Assert.AreEqual(methodNames[0], sortingClass.Members.First().Name);
Assert.AreEqual(methodNames[1], sortingClass.Members[1].Name);
Assert.AreEqual(methodNames[2], sortingClass.Members.Last().Name);
Assert.AreEqual(sortOrder, viewModel.SortOrder);
}
public void TestBaseImplementedInterfaceShouldBeOk()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestInterface3.cs"));
Assert.IsTrue(document.Any());
// last item should be the implementing class
var implementingClass = (document.First() as IMembers).Members.Last() as CodeClassItem;
Assert.AreEqual(CodeItemKindEnum.Class, implementingClass.Kind);
Assert.AreEqual(1, implementingClass.Members.Count);
var implementedInterface = implementingClass.Members.First() as CodeImplementedInterfaceItem;
Assert.AreEqual(CodeItemKindEnum.ImplementedInterface, implementedInterface.Kind);
Assert.AreEqual(1, implementedInterface.Members.Count);
}
public void ShouldBeOk()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestIndexers.cs"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Namespace, document.First().Kind);
// Inner item should be a class
var innerClass = (document.First() as CodeNamespaceItem).Members.First() as CodeClassItem;
// Class should have an indexer
var indexer = innerClass.Members.First() as CodeFunctionItem;
Assert.AreEqual(CodeItemKindEnum.Indexer, indexer.Kind);
}
public void TestRegionsNoName()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestRegionsNoName.cs"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Namespace, document.First().Kind);
// There should be a single class
var regionClass = (document.First() as IMembers).Members.First() as CodeClassItem;
Assert.NotNull(regionClass);
// The class should have a region in it
var regionR1 = regionClass.Members.FirstOrDefault(m => m.Name.Equals("#Region")) as CodeRegionItem;
Assert.NotNull(regionR1, "Region #Region not found");
}
public void TestUsingsInNamespaceShouldBeOk()
{
var document = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestUsingsInNamespace.cs"));
Assert.IsTrue(document.Any());
// First item should be a namespace
Assert.AreEqual(CodeItemKindEnum.Namespace, document.First().Kind);
// Namespace item should have 1 member
Assert.AreEqual(1, (document.First() as IMembers).Members.Count);
// Item should be a class
var innerClass = (document.First() as IMembers).Members.First() as CodeClassItem;
Assert.AreEqual(CodeItemKindEnum.Class, innerClass.Kind);
Assert.AreEqual(2, innerClass.Members.Count);
Assert.AreEqual(CodeItemKindEnum.Constructor, innerClass.Members.First().Kind);
Assert.AreEqual(CodeItemKindEnum.Method, innerClass.Members.Last().Kind);
}
private void BackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
var result = e.Result as BackgroundWorkerResult;
if (result?.CodeItems == null)
{
LogHelper.Log($"CodeNav for '{_window.Document.Name}' updated, no results");
return;
}
// Filter all null items from the code document
SyntaxMapper.FilterNullItems(result.CodeItems);
// Do we need to update the DataContext?
var areEqual = AreDocumentsEqual(CodeDocumentViewModel.CodeDocument, result.CodeItems);
if (result.ForceUpdate == false && areEqual)
{
LogHelper.Log($"CodeNav for '{_window.Document.Name}' updated, document did not change");
return;
}
// Set the new list of codeitems as DataContext
CodeDocumentViewModel.CodeDocument = result.CodeItems;
_cache = result.CodeItems;
// Set currently active codeitem
HighlightHelper.SetForeground(CodeDocumentViewModel.CodeDocument);
// Are there any items to show, if not hide the margin
VisibilityHelper.SetMarginWidth(_column, CodeDocumentViewModel.CodeDocument);
// Apply current visibility settings to the document
VisibilityHelper.SetCodeItemVisibility(CodeDocumentViewModel.CodeDocument);
// Sync all regions
OutliningHelper.SyncAllRegions(_outliningManager, _textView, CodeDocumentViewModel.CodeDocument);
LogHelper.Log($"CodeNav for '{_window.Document.Name}' updated");
}
public void TestRegionsVB()
{
var document = SyntaxMapper.MapDocumentVB(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\VisualBasic\\TestRegions.vb"));
Assert.IsTrue(document.Any());
// There should be a single class
var regionClass = document.First() as CodeClassItem;
Assert.NotNull(regionClass);
// The class should have a property in it
Assert.NotNull(regionClass.Members.FirstOrDefault(m => m.Name.Equals("outsideRegion$")));
// The class should have a region in it
var regionR1 = regionClass.Members.FirstOrDefault(m => m.Name.Equals("#FirstRegion")) as CodeRegionItem;
Assert.NotNull(regionR1, "Region #FirstRegion not found");
// Region R1 should have a property in it
Assert.NotNull(regionR1.Members.FirstOrDefault(m => m.Name.Equals("insideRegion$")), "No property inside region found");
}
