Skip to content

R
roslyn

lwm1986 / roslyn
与 Fork 源项目一致

从无法访问的项目Fork

通知 1
Star 0
Fork 0
R
roslyn

体验新版 GitCode，发现更多精彩内容 >>

提交 66944d3e 编写于 作者: D Dustin Campbell
浏览文件
操作

Convert C# outlining tests to 'FIT' style tests

上级 2bebe50f
展开全部 隐藏空白更改
内联 并排
Showing with 1619 addition and 3204 deletion
src/EditorFeatures/CSharp/Outlining/Outliners/MetadataAsSource/OperatorDeclarationOutliner.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource
......@@ -11,7 +10,7 @@ protected override SyntaxToken GetEndToken(OperatorDeclarationSyntax node)
{
return node.Modifiers.Count > 0
? node.Modifiers.First()
: node.OperatorKeyword;
: node.ReturnType.GetFirstToken();
}
}
}
src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj
浏览文件 @ 66944d3e
......@@ -310,7 +310,6 @@
<Compile Include="Organizing\OrganizeModifiersTests.cs" />
<Compile Include="Organizing\OrganizeTypeDeclarationTests.cs" />
<Compile Include="Organizing\OrganizeUsingsTests.cs" />
<Compile Include="Outlining\AbstractOutlinerTests.cs" />
<Compile Include="Outlining\AbstractOutlinerTests`1.cs" />
<Compile Include="Outlining\AccessorDeclarationTests.cs" />
<Compile Include="Outlining\AnonymousMethodExpressionTests.cs" />
......@@ -351,6 +350,7 @@
<Compile Include="Outlining\RegionDirectiveOutlinerTests.cs" />
<Compile Include="Outlining\SimpleLambdaExpressionOutlinerTests.cs" />
<Compile Include="Outlining\TypeDeclarationOutlinerTests.cs" />
<Compile Include="Outlining\Utils.cs" />
<Compile Include="QuickInfo\SemanticQuickInfoSourceTests.cs" />
<Compile Include="QuickInfo\SyntacticQuickInfoSourceTests.cs" />
<Compile Include="Semantics\SpeculationAnalyzerTests.cs" />
......
src/EditorFeatures/CSharpTest/Outlining/AbstractOutlinerTests`1.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Editor.UnitTests.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
public abstract class AbstractOutlinerTests<TSyntaxNode> :
AbstractOutlinerTests
public abstract class AbstractOutlinerTests<TSyntaxNode> : AbstractOutlinerTests
where TSyntaxNode : SyntaxNode
{
internal virtual IEnumerable<OutliningSpan> GetRegions(TSyntaxNode node)
internal abstract AbstractSyntaxNodeOutliner<TSyntaxNode> CreateOutliner();
internal IEnumerable<OutliningSpan> GetRegions(TSyntaxNode node)
{
return Enumerable.Empty<OutliningSpan>();
var outliner = CreateOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
}
internal OutliningSpan GetRegion(TSyntaxNode node)
......@@ -27,32 +33,70 @@ internal OutliningSpan GetRegion(TSyntaxNode node)
return regions[0];
}
protected void TestTrivia(string expectedRegionName, string code, SyntaxKind expectedKind, bool autoCollapse)
protected Tuple<string, string, string, bool, bool> Region(string collapseSpanName, string hintSpanName, string bannerText, bool autoCollapse, bool isDefaultCollapsed = false)
{
return Tuple.Create(collapseSpanName, hintSpanName, bannerText, autoCollapse, isDefaultCollapsed);
}
protected Tuple<string, string, string, bool, bool> Region(string collapseSpanName, string bannerText, bool autoCollapse, bool isDefaultCollapsed = false)
{
return Tuple.Create(collapseSpanName, collapseSpanName, bannerText, autoCollapse, isDefaultCollapsed);
}
protected void Regions(string markupCode, params Tuple<string, string, string, bool, bool>[] expectedRegions)
{
int caretPosition;
IList<TextSpan> spans;
MarkupTestFile.GetPositionAndSpans(code, out code, out caretPosition, out spans);
var tree = ParseCode(code);
var trivia = tree.GetRoot().FindTrivia(caretPosition);
var directive = trivia.GetStructure() as TSyntaxNode;
Assert.NotNull(directive);
Assert.Equal(expectedKind, directive.Kind());
var actualRegions = GetRegions(directive).ToArray();
if (spans.Count == 0)
string code;
int? position;
IDictionary<string, IList<TextSpan>> spans;
MarkupTestFile.GetPositionAndSpans(markupCode, out code, out position, out spans);
Assert.True(position.HasValue, "Can't find node! Test did not specify position.");
var compilationUnit = SyntaxFactory.ParseCompilationUnit(code);
var token = compilationUnit.FindToken(position.Value, findInsideTrivia: true);
var node = token.Parent.FirstAncestorOrSelf<TSyntaxNode>();
Assert.NotNull(node);
var actualRegions = GetRegions(node).ToArray();
Assert.True(expectedRegions.Length == actualRegions.Length, $"Expected {expectedRegions.Length} regions but there were {actualRegions.Length}");
for (int i = 0; i < actualRegions.Length; i++)
{
Assert.Equal(0, actualRegions.Length);
return;
var actualRegion = actualRegions[i];
var expectedRegion = expectedRegions[i];
var collapseSpanName = expectedRegion.Item1;
var hintSpanName = expectedRegion.Item2;
var bannerText = expectedRegion.Item3;
var autoCollapse = expectedRegion.Item4;
var isDefaultCollapsed = expectedRegion.Item5;
Assert.True(spans.ContainsKey(collapseSpanName) && spans[collapseSpanName].Count == 1, $"Test did not specify '{collapseSpanName}' span.");
Assert.True(spans.ContainsKey(hintSpanName) && spans[hintSpanName].Count == 1, $"Test did not specify '{hintSpanName}' span.");
var collapseSpan = spans[collapseSpanName][0];
var hintSpan = spans[hintSpanName][0];
AssertRegion(new OutliningSpan(collapseSpan, hintSpan, bannerText, autoCollapse, isDefaultCollapsed), actualRegion);
}
}
protected void NoRegions(string markupCode)
{
string code;
int? position;
IDictionary<string, IList<TextSpan>> spans;
MarkupTestFile.GetPositionAndSpans(markupCode, out code, out position, out spans);
Assert.True(position.HasValue, "Can't find node! Test did not specify position.");
Assert.Equal(1, actualRegions.Length);
var expectedRegion = new OutliningSpan(
spans[0],
expectedRegionName,
autoCollapse);
var compilationUnit = SyntaxFactory.ParseCompilationUnit(code);
var token = compilationUnit.FindToken(position.Value, findInsideTrivia: true);
var node = token.Parent.FirstAncestorOrSelf<TSyntaxNode>();
Assert.NotNull(node);
AssertRegion(expectedRegion, actualRegions[0]);
var actualRegions = GetRegions(node).ToArray();
Assert.True(actualRegions.Length == 0, $"Expected no regions but found {actualRegions.Length}.");
}
}
}
src/EditorFeatures/CSharpTest/Outlining/AnonymousMethodExpressionTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
public class AnonymousMethodExpressionTests :
AbstractOutlinerTests<AnonymousMethodExpressionSyntax>
public class AnonymousMethodExpressionTests : AbstractOutlinerTests<AnonymousMethodExpressionSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(AnonymousMethodExpressionSyntax lambdaExpression)
internal override AbstractSyntaxNodeOutliner<AnonymousMethodExpressionSyntax> CreateOutliner()
{
var outliner = new AnonymousMethodExpressionOutliner();
return outliner.GetOutliningSpans(lambdaExpression, CancellationToken.None).WhereNotNull();
return new AnonymousMethodExpressionOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestAnonymousMethod()
{
var tree = ParseLines("class C",
"{",
" void Main()",
" {",
" delegate {",
" x();",
" };",
" }",
"}");
var lambdaExpression = tree.GetRoot().FindFirstNodeOfType<AnonymousMethodExpressionSyntax>();
var actualRegion = GetRegion(lambdaExpression);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(45, 66),
TextSpan.FromBounds(36, 66),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: false);
const string code = @"
class C
{
void Main()
{
$${|hint:delegate {|collapse:{
x();
};|}|}
}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: false));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestAnonymousMethodInForLoop()
{
var tree = ParseLines("class C",
"{",
" void Main()",
" {",
" for (Action a = delegate { }; true; a()) { }",
" }",
"}");
var lambdaExpression = tree.GetRoot().FindFirstNodeOfType<AnonymousMethodExpressionSyntax>();
var actualRegions = GetRegions(lambdaExpression).ToList();
const string code = @"
class C
{
void Main()
{
for (Action a = $$delegate { }; true; a()) { }
}
}";
Assert.Equal(0, actualRegions.Count);
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestAnonymousMethodInMethodCall1()
{
var tree = ParseLines("class C",
"{",
" void Main()",
" {",
" someMethod(42, \"test\", false, delegate(int x, int y, int z) {",
" return x + y + z;",
" }, \"other arguments\");",
" }",
"}");
var lambdaExpression = tree.GetRoot().FindFirstNodeOfType<AnonymousMethodExpressionSyntax>();
var actualRegion = GetRegion(lambdaExpression);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(96, 131),
TextSpan.FromBounds(66, 131),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: false);
const string code = @"
class C
{
void Main()
{
someMethod(42, ""test"", false, {|hint:$$delegate(int x, int y, int z) {|collapse:{
return x + y + z;
}|}|}, ""other arguments"");
}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: false));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestAnonymousMethodInMethodCall2()
{
var tree = ParseLines("class C",
"{",
" void Main()",
" {",
" someMethod(42, \"test\", false, delegate(int x, int y, int z) {",
" return x + y + z;",
" });",
" }",
"}");
var lambdaExpression = tree.GetRoot().FindFirstNodeOfType<AnonymousMethodExpressionSyntax>();
var actualRegion = GetRegion(lambdaExpression);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(96, 131),
TextSpan.FromBounds(66, 131),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: false);
const string code = @"
class C
{
void Main()
{
someMethod(42, ""test"", false, {|hint:$$delegate(int x, int y, int z) {|collapse:{
return x + y + z;
}|}|});
}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: false));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/CommentTests.cs
浏览文件 @ 66944d3e
......@@ -3,9 +3,11 @@
using System.Linq;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Editor.UnitTests.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;
using static Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.Utils;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
......
src/EditorFeatures/CSharpTest/Outlining/CompilationUnitOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
public class CompilationUnitOutlinerTests : AbstractOutlinerTests<CompilationUnitSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(CompilationUnitSyntax node)
internal override AbstractSyntaxNodeOutliner<CompilationUnitSyntax> CreateOutliner()
{
var outliner = new CompilationUnitOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new CompilationUnitOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestUsings()
{
var tree = ParseLines("using System;",
"using System.Core;");
const string code = @"
$${|hint:using {|collapse:System;
using System.Core;|}|}";
var compilationUnit = tree.GetRoot() as CompilationUnitSyntax;
var actualRegion = GetRegion(compilationUnit);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(6, 33),
hintSpan: TextSpan.FromBounds(0, 33),
bannerText: CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestUsingAliases()
{
var tree = ParseLines("using System;",
"using System.Core;",
"using text = System.Text;",
"using linq = System.Linq;");
var compilationUnit = tree.GetRoot() as CompilationUnitSyntax;
var actualRegion = GetRegion(compilationUnit);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(6, 87),
hintSpan: TextSpan.FromBounds(0, 87),
bannerText: CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
const string code = @"
$${|hint:using {|collapse:System;
using System.Core;
using text = System.Text;
using linq = System.Linq;|}|}";
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestExternAliases()
{
var tree = ParseLines("extern alias Foo;",
"extern alias Bar;");
var compilationUnit = (CompilationUnitSyntax)tree.GetRoot();
const string code = @"
$${|hint:extern {|collapse:alias Foo;
extern alias Bar;|}|}";
var actualRegion = GetRegion(compilationUnit);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(7, 36),
hintSpan: TextSpan.FromBounds(0, 36),
bannerText: CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestExternAliasesAndUsings()
{
var tree = ParseLines("extern alias Foo;",
"extern alias Bar;",
"using System;",
"using System.Core;");
var compilationUnit = tree.GetRoot() as CompilationUnitSyntax;
var actualRegion = GetRegion(compilationUnit);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(7, 71),
hintSpan: TextSpan.FromBounds(0, 71),
bannerText: CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
const string code = @"
$${|hint:extern {|collapse:alias Foo;
extern alias Bar;
using System;
using System.Core;|}|}";
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestExternAliasesAndUsingsWithLeadingTrailingAndNestedComments()
{
var tree = ParseLines("// Foo",
"// Bar",
"extern alias Foo;",
"extern alias Bar;",
"// Foo",
"// Bar",
"using System;",
"using System.Core;",
"// Foo",
"// Bar");
var compilationUnit = (CompilationUnitSyntax)tree.GetRoot();
var actualRegions = GetRegions(compilationUnit).ToList();
Assert.Equal(3, actualRegions.Count);
var expectedRegion1 = new OutliningSpan(
TextSpan.FromBounds(0, 14),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion1, actualRegions[0]);
var expectedRegion2 = new OutliningSpan(
TextSpan.FromBounds(23, 103),
hintSpan: TextSpan.FromBounds(16, 103),
bannerText: CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion2, actualRegions[1]);
var expectedRegion3 = new OutliningSpan(
TextSpan.FromBounds(105, 119),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion3, actualRegions[2]);
const string code = @"
$${|span1:// Foo
// Bar|}
{|hint2:extern {|collapse2:alias Foo;
extern alias Bar;
// Foo
// Bar
using System;
using System.Core;|}|}
{|span3:// Foo
// Bar|}";
Regions(code,
Region("span1", "// Foo ...", autoCollapse: true),
Region("collapse2", "hint2", CSharpOutliningHelpers.Ellipsis, autoCollapse: true),
Region("span3", "// Foo ...", autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestUsingsWithComments()
{
var tree = ParseLines("// Foo",
"// Bar",
"using System;",
"using System.Core;");
var compilationUnit = (CompilationUnitSyntax)tree.GetRoot();
var actualRegions = GetRegions(compilationUnit).ToList();
Assert.Equal(2, actualRegions.Count);
var expectedRegion1 = new OutliningSpan(
TextSpan.FromBounds(0, 14),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion1, actualRegions[0]);
var expectedRegion2 = new OutliningSpan(
TextSpan.FromBounds(22, 49),
hintSpan: TextSpan.FromBounds(16, 49),
bannerText: CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion2, actualRegions[1]);
const string code = @"
$${|span1:// Foo
// Bar|}
{|hint2:using {|collapse2:System;
using System.Core;|}|}";
Regions(code,
Region("span1", "// Foo ...", autoCollapse: true),
Region("collapse2", "hint2", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestExternAliasesWithComments()
{
var tree = ParseLines("// Foo",
"// Bar",
"extern alias Foo;",
"extern alias Bar;");
var compilationUnit = (CompilationUnitSyntax)tree.GetRoot();
var actualRegions = GetRegions(compilationUnit).ToList();
Assert.Equal(2, actualRegions.Count);
var expectedRegion1 = new OutliningSpan(
TextSpan.FromBounds(0, 14),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion1, actualRegions[0]);
var expectedRegion2 = new OutliningSpan(
TextSpan.FromBounds(23, 52),
hintSpan: TextSpan.FromBounds(16, 52),
bannerText: CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion2, actualRegions[1]);
const string code = @"
$${|span1:// Foo
// Bar|}
{|hint2:extern {|collapse2:alias Foo;
extern alias Bar;|}|}";
Regions(code,
Region("span1", "// Foo ...", autoCollapse: true),
Region("collapse2", "hint2", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestWithComments()
{
var tree = ParseLines("// Foo",
"// Bar");
const string code = @"
$${|span1:// Foo
// Bar|}";
var compilationUnit = (CompilationUnitSyntax)tree.GetRoot();
var actualRegion = GetRegion(compilationUnit);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(0, 14),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("span1", "// Foo ...", autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestWithCommentsAtEnd()
{
var tree = ParseLines("using System;",
"// Foo",
"// Bar");
var compilationUnit = (CompilationUnitSyntax)tree.GetRoot();
var actualRegions = GetRegions(compilationUnit).ToList();
var expectedRegion1 = new OutliningSpan(
TextSpan.FromBounds(6, 13),
hintSpan: TextSpan.FromBounds(0, 13),
bannerText: CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion1, actualRegions[0]);
var expectedRegion2 = new OutliningSpan(
TextSpan.FromBounds(15, 29),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion2, actualRegions[1]);
const string code = @"
$${|hint1:using {|collapse1:System;|}|}
{|span2:// Foo
// Bar|}";
Regions(code,
Region("collapse1", "hint1", CSharpOutliningHelpers.Ellipsis, autoCollapse: true),
Region("span2", "// Foo ...", autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
[WorkItem(539359)]
public void TestUsingKeywordWithSpace()
{
var tree = ParseLines("using ");
var compilationUnit = (CompilationUnitSyntax)tree.GetRoot();
var actualRegions = GetRegions(compilationUnit).ToList();
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(6, 6),
TextSpan.FromBounds(0, 5),
bannerText: CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
$${|hint:using|} {|collapse:|}";
AssertRegion(expectedRegion, actualRegions[0]);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/ConstructorDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
public class ConstructorDeclarationOutlinerTests :
AbstractOutlinerTests<ConstructorDeclarationSyntax>
public class ConstructorDeclarationOutlinerTests : AbstractOutlinerTests<ConstructorDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(ConstructorDeclarationSyntax constructorDeclaration)
internal override AbstractSyntaxNodeOutliner<ConstructorDeclarationSyntax> CreateOutliner()
{
var outliner = new ConstructorDeclarationOutliner();
return outliner.GetOutliningSpans(constructorDeclaration, CancellationToken.None).WhereNotNull();
return new ConstructorDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestConstructor1()
{
var tree = ParseLines("class C",
"{",
" public C()",
" {",
" }",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var actualRegion = GetRegion(consDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(24, 34),
TextSpan.FromBounds(14, 34),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$public C(){|collapse:
{
}|}|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestConstructor2()
{
var tree = ParseLines("class C",
"{",
" public C()",
" {",
" } ",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var actualRegion = GetRegion(consDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(24, 51),
TextSpan.FromBounds(14, 51),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$public C(){|collapse:
{
} |}|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestConstructor3()
{
var tree = ParseLines("class C",
"{",
" public C()",
" {",
" } // .ctor",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var actualRegion = GetRegion(consDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(24, 34),
TextSpan.FromBounds(14, 34),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$public C(){|collapse:
{
}|}|} // .ctor
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestConstructor4()
{
var tree = ParseLines("class C",
"{",
" public C()",
" {",
" } /* .ctor */",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var actualRegion = GetRegion(consDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(24, 34),
TextSpan.FromBounds(14, 34),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$public C(){|collapse:
{
}|}|} /* .ctor */
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestConstructor5()
{
var tree = ParseLines("class C",
"{",
" public C() // .ctor",
" {",
" } // .ctor",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var actualRegion = GetRegion(consDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(33, 43),
TextSpan.FromBounds(14, 43),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$public C() // .ctor{|collapse:
{
}|}|} // .ctor
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestConstructor6()
{
var tree = ParseLines("class C",
"{",
" public C() /* .ctor */",
" {",
" } // .ctor",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var actualRegion = GetRegion(consDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(36, 46),
TextSpan.FromBounds(14, 46),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$public C() /* .ctor */{|collapse:
{
}|}|} // .ctor
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestConstructor7()
{
var tree = ParseLines("class C",
"{",
" public C()",
" // .ctor",
" {",
" } // .ctor",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var actualRegion = GetRegion(consDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(36, 46),
TextSpan.FromBounds(14, 46),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$public C()
// .ctor{|collapse:
{
}|}|} // .ctor
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestConstructor8()
{
var tree = ParseLines("class C",
"{",
" public C()",
" /* .ctor */",
" {",
" } // .ctor",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var actualRegion = GetRegion(consDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(39, 49),
TextSpan.FromBounds(14, 49),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$public C()
/* .ctor */{|collapse:
{
}|}|} // .ctor
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestConstructorWithComments()
{
var tree = ParseLines("class C",
"{",
" // Foo",
" // Bar",
" public C()",
" {",
" }",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var actualRegions = GetRegions(consDecl).ToList();
var expectedRegion1 = new OutliningSpan(
TextSpan.FromBounds(14, 30),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion1, actualRegions[0]);
var expectedRegion2 = new OutliningSpan(
TextSpan.FromBounds(44, 54),
TextSpan.FromBounds(34, 54),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|span1:// Foo
// Bar|}
{|hint2:$$public C(){|collapse2:
{
}|}|} // .ctor
}";
AssertRegion(expectedRegion2, actualRegions[1]);
Regions(code,
Region("span1", "// Foo ...", autoCollapse: true),
Region("collapse2", "hint2", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
......@@ -246,30 +160,13 @@ public void TestConstructorMissingCloseParenAndBody()
{
// Expected behavior is that the class should be outlined, but the constructor should not.
var tree = ParseLines("class C",
"{",
" C(",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var typeDeclOutliner = new TypeDeclarationOutliner();
var typeDeclRegions = typeDeclOutliner.GetOutliningSpans(typeDecl, CancellationToken.None).ToList();
Assert.Equal(1, typeDeclRegions.Count);
var expectedTypeDeclRegion =
new OutliningSpan(
TextSpan.FromBounds(7, 19),
TextSpan.FromBounds(0, 19),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: false);
AssertRegion(expectedTypeDeclRegion, typeDeclRegions[0]);
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var consDeclRegions = GetRegions(consDecl).ToList();
const string code = @"
class C
{
$$C(
}";
Assert.Equal(0, consDeclRegions.Count);
NoRegions(code);
}
}
}
src/EditorFeatures/CSharpTest/Outlining/ConversionOperatorDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
public class ConversionOperatorDeclarationOutlinerTests :
AbstractOutlinerTests<ConversionOperatorDeclarationSyntax>
public class ConversionOperatorDeclarationOutlinerTests : AbstractOutlinerTests<ConversionOperatorDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(ConversionOperatorDeclarationSyntax operatorDecl)
internal override AbstractSyntaxNodeOutliner<ConversionOperatorDeclarationSyntax> CreateOutliner()
{
var outliner = new ConversionOperatorDeclarationOutliner();
return outliner.GetOutliningSpans(operatorDecl, CancellationToken.None).WhereNotNull();
return new ConversionOperatorDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestOperator()
{
var tree = ParseLines("class C",
"{",
" public static explicit operator C (byte i)",
" {",
" }",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var operatorDecl = typeDecl.DigToFirstNodeOfType<ConversionOperatorDeclarationSyntax>();
var actualRegion = GetRegion(operatorDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(56, 66),
TextSpan.FromBounds(14, 66),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$public static explicit operator C(byte i){|collapse:
{
}|}|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact,
Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestOperatorWithLeadingComments()
{
var tree = ParseLines("class C",
"{",
" // Foo",
" // Bar",
" public static explicit operator C (byte i)",
" {",
" }",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var operatorDecl = typeDecl.DigToFirstNodeOfType<ConversionOperatorDeclarationSyntax>();
var actualRegions = GetRegions(operatorDecl).ToList();
Assert.Equal(2, actualRegions.Count);
var expectedRegion1 = new OutliningSpan(
TextSpan.FromBounds(14, 30),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion1, actualRegions[0]);
var expectedRegion2 = new OutliningSpan(
TextSpan.FromBounds(76, 86),
TextSpan.FromBounds(34, 86),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|span1:// Foo
// Bar|}
{|hint2:$$public static explicit operator C(byte i){|collapse2:
{
}|}|}
}";
AssertRegion(expectedRegion2, actualRegions[1]);
Regions(code,
Region("span1", "// Foo ...", autoCollapse: true),
Region("collapse2", "hint2", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/DelegateDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
public class DelegateDeclarationOutlinerTests :
AbstractOutlinerTests<DelegateDeclarationSyntax>
public class DelegateDeclarationOutlinerTests : AbstractOutlinerTests<DelegateDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(DelegateDeclarationSyntax delegateDeclaration)
internal override AbstractSyntaxNodeOutliner<DelegateDeclarationSyntax> CreateOutliner()
{
var outliner = new DelegateDeclarationOutliner();
return outliner.GetOutliningSpans(delegateDeclaration, CancellationToken.None);
return new DelegateDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestDelegateWithComments()
{
var tree = ParseLines("// Foo",
"// Bar",
"public delegate void C();");
const string code = @"
{|span:// Foo
// Bar|}
$$public delegate void C();";
var delegateDecl = tree.DigToFirstNodeOfType<DelegateDeclarationSyntax>();
var actualRegion = GetRegion(delegateDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(0, 14),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("span", "// Foo ...", autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/DestructorDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
public class DestructorDeclarationOutlinerTests :
AbstractOutlinerTests<DestructorDeclarationSyntax>
public class DestructorDeclarationOutlinerTests : AbstractOutlinerTests<DestructorDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(DestructorDeclarationSyntax destructorDeclaration)
internal override AbstractSyntaxNodeOutliner<DestructorDeclarationSyntax> CreateOutliner()
{
var outliner = new DestructorDeclarationOutliner();
return outliner.GetOutliningSpans(destructorDeclaration, CancellationToken.None).WhereNotNull();
return new DestructorDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestDestructor()
{
var tree = ParseLines("class C",
"{",
" ~C()",
" {",
" }",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var destructor = typeDecl.DigToFirstNodeOfType<DestructorDeclarationSyntax>();
var actualRegion = GetRegion(destructor);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 28),
TextSpan.FromBounds(14, 28),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$~C(){|collapse:
{
}|}|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestDestructorWithComments()
{
var tree = ParseLines("class C",
"{",
" // Foo",
" // Bar",
" ~C()",
" {",
" }",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var destructor = typeDecl.DigToFirstNodeOfType<DestructorDeclarationSyntax>();
var actualRegions = GetRegions(destructor).ToList();
var expectedRegion1 = new OutliningSpan(
TextSpan.FromBounds(14, 30),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion1, actualRegions[0]);
var expectedRegion2 = new OutliningSpan(
TextSpan.FromBounds(38, 48),
TextSpan.FromBounds(34, 48),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|span1:// Foo
// Bar|}
{|hint2:$$~C(){|collapse2:
{
}|}|}
}";
AssertRegion(expectedRegion2, actualRegions[1]);
Regions(code,
Region("span1", "// Foo ...", autoCollapse: true),
Region("collapse2", "hint2", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
......@@ -83,30 +53,13 @@ public void TestDestructorMissingCloseParenAndBody()
{
// Expected behavior is that the class should be outlined, but the destructor should not.
var tree = ParseLines("class C",
"{",
" ~C(",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var typeDeclOutliner = new TypeDeclarationOutliner();
var typeDeclRegions = typeDeclOutliner.GetOutliningSpans(typeDecl, CancellationToken.None).ToList();
Assert.Equal(1, typeDeclRegions.Count);
var expectedTypeDeclRegion =
new OutliningSpan(
TextSpan.FromBounds(7, 20),
TextSpan.FromBounds(0, 20),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: false);
AssertRegion(expectedTypeDeclRegion, typeDeclRegions[0]);
var destructor = typeDecl.DigToFirstNodeOfType<DestructorDeclarationSyntax>();
var destructorRegions = GetRegions(destructor).ToList();
const string code = @"
class C
{
$$~C(
}";
Assert.Equal(0, destructorRegions.Count);
NoRegions(code);
}
}
}
src/EditorFeatures/CSharpTest/Outlining/DisabledTextOutlinerTests.cs
浏览文件 @ 66944d3e
......@@ -7,9 +7,11 @@
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Editor.UnitTests.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;
using static Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.Utils;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
......
src/EditorFeatures/CSharpTest/Outlining/EnumDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;
......@@ -15,89 +11,51 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
public class EnumDeclarationOutlinerTests :
AbstractOutlinerTests<EnumDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(EnumDeclarationSyntax enumDeclaration)
internal override AbstractSyntaxNodeOutliner<EnumDeclarationSyntax> CreateOutliner()
{
var outliner = new EnumDeclarationOutliner();
return outliner.GetOutliningSpans(enumDeclaration, CancellationToken.None);
return new EnumDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestEnum()
{
var tree = ParseLines("enum E",
"{",
"}");
var enumDecl = tree.DigToFirstNodeOfType<EnumDeclarationSyntax>();
var actualRegion = GetRegion(enumDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(6, 12),
TextSpan.FromBounds(0, 12),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: false);
const string code = @"
{|hint:$$enum E{|collapse:
{
}|}|}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: false));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestEnumWithLeadingComments()
{
var tree = ParseLines("// Foo",
"// Bar",
"enum E",
"{",
"}");
var enumDecl = tree.DigToFirstNodeOfType<EnumDeclarationSyntax>();
var actualRegions = GetRegions(enumDecl).ToList();
Assert.Equal(2, actualRegions.Count);
var expectedRegion1 = new OutliningSpan(
TextSpan.FromBounds(0, 14),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion1, actualRegions[0]);
var expectedRegion2 = new OutliningSpan(
TextSpan.FromBounds(22, 28),
TextSpan.FromBounds(16, 28),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: false);
const string code = @"
{|span1:// Foo
// Bar|}
{|hint2:$$enum E{|collapse2:
{
}|}|}";
AssertRegion(expectedRegion2, actualRegions[1]);
Regions(code,
Region("span1", "// Foo ...", autoCollapse: true),
Region("collapse2", "hint2", CSharpOutliningHelpers.Ellipsis, autoCollapse: false));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestEnumWithNestedComments()
{
var tree = ParseLines("enum E",
"{",
" // Foo",
" // Bar",
"}");
var enumDecl = tree.DigToFirstNodeOfType<EnumDeclarationSyntax>();
var actualRegions = GetRegions(enumDecl).ToList();
Assert.Equal(2, actualRegions.Count);
var expectedRegion1 = new OutliningSpan(
TextSpan.FromBounds(6, 32),
TextSpan.FromBounds(0, 32),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: false);
AssertRegion(expectedRegion1, actualRegions[0]);
var expectedRegion2 = new OutliningSpan(
TextSpan.FromBounds(13, 29),
"// Foo ...",
autoCollapse: true);
const string code = @"
{|hint1:$$enum E{|collapse1:
{
{|span2:// Foo
// Bar|}
}|}|}";
AssertRegion(expectedRegion2, actualRegions[1]);
Regions(code,
Region("collapse1", "hint1", CSharpOutliningHelpers.Ellipsis, autoCollapse: false),
Region("span2", "// Foo ...", autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/EventDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
public class EventDeclarationOutlinerTests :
AbstractOutlinerTests<EventDeclarationSyntax>
public class EventDeclarationOutlinerTests : AbstractOutlinerTests<EventDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(EventDeclarationSyntax eventDeclaration)
internal override AbstractSyntaxNodeOutliner<EventDeclarationSyntax> CreateOutliner()
{
var outliner = new EventDeclarationOutliner();
return outliner.GetOutliningSpans(eventDeclaration, CancellationToken.None);
return new EventDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestEvent()
{
var tree = ParseLines("class C",
"{",
" event EventHandler E",
" {",
" add { }",
" remove { }",
" }",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var eventDecl = typeDecl.DigToFirstNodeOfType<EventDeclarationSyntax>();
var actualRegion = GetRegion(eventDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(34, 73),
TextSpan.FromBounds(14, 73),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$event EventHandler E{|collapse:
{
add { }
remove { }
}|}|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestEventWithComments()
{
var tree = ParseLines("class C",
"{",
" // Foo",
" // Bar",
" event EventHandler E",
" {",
" add { }",
" remove { }",
" }",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var eventDecl = typeDecl.DigToFirstNodeOfType<EventDeclarationSyntax>();
var actualRegions = GetRegions(eventDecl).ToList();
var expectedRegion1 = new OutliningSpan(
TextSpan.FromBounds(14, 30),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion1, actualRegions[0]);
var expectedRegion2 = new OutliningSpan(
TextSpan.FromBounds(54, 93),
TextSpan.FromBounds(34, 93),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion2, actualRegions[1]);
const string code = @"
class C
{
{|span1:// Foo
// Bar|}
{|hint2:$$event EventHandler E{|collapse2:
{
add { }
remove { }
}|}|}
}";
Regions(code,
Region("span1", "// Foo ...", autoCollapse: true),
Region("collapse2", "hint2", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/EventFieldDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
public class EventFieldDeclarationOutlinerTests :
AbstractOutlinerTests<EventFieldDeclarationSyntax>
public class EventFieldDeclarationOutlinerTests : AbstractOutlinerTests<EventFieldDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(EventFieldDeclarationSyntax eventFieldDecl)
internal override AbstractSyntaxNodeOutliner<EventFieldDeclarationSyntax> CreateOutliner()
{
var outliner = new EventFieldDeclarationOutliner();
return outliner.GetOutliningSpans(eventFieldDecl, CancellationToken.None);
return new EventFieldDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestEventFieldWithComments()
{
var tree = ParseLines("class C",
"{",
" // Foo",
" // Bar",
" event EventHandler E;",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var eventFieldDecl = typeDecl.DigToFirstNodeOfType<EventFieldDeclarationSyntax>();
var actualRegion = GetRegion(eventFieldDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(14, 30),
"// Foo ...",
autoCollapse: true);
const string code = @"
class C
{
{|span:// Foo
// Bar|}
$$event EventHandler E;
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("span", "// Foo ...", autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/FieldDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
public class FieldDeclarationOutlinerTests :
AbstractOutlinerTests<FieldDeclarationSyntax>
public class FieldDeclarationOutlinerTests : AbstractOutlinerTests<FieldDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(FieldDeclarationSyntax fieldDecl)
internal override AbstractSyntaxNodeOutliner<FieldDeclarationSyntax> CreateOutliner()
{
var outliner = new FieldDeclarationOutliner();
return outliner.GetOutliningSpans(fieldDecl, CancellationToken.None);
return new FieldDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestFieldWithComments()
{
var tree = ParseLines("class C",
"{",
" // Foo",
" // Bar",
" int F;",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var fieldDecl = typeDecl.DigToFirstNodeOfType<FieldDeclarationSyntax>();
var actualRegion = GetRegion(fieldDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(14, 30),
"// Foo ...",
autoCollapse: true);
const string code = @"
class C
{
{|span:// Foo
// Bar|}
$$int F;
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("span", "// Foo ...", autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/IndexerDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
public class IndexerDeclarationOutlinerTests :
AbstractOutlinerTests<IndexerDeclarationSyntax>
public class IndexerDeclarationOutlinerTests : AbstractOutlinerTests<IndexerDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(IndexerDeclarationSyntax indexerDecl)
internal override AbstractSyntaxNodeOutliner<IndexerDeclarationSyntax> CreateOutliner()
{
var outliner = new IndexerDeclarationOutliner();
return outliner.GetOutliningSpans(indexerDecl, CancellationToken.None);
return new IndexerDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestIndexer()
{
var tree = ParseLines("class C",
"{",
" public string this[int index]",
" {",
" get { }",
" }",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var indexerDecl = typeDecl.DigToFirstNodeOfType<IndexerDeclarationSyntax>();
var actualRegion = GetRegion(indexerDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(43, 66),
TextSpan.FromBounds(14, 66),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|hint:$$public string this[int index]{|collapse:
{
get { }
}|}|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestIndexerWithComments()
{
var tree = ParseLines("class C",
"{",
" // Foo",
" // Bar",
" public string this[int index]",
" {",
" get { }",
" }",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var indexerDecl = typeDecl.DigToFirstNodeOfType<IndexerDeclarationSyntax>();
var actualRegions = GetRegions(indexerDecl).ToList();
var expectedRegion1 = new OutliningSpan(
TextSpan.FromBounds(14, 30),
"// Foo ...",
autoCollapse: true);
AssertRegion(expectedRegion1, actualRegions[0]);
var expectedRegion2 = new OutliningSpan(
TextSpan.FromBounds(63, 86),
TextSpan.FromBounds(34, 86),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
const string code = @"
class C
{
{|span1:// Foo
// Bar|}
{|hint2:$$public string this[int index]{|collapse2:
{
get { }
}|}|}
}";
AssertRegion(expectedRegion2, actualRegions[1]);
Regions(code,
Region("span1", "// Foo ...", autoCollapse: true),
Region("collapse2", "hint2", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.Outlining)]
public void TestIndexerWithWithExpressionBodyAndComments()
{
var tree = ParseLines("class C",
"{",
" // Foo",
" // Bar",
" public string this[int index] => 0;",
"}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var indexerDecl = typeDecl.DigToFirstNodeOfType<IndexerDeclarationSyntax>();
var actualRegion = GetRegion(indexerDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(14, 30),
"// Foo ...",
autoCollapse: true);
const string code = @"
class C
{
{|span:// Foo
// Bar|}
$$public string this[int index] => 0;
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("span", "// Foo ...", autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/ConstructorDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class ConstructorDeclarationOutlinerTests :
AbstractOutlinerTests<ConstructorDeclarationSyntax>
public class ConstructorDeclarationOutlinerTests : AbstractOutlinerTests<ConstructorDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(ConstructorDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<ConstructorDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.ConstructorDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.ConstructorDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"class C
const string code = @"
class C
{
C();
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
$$C();
}";
Assert.Empty(GetRegions(consDecl));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"class C
const string code = @"
class C
{
[Bar]
C();
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var actualRegion = GetRegion(consDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(16, 27),
TextSpan.FromBounds(16, 31),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
{|hint:{|collapse:[Bar]
|}$$C();|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"class C
const string code = @"
class C
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Bar]
C();
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
|}$$C();|}
}";
var actualRegion = GetRegion(consDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(16, 75),
TextSpan.FromBounds(16, 79),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAttributesAndModifiers()
{
var tree = ParseCode(
@"class C
const string code = @"
class C
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Bar]
public C();
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var consDecl = typeDecl.DigToFirstNodeOfType<ConstructorDeclarationSyntax>();
var actualRegion = GetRegion(consDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(16, 75),
TextSpan.FromBounds(16, 86),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}$$public C();|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/ConversionOperatorDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class ConversionOperatorDeclarationOutlinerTests :
AbstractOutlinerTests<ConversionOperatorDeclarationSyntax>
public class ConversionOperatorDeclarationOutlinerTests : AbstractOutlinerTests<ConversionOperatorDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(ConversionOperatorDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<ConversionOperatorDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.ConversionOperatorDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.ConversionOperatorDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class C
{
public static explicit operator Foo (byte b);
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var operatorMethod = typeDecl.DigToFirstNodeOfType<ConversionOperatorDeclarationSyntax>();
public static explicit operator $$Foo(byte b);
}";
Assert.Empty(GetRegions(operatorMethod));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class C
{
[Blah]
public static explicit operator Foo (byte b);
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var operatorMethod = typeDecl.DigToFirstNodeOfType<ConversionOperatorDeclarationSyntax>();
var actualRegion = GetRegion(operatorMethod);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 30),
TextSpan.FromBounds(18, 75),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
{|hint:{|collapse:[Blah]
|}public static explicit operator $$Foo(byte b);|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class C
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Blah]
public static explicit operator Foo (byte b);
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var operatorMethod = typeDecl.DigToFirstNodeOfType<ConversionOperatorDeclarationSyntax>();
var actualRegion = GetRegion(operatorMethod);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 78),
TextSpan.FromBounds(18, 123),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}public static explicit operator $$Foo(byte b);|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/DelegateDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class DelegateDeclarationOutlinerTests :
AbstractOutlinerTests<DelegateDeclarationSyntax>
public class DelegateDeclarationOutlinerTests : AbstractOutlinerTests<DelegateDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(DelegateDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<DelegateDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.DelegateDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.DelegateDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(@"public delegate TResult Blah<in T, out TResult>(T arg);");
var delegateDecl = tree.DigToFirstNodeOfType<DelegateDeclarationSyntax>();
const string code = @"
public delegate TResult $$Blah<in T, out TResult>(T arg);";
Assert.Empty(GetRegions(delegateDecl));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"[Foo]
public delegate TResult Blah<in T, out TResult>(T arg);");
var delegateDecl = tree.DigToFirstNodeOfType<DelegateDeclarationSyntax>();
const string code = @"
{|hint:{|collapse:[Foo]
|}public delegate TResult $$Blah<in T, out TResult>(T arg);|}";
var actualRegion = GetRegion(delegateDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(0, 7),
TextSpan.FromBounds(0, 62),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"// Summary:
const string code = @"
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
delegate TResult Blah<in T, out TResult>(T arg);");
var delegateDecl = tree.DigToFirstNodeOfType<DelegateDeclarationSyntax>();
var actualRegion = GetRegion(delegateDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(0, 47),
TextSpan.FromBounds(0, 95),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}delegate TResult $$Blah<in T, out TResult>(T arg);|}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAttributesAndModifiers()
{
var tree = ParseCode(
@"// Summary:
const string code = @"
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
public delegate TResult Blah<in T, out TResult>(T arg);");
var delegateDecl = tree.DigToFirstNodeOfType<DelegateDeclarationSyntax>();
var actualRegion = GetRegion(delegateDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(0, 47),
TextSpan.FromBounds(0, 102),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}public delegate TResult $$Blah<in T, out TResult>(T arg);|}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/DestructorDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class DestructorDeclarationOutlinerTests :
AbstractOutlinerTests<DestructorDeclarationSyntax>
public class DestructorDeclarationOutlinerTests : AbstractOutlinerTests<DestructorDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(DestructorDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<DestructorDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.DestructorDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.DestructorDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
~Foo();
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var destructor = typeDecl.DigToFirstNodeOfType<DestructorDeclarationSyntax>();
$$~Foo();
}";
Assert.Empty(GetRegions(destructor));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
[Bar]
~Foo();
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var destructor = typeDecl.DigToFirstNodeOfType<DestructorDeclarationSyntax>();
var actualRegion = GetRegion(destructor);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 29),
TextSpan.FromBounds(18, 36),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
{|hint:{|collapse:[Bar]
|}$$~Foo();|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Bar]
~Foo();
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var destructor = typeDecl.DigToFirstNodeOfType<DestructorDeclarationSyntax>();
var actualRegion = GetRegion(destructor);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 84),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}$$~Foo();|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/EnumDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class EnumDeclarationOutlinerTests :
AbstractOutlinerTests<EnumDeclarationSyntax>
public class EnumDeclarationOutlinerTests : AbstractOutlinerTests<EnumDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(EnumDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<EnumDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.EnumDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.EnumDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"enum C
const string code = @"
enum $$E
{
A,
B
}");
var enumDecl = tree.DigToFirstNodeOfType<EnumDeclarationSyntax>();
}";
Assert.Empty(GetRegions(enumDecl));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"[Bar]
enum C
const string code = @"
{|hint:{|collapse:[Bar]
|}enum $$E|}
{
A,
B
}");
var enumDecl = tree.DigToFirstNodeOfType<EnumDeclarationSyntax>();
}";
var actualRegion = GetRegion(enumDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(0, 7),
TextSpan.FromBounds(0, 13),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"// Summary:
const string code = @"
{|hint:{|collapse:// Summary:
// This is a summary.
[Bar]
enum C
|}enum $$E|}
{
A,
B
}");
var enumDecl = tree.DigToFirstNodeOfType<EnumDeclarationSyntax>();
var actualRegion = GetRegion(enumDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(0, 47),
TextSpan.FromBounds(0, 53),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAttributesAndModifiers()
{
var tree = ParseCode(
@"// Summary:
const string code = @"
{|hint:{|collapse:// Summary:
// This is a summary.
[Bar]
public enum C
|}public enum $$E|}
{
A,
B
}");
var enumDecl = tree.DigToFirstNodeOfType<EnumDeclarationSyntax>();
var actualRegion = GetRegion(enumDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(0, 47),
TextSpan.FromBounds(0, 60),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/EnumMemberDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class EnumMemberDeclarationOutlinerTests :
AbstractOutlinerTests<EnumMemberDeclarationSyntax>
public class EnumMemberDeclarationOutlinerTests : AbstractOutlinerTests<EnumMemberDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(EnumMemberDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<EnumMemberDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.EnumMemberDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.EnumMemberDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"enum E
const string code = @"
enum E
{
Foo,
$$Foo,
Bar
}");
var enumDecl = tree.DigToFirstNodeOfType<EnumDeclarationSyntax>();
var enumMember = enumDecl.DigToFirstNodeOfType<EnumMemberDeclarationSyntax>();
}";
Assert.Empty(GetRegions(enumMember));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"enum E
const string code = @"
enum E
{
[Blah]
Foo,
{|hint:{|collapse:[Blah]
|}$$Foo|},
Bar
}");
var enumDecl = tree.DigToFirstNodeOfType<EnumDeclarationSyntax>();
var enumMember = enumDecl.DigToFirstNodeOfType<EnumMemberDeclarationSyntax>();
var actualRegion = GetRegion(enumMember);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(15, 27),
TextSpan.FromBounds(15, 30),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"enum E
const string code = @"
enum E
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Blah]
Foo,
|}$$Foo|},
Bar
}");
var enumDecl = tree.DigToFirstNodeOfType<EnumDeclarationSyntax>();
var enumMember = enumDecl.DigToFirstNodeOfType<EnumMemberDeclarationSyntax>();
var actualRegion = GetRegion(enumMember);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(15, 75),
TextSpan.FromBounds(15, 78),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/EventDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class EventDeclarationOutlinerTests :
AbstractOutlinerTests<EventDeclarationSyntax>
public class EventDeclarationOutlinerTests : AbstractOutlinerTests<EventDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(EventDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<EventDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.EventDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.EventDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
public event EventArgs foo { add; remove; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var eventDecl = typeDecl.DigToFirstNodeOfType<EventDeclarationSyntax>();
public event EventArgs $$foo { add; remove; }
}";
Assert.Empty(GetRegions(eventDecl));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
[Foo]
public event EventArgs foo { add; remove; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var eventDecl = typeDecl.DigToFirstNodeOfType<EventDeclarationSyntax>();
var actualRegion = GetRegion(eventDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 29),
TextSpan.FromBounds(18, 72),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
{|hint:{|collapse:[Foo]
|}public event EventArgs $$foo { add; remove; }|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
event EventArgs foo { add; remove; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var eventDecl = typeDecl.DigToFirstNodeOfType<EventDeclarationSyntax>();
|}event EventArgs $$foo { add; remove; }|}
}";
var actualRegion = GetRegion(eventDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 113),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAttributesAndModifiers()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
public event EventArgs foo { add; remove; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var eventDecl = typeDecl.DigToFirstNodeOfType<EventDeclarationSyntax>();
var actualRegion = GetRegion(eventDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 120),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}public event EventArgs $$foo { add; remove; }|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/EventFieldDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class EventFieldDeclarationOutlinerTests :
AbstractOutlinerTests<EventFieldDeclarationSyntax>
public class EventFieldDeclarationOutlinerTests : AbstractOutlinerTests<EventFieldDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(EventFieldDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<EventFieldDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.EventFieldDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.EventFieldDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
public event EventArgs foo;
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var eventDecl = typeDecl.DigToFirstNodeOfType<EventFieldDeclarationSyntax>();
public event EventArgs $$foo
}";
Assert.Empty(GetRegions(eventDecl));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
[Foo]
public event EventArgs foo;
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var eventDecl = typeDecl.DigToFirstNodeOfType<EventFieldDeclarationSyntax>();
var actualRegion = GetRegion(eventDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 29),
TextSpan.FromBounds(18, 56),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
{|hint:{|collapse:[Foo]
|}event EventArgs $$foo|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
event EventArgs foo;
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var eventDecl = typeDecl.DigToFirstNodeOfType<EventFieldDeclarationSyntax>();
|}event EventArgs $$foo|}
}";
var actualRegion = GetRegion(eventDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 97),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAttributesAndModifiers()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
public event EventArgs foo;
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var eventDecl = typeDecl.DigToFirstNodeOfType<EventFieldDeclarationSyntax>();
var actualRegion = GetRegion(eventDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 104),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}public event EventArgs $$foo|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/FieldDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
......@@ -16,94 +12,67 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSou
public class FieldDeclarationOutlinerTests :
AbstractOutlinerTests<FieldDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(FieldDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<FieldDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.FieldDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.FieldDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
public int foo;
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var fieldDecl = typeDecl.DigToFirstNodeOfType<FieldDeclarationSyntax>();
public int $$foo
}";
Assert.Empty(GetRegions(fieldDecl));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
[Foo]
public int foo;
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var fieldDecl = typeDecl.DigToFirstNodeOfType<FieldDeclarationSyntax>();
var actualRegion = GetRegion(fieldDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 29),
TextSpan.FromBounds(18, 44),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
{|hint:{|collapse:[Foo]
|}public int $$foo|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
int foo;
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var fieldDecl = typeDecl.DigToFirstNodeOfType<FieldDeclarationSyntax>();
|}int $$foo|}
}";
var actualRegion = GetRegion(fieldDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 85),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAttributesAndModifiers()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
public int foo;
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var fieldDecl = typeDecl.DigToFirstNodeOfType<FieldDeclarationSyntax>();
var actualRegion = GetRegion(fieldDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 92),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}public int $$foo|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/IndexerDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class IndexerDeclarationOutlinerTests :
AbstractOutlinerTests<IndexerDeclarationSyntax>
public class IndexerDeclarationOutlinerTests : AbstractOutlinerTests<IndexerDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(IndexerDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<IndexerDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.IndexerDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.IndexerDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
public string this[int x] { get; set; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var indexer = typeDecl.DigToFirstNodeOfType<IndexerDeclarationSyntax>();
public string $$this[int x] { get; set; }
}";
Assert.Empty(GetRegions(indexer));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
[Foo]
public string this[int x] { get; set; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var indexer = typeDecl.DigToFirstNodeOfType<IndexerDeclarationSyntax>();
var actualRegion = GetRegion(indexer);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 29),
TextSpan.FromBounds(18, 68),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
{|hint:{|collapse:[Foo]
|}public string $$this[int x] { get; set; }|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
string this[int x] { get; set; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var indexer = typeDecl.DigToFirstNodeOfType<IndexerDeclarationSyntax>();
|}string $$this[int x] { get; set; }|}
}";
var actualRegion = GetRegion(indexer);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 109),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAttributesAndmodifiers()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
public string this[int x] { get; set; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var indexer = typeDecl.DigToFirstNodeOfType<IndexerDeclarationSyntax>();
var actualRegion = GetRegion(indexer);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 116),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}public string $$this[int x] { get; set; }|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/InvalidIdentifierTests.cs
浏览文件 @ 66944d3e
......@@ -4,6 +4,7 @@
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Editor.UnitTests.Outlining;
using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
using Roslyn.Test.Utilities;
using Xunit;
......
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/MethodDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class MethodDeclarationOutlinerTests :
AbstractOutlinerTests<MethodDeclarationSyntax>
public class MethodDeclarationOutlinerTests : AbstractOutlinerTests<MethodDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(MethodDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<MethodDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.MethodDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.MethodDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
public string Bar(int x);
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var method = typeDecl.DigToFirstNodeOfType<MethodDeclarationSyntax>();
public string $$Bar(int x);
}";
Assert.Empty(GetRegions(method));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
[Foo]
public string Bar(int x);
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var method = typeDecl.DigToFirstNodeOfType<MethodDeclarationSyntax>();
var actualRegion = GetRegion(method);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 29),
TextSpan.FromBounds(18, 54),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
{|hint:{|collapse:[Foo]
|}public string $$Bar(int x);|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
string Bar(int x);
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var method = typeDecl.DigToFirstNodeOfType<MethodDeclarationSyntax>();
|}string $$Bar(int x);|}
}";
var actualRegion = GetRegion(method);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 95),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAttributesAndModifiers()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
public string Bar(int x);
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var method = typeDecl.DigToFirstNodeOfType<MethodDeclarationSyntax>();
var actualRegion = GetRegion(method);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 102),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}public string $$Bar(int x);|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/OperatorDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class OperatorDeclarationOutlinerTests :
AbstractOutlinerTests<OperatorDeclarationSyntax>
public class OperatorDeclarationOutlinerTests : AbstractOutlinerTests<OperatorDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(OperatorDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<OperatorDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.OperatorDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.OperatorDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
public static bool operator ==(Foo a, Foo b);
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var operatorMethod = typeDecl.DigToFirstNodeOfType<OperatorDeclarationSyntax>();
public static bool operator $$==(Foo a, Foo b);
}";
Assert.Empty(GetRegions(operatorMethod));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
[Blah]
public static bool operator ==(Foo a, Foo b);
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var operatorMethod = typeDecl.DigToFirstNodeOfType<OperatorDeclarationSyntax>();
var actualRegion = GetRegion(operatorMethod);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 30),
TextSpan.FromBounds(18, 75),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
{|hint:{|collapse:[Blah]
|}public static bool operator $$==(Foo a, Foo b);|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Blah]
bool operator ==(Foo a, Foo b);
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var operatorMethod = typeDecl.DigToFirstNodeOfType<OperatorDeclarationSyntax>();
|}bool operator $$==(Foo a, Foo b);|}
}";
var actualRegion = GetRegion(operatorMethod);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 83),
TextSpan.FromBounds(18, 109),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAttributesAndModifiers()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Blah]
public static bool operator ==(Foo a, Foo b);
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var operatorMethod = typeDecl.DigToFirstNodeOfType<OperatorDeclarationSyntax>();
var actualRegion = GetRegion(operatorMethod);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 78),
TextSpan.FromBounds(18, 123),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}public static bool operator $$==(Foo a, Foo b);|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/PropertyDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class PropertyDeclarationOutlinerTests :
AbstractOutlinerTests<PropertyDeclarationSyntax>
public class PropertyDeclarationOutlinerTests : AbstractOutlinerTests<PropertyDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(PropertyDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<PropertyDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.PropertyDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.PropertyDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
public string Prop { get; set; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var prop = typeDecl.DigToFirstNodeOfType<PropertyDeclarationSyntax>();
public string $$Prop { get; set; }
}";
Assert.Empty(GetRegions(prop));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
[Foo]
public string Prop { get; set; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var prop = typeDecl.DigToFirstNodeOfType<PropertyDeclarationSyntax>();
var actualRegion = GetRegion(prop);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 29),
TextSpan.FromBounds(18, 61),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
{|hint:{|collapse:[Foo]
|}public string $$Prop { get; set; }|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
string Prop { get; set; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var prop = typeDecl.DigToFirstNodeOfType<PropertyDeclarationSyntax>();
|}string $$Prop { get; set; }|}
}";
var actualRegion = GetRegion(prop);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 102),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAttributesAndModifiers()
{
var tree = ParseCode(
@"class Foo
const string code = @"
class Foo
{
// Summary:
{|hint:{|collapse:// Summary:
// This is a summary.
[Foo]
public string Prop { get; set; }
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var prop = typeDecl.DigToFirstNodeOfType<PropertyDeclarationSyntax>();
var actualRegion = GetRegion(prop);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(18, 77),
TextSpan.FromBounds(18, 109),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
|}public string $$Prop { get; set; }|}
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/RegionDirectiveOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class RegionDirectiveOutlinerTests :
AbstractOutlinerTests<RegionDirectiveTriviaSyntax>
public class RegionDirectiveOutlinerTests : AbstractOutlinerTests<RegionDirectiveTriviaSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(RegionDirectiveTriviaSyntax node)
internal override AbstractSyntaxNodeOutliner<RegionDirectiveTriviaSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.RegionDirectiveOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.RegionDirectiveOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void FileHeader()
{
var tree = ParseCode(
@"#region Assembly mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
const string code = @"
{|span:#re$$gion Assembly mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\mscorlib.dll
#endregion");
#endregion|}";
var trivia = tree.GetRoot().FindTrivia(position: 0);
var region = trivia.GetStructure() as RegionDirectiveTriviaSyntax;
Assert.NotNull(region);
var actualOutliningSpan = GetRegion(region);
var expectedOutliningSpan = new OutliningSpan(
TextSpan.FromBounds(0, 204),
bannerText: "Assembly mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
autoCollapse: true);
AssertRegion(expectedOutliningSpan, actualOutliningSpan);
Regions(code,
Region("span", "Assembly mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void EmptyFileHeader()
{
var tree = ParseCode(
@"#region
const string code = @"
{|span:#re$$gion
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\mscorlib.dll
#endregion");
var trivia = tree.GetRoot().FindTrivia(position: 0);
var region = trivia.GetStructure() as RegionDirectiveTriviaSyntax;
Assert.NotNull(region);
var actualOutliningSpan = GetRegion(region);
var expectedOutliningSpan = new OutliningSpan(
TextSpan.FromBounds(0, 119),
bannerText: "#region",
autoCollapse: true);
#endregion|}";
AssertRegion(expectedOutliningSpan, actualOutliningSpan);
Regions(code,
Region("span", "#region", autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/MetadataAsSource/TypeDeclarationOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editor.CSharp.Outlining;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
using MaSOutliners = Microsoft.CodeAnalysis.Editor.CSharp.Outlining.MetadataAsSource;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining.MetadataAsSource
{
public class TypeDeclarationOutlinerTests :
AbstractOutlinerTests<TypeDeclarationSyntax>
public class TypeDeclarationOutlinerTests : AbstractOutlinerTests<TypeDeclarationSyntax>
{
internal override IEnumerable<OutliningSpan> GetRegions(TypeDeclarationSyntax node)
internal override AbstractSyntaxNodeOutliner<TypeDeclarationSyntax> CreateOutliner()
{
var outliner = new MaSOutliners.TypeDeclarationOutliner();
return outliner.GetOutliningSpans(node, CancellationToken.None).WhereNotNull();
return new MaSOutliners.TypeDeclarationOutliner();
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void NoCommentsOrAttributes()
{
var tree = ParseCode(
@"class C
const string code = @"
class $$C
{
void M();
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
}";
Assert.Empty(GetRegions(typeDecl));
NoRegions(code);
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithAttributes()
{
var tree = ParseCode(
@"[Bar]
const string code = @"
{|hint:{|collapse:[Bar]
[Baz]
public class C
|}public class $$C|}
{
void M();
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
}";
var actualRegion = GetRegion(typeDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(0, 14),
TextSpan.FromBounds(0, 28),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
[WpfFact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
public void WithCommentsAndAttributes()
{
var tree = ParseCode(
@"// Summary:
const string code = @"
{|hint:{|collapse:// Summary:
// This is a doc comment.
[Bar, Baz]
public class C
|}public class $$C|}
{
void M();
}");
var typeDecl = tree.DigToFirstTypeDeclaration();
var actualRegion = GetRegion(typeDecl);
var expectedRegion = new OutliningSpan(
TextSpan.FromBounds(0, 56),
TextSpan.FromBounds(0, 70),
CSharpOutliningHelpers.Ellipsis,
autoCollapse: true);
}";
AssertRegion(expectedRegion, actualRegion);
Regions(code,
Region("collapse", "hint", CSharpOutliningHelpers.Ellipsis, autoCollapse: true));
}
}
}
src/EditorFeatures/CSharpTest/Outlining/Utils.cs 0 → 100644
浏览文件 @ 66944d3e
using System;
using Microsoft.CodeAnalysis.CSharp;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
{
internal static class Utils
{
public static SyntaxTree ParseCode(string code)
{
return SyntaxFactory.ParseSyntaxTree(code);
}
public static string StringFromLines(params string[] lines)
{
return string.Join(Environment.NewLine, lines);
}
public static SyntaxTree ParseLines(params string[] lines)
{
var code = StringFromLines(lines);
return ParseCode(code);
}
}
}
src/EditorFeatures/Test/EditorServicesTest.csproj
浏览文件 @ 66944d3e
......@@ -251,6 +251,7 @@
<Compile Include="CodeFixes\ExtensionOrderingTests.cs" />
<Compile Include="Diagnostics\TestHostDiagnosticUpdateSource.cs" />
<Compile Include="Extensions\SourceTextContainerExtensionsTests.cs" />
<Compile Include="Outlining\AbstractOutlinerTests.cs" />
<Compile Include="Preview\TestOnly_CompilerDiagnosticAnalyzerProviderService.cs" />
<Compile Include="DocCommentFormatting\DocCommentFormattingTests.cs" />
<Compile Include="DocumentationComments\AbstractDocumentationCommentTests.cs" />
......
src/EditorFeatures/CSharpTest/Outlining/AbstractOutlinerTests.cs → src/EditorFeatures/Test/Outlining/AbstractOutlinerTests.cs
浏览文件 @ 66944d3e
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Editor.Implementation.Outlining;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Outlining
namespace Microsoft.CodeAnalysis.Editor.UnitTests.Outlining
{
public abstract class AbstractOutlinerTests
{
internal void AssertRegion(OutliningSpan expected, OutliningSpan actual)
internal static void AssertRegion(OutliningSpan expected, OutliningSpan actual)
{
Assert.Equal(expected.TextSpan.Start, actual.TextSpan.Start);
Assert.Equal(expected.TextSpan.End, actual.TextSpan.End);
......@@ -17,22 +15,7 @@ internal void AssertRegion(OutliningSpan expected, OutliningSpan actual)
Assert.Equal(expected.HintSpan.End, actual.HintSpan.End);
Assert.Equal(expected.BannerText, actual.BannerText);
Assert.Equal(expected.AutoCollapse, actual.AutoCollapse);
}
protected SyntaxTree ParseCode(string code)
{
return SyntaxFactory.ParseSyntaxTree(code);
}
protected string StringFromLines(params string[] lines)
{
return string.Join(Environment.NewLine, lines);
}
protected SyntaxTree ParseLines(params string[] lines)
{
var code = StringFromLines(lines);
return ParseCode(code);
Assert.Equal(expected.IsDefaultCollapsed, actual.IsDefaultCollapsed);
}
}
}
src/EditorFeatures/VisualBasicTest/BasicEditorServicesTest.vbproj
浏览文件 @ 66944d3e
......@@ -313,7 +313,6 @@
<Compile Include="Organizing\OrganizeImportsTests.vb" />
<Compile Include="Organizing\OrganizeModifiersTests.vb" />
<Compile Include="Organizing\OrganizeTypeDeclarationTests.vb" />
<Compile Include="Outlining\AbstractOutlinerTests.vb" />
<Compile Include="Outlining\AbstractOutlinerTests`1.vb" />
<Compile Include="Outlining\AccessorDeclarationOutlinerTests.vb" />
<Compile Include="Outlining\CommentTests.vb" />
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或