|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.Formatting;
using Microsoft.CodeAnalysis.Options;
using Microsoft.CodeAnalysis.Remote.Testing;
using Microsoft.CodeAnalysis.Tags;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
using Xunit.Abstractions;
using Basic.Reference.Assemblies;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.AddUsing;
[Trait(Traits.Feature, Traits.Features.CodeActionsAddImport)]
public partial class AddUsingTests : AbstractAddUsingTests
{
public AddUsingTests(ITestOutputHelper logger)
: base(logger)
{
}
[Theory, CombinatorialData]
public async Task TestTypeFromMultipleNamespaces1(TestHost testHost)
{
await TestAsync(
@"class Class
{
[|IDictionary|] Method()
{
Goo();
}
}",
@"using System.Collections;
class Class
{
IDictionary Method()
{
Goo();
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestTypeFromMultipleNamespaces1_FileScopedNamespace_Outer(TestHost testHost)
{
await TestAsync(
@"
namespace N;
class Class
{
[|IDictionary|] Method()
{
Goo();
}
}",
@"
using System.Collections;
namespace N;
class Class
{
IDictionary Method()
{
Goo();
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestTypeFromMultipleNamespaces1_FileScopedNamespace_Inner(TestHost testHost)
{
await TestAsync(
@"
namespace N;
using System;
class Class
{
[|IDictionary|] Method()
{
Goo();
}
}",
@"
namespace N;
using System;
using System.Collections;
class Class
{
IDictionary Method()
{
Goo();
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/11241")]
public async Task TestAddImportWithCaseChange(TestHost testHost)
{
await TestAsync(
@"namespace N1
{
public class TextBox
{
}
}
class Class1 : [|Textbox|]
{
}",
@"using N1;
namespace N1
{
public class TextBox
{
}
}
class Class1 : TextBox
{
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestTypeFromMultipleNamespaces2(TestHost testHost)
{
await TestAsync(
@"class Class
{
[|IDictionary|] Method()
{
Goo();
}
}",
@"using System.Collections.Generic;
class Class
{
IDictionary Method()
{
Goo();
}
}",
testHost, index: 1);
}
[Theory, CombinatorialData]
public async Task TestGenericWithNoArgs(TestHost testHost)
{
await TestAsync(
@"class Class
{
[|List|] Method()
{
Goo();
}
}",
@"using System.Collections.Generic;
class Class
{
List Method()
{
Goo();
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestGenericWithCorrectArgs(TestHost testHost)
{
await TestAsync(
@"class Class
{
[|List<int>|] Method()
{
Goo();
}
}",
@"using System.Collections.Generic;
class Class
{
List<int> Method()
{
Goo();
}
}", testHost);
}
[Fact]
public async Task TestGenericWithWrongArgs1()
{
await TestMissingInRegularAndScriptAsync(
@"class Class
{
[|List<int, string, bool>|] Method()
{
Goo();
}
}");
}
[Fact]
public async Task TestGenericWithWrongArgs2()
{
await TestMissingInRegularAndScriptAsync(
@"class Class
{
[|List<int, string>|] Method()
{
Goo();
}
}");
}
[Theory, CombinatorialData]
public async Task TestGenericInLocalDeclaration(TestHost testHost)
{
await TestAsync(
@"class Class
{
void Goo()
{
[|List<int>|] a = new List<int>();
}
}",
@"using System.Collections.Generic;
class Class
{
void Goo()
{
List<int> a = new List<int>();
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestGenericItemType(TestHost testHost)
{
await TestAsync(
@"using System.Collections.Generic;
class Class
{
List<[|Int32|]> l;
}",
@"using System;
using System.Collections.Generic;
class Class
{
List<Int32> l;
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestGenerateWithExistingUsings(TestHost testHost)
{
await TestAsync(
@"using System;
class Class
{
[|List<int>|] Method()
{
Goo();
}
}",
@"using System;
using System.Collections.Generic;
class Class
{
List<int> Method()
{
Goo();
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestGenerateInNamespace(TestHost testHost)
{
await TestAsync(
@"namespace N
{
class Class
{
[|List<int>|] Method()
{
Goo();
}
}
}",
@"using System.Collections.Generic;
namespace N
{
class Class
{
List<int> Method()
{
Goo();
}
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestGenerateInNamespaceWithUsings(TestHost testHost)
{
await TestAsync(
@"namespace N
{
using System;
class Class
{
[|List<int>|] Method()
{
Goo();
}
}
}",
@"namespace N
{
using System;
using System.Collections.Generic;
class Class
{
List<int> Method()
{
Goo();
}
}
}", testHost);
}
[Fact]
public async Task TestExistingUsing_ActionCount()
{
await TestActionCountAsync(
@"using System.Collections.Generic;
class Class
{
[|IDictionary|] Method()
{
Goo();
}
}",
count: 1);
}
[Theory, CombinatorialData]
public async Task TestExistingUsing(TestHost testHost)
{
await TestAsync(
@"using System.Collections.Generic;
class Class
{
[|IDictionary|] Method()
{
Goo();
}
}",
@"using System.Collections;
using System.Collections.Generic;
class Class
{
IDictionary Method()
{
Goo();
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541730")]
public async Task TestAddUsingForGenericExtensionMethod(TestHost testHost)
{
await TestAsync(
@"using System.Collections.Generic;
class Class
{
void Method(IList<int> args)
{
args.[|Where|]() }
}",
@"using System.Collections.Generic;
using System.Linq;
class Class
{
void Method(IList<int> args)
{
args.Where() }
}", testHost);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541730")]
public async Task TestAddUsingForNormalExtensionMethod()
{
await TestAsync(
@"class Class
{
void Method(Class args)
{
args.[|Where|]() }
}
namespace N
{
static class E
{
public static void Where(this Class c)
{
}
}
}",
@"using N;
class Class
{
void Method(Class args)
{
args.Where() }
}
namespace N
{
static class E
{
public static void Where(this Class c)
{
}
}
}",
parseOptions: Options.Regular);
}
[Theory, CombinatorialData]
public async Task TestOnEnum(TestHost testHost)
{
await TestAsync(
@"class Class
{
void Goo()
{
var a = [|Colors|].Red;
}
}
namespace A
{
enum Colors
{
Red,
Green,
Blue
}
}",
@"using A;
class Class
{
void Goo()
{
var a = Colors.Red;
}
}
namespace A
{
enum Colors
{
Red,
Green,
Blue
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestOnClassInheritance(TestHost testHost)
{
await TestAsync(
@"class Class : [|Class2|]
{
}
namespace A
{
class Class2
{
}
}",
@"using A;
class Class : Class2
{
}
namespace A
{
class Class2
{
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestOnImplementedInterface(TestHost testHost)
{
await TestAsync(
@"class Class : [|IGoo|]
{
}
namespace A
{
interface IGoo
{
}
}",
@"using A;
class Class : IGoo
{
}
namespace A
{
interface IGoo
{
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAllInBaseList(TestHost testHost)
{
await TestAsync(
@"class Class : [|IGoo|], Class2
{
}
namespace A
{
class Class2
{
}
}
namespace B
{
interface IGoo
{
}
}",
@"using B;
class Class : IGoo, Class2
{
}
namespace A
{
class Class2
{
}
}
namespace B
{
interface IGoo
{
}
}", testHost);
await TestAsync(
@"using B;
class Class : IGoo, [|Class2|]
{
}
namespace A
{
class Class2
{
}
}
namespace B
{
interface IGoo
{
}
}",
@"using A;
using B;
class Class : IGoo, Class2
{
}
namespace A
{
class Class2
{
}
}
namespace B
{
interface IGoo
{
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAttributeUnexpanded(TestHost testHost)
{
await TestAsync(
@"[[|Obsolete|]]
class Class
{
}",
@"using System;
[Obsolete]
class Class
{
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAttributeExpanded(TestHost testHost)
{
await TestAsync(
@"[[|ObsoleteAttribute|]]
class Class
{
}",
@"using System;
[ObsoleteAttribute]
class Class
{
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538018")]
public async Task TestAfterNew(TestHost testHost)
{
await TestAsync(
@"class Class
{
void Goo()
{
List<int> l;
l = new [|List<int>|]();
}
}",
@"using System.Collections.Generic;
class Class
{
void Goo()
{
List<int> l;
l = new List<int>();
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestArgumentsInMethodCall(TestHost testHost)
{
await TestAsync(
@"class Class
{
void Test()
{
Console.WriteLine([|DateTime|].Today);
}
}",
@"using System;
class Class
{
void Test()
{
Console.WriteLine(DateTime.Today);
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestCallSiteArgs(TestHost testHost)
{
await TestAsync(
@"class Class
{
void Test([|DateTime|] dt)
{
}
}",
@"using System;
class Class
{
void Test(DateTime dt)
{
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestUsePartialClass(TestHost testHost)
{
await TestAsync(
@"namespace A
{
public class Class
{
[|PClass|] c;
}
}
namespace B
{
public partial class PClass
{
}
}",
@"using B;
namespace A
{
public class Class
{
PClass c;
}
}
namespace B
{
public partial class PClass
{
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestGenericClassInNestedNamespace(TestHost testHost)
{
await TestAsync(
@"namespace A
{
namespace B
{
class GenericClass<T>
{
}
}
}
namespace C
{
class Class
{
[|GenericClass<int>|] c;
}
}",
@"using A.B;
namespace A
{
namespace B
{
class GenericClass<T>
{
}
}
}
namespace C
{
class Class
{
GenericClass<int> c;
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541730")]
public async Task TestExtensionMethods(TestHost testHost)
{
await TestAsync(
@"using System.Collections.Generic;
class Goo
{
void Bar()
{
var values = new List<int>();
values.[|Where|](i => i > 1);
}
}",
@"using System.Collections.Generic;
using System.Linq;
class Goo
{
void Bar()
{
var values = new List<int>();
values.Where(i => i > 1);
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541730")]
public async Task TestQueryPatterns(TestHost testHost)
{
await TestAsync(
@"using System.Collections.Generic;
class Goo
{
void Bar()
{
var values = new List<int>();
var q = [|from v in values
where v > 1
select v + 10|];
}
}",
@"using System.Collections.Generic;
using System.Linq;
class Goo
{
void Bar()
{
var values = new List<int>();
var q = from v in values
where v > 1
select v + 10;
}
}", testHost);
}
// Tests for Insertion Order
[Theory, CombinatorialData]
public async Task TestSimplePresortedUsings1(TestHost testHost)
{
await TestAsync(
@"using B;
using C;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace D
{
class Goo
{
public static void Bar()
{
}
}
}",
@"using B;
using C;
using D;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace D
{
class Goo
{
public static void Bar()
{
}
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestSimplePresortedUsings2(TestHost testHost)
{
await TestAsync(
@"using B;
using C;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
@"using A;
using B;
using C;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestSimpleUnsortedUsings1(TestHost testHost)
{
await TestAsync(
@"using C;
using B;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
@"using C;
using B;
using A;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestSimpleUnsortedUsings2(TestHost testHost)
{
await TestAsync(
@"using D;
using B;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace C
{
class Goo
{
public static void Bar()
{
}
}
}",
@"using D;
using B;
using C;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace C
{
class Goo
{
public static void Bar()
{
}
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestMultiplePresortedUsings1(TestHost testHost)
{
await TestAsync(
@"using B.X;
using B.Y;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace B
{
class Goo
{
public static void Bar()
{
}
}
}",
@"using B;
using B.X;
using B.Y;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace B
{
class Goo
{
public static void Bar()
{
}
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestMultiplePresortedUsings2(TestHost testHost)
{
await TestAsync(
@"using B.X;
using B.Y;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace B.A
{
class Goo
{
public static void Bar()
{
}
}
}",
@"using B.A;
using B.X;
using B.Y;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace B.A
{
class Goo
{
public static void Bar()
{
}
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestMultiplePresortedUsings3(TestHost testHost)
{
await TestAsync(
@"using B.X;
using B.Y;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace B
{
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}
}",
@"using B.A;
using B.X;
using B.Y;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace B
{
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestMultipleUnsortedUsings1(TestHost testHost)
{
await TestAsync(
@"using B.Y;
using B.X;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace B
{
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}
}",
@"using B.Y;
using B.X;
using B.A;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace B
{
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestMultipleUnsortedUsings2(TestHost testHost)
{
await TestAsync(
@"using B.Y;
using B.X;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace B
{
class Goo
{
public static void Bar()
{
}
}
}",
@"using B.Y;
using B.X;
using B;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace B
{
class Goo
{
public static void Bar()
{
}
}
}", testHost);
}
// System on top cases
[Theory, CombinatorialData]
public async Task TestSimpleSystemSortedUsings1(TestHost testHost)
{
await TestAsync(
@"using System;
using B;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
@"using System;
using A;
using B;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
testHost);
}
[Theory, CombinatorialData]
public async Task TestSimpleSystemSortedUsings2(TestHost testHost)
{
await TestAsync(
@"using System;
using System.Collections.Generic;
using B;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
@"using System;
using System.Collections.Generic;
using A;
using B;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
testHost);
}
[Theory, CombinatorialData]
public async Task TestSimpleSystemSortedUsings3(TestHost testHost)
{
await TestAsync(
@"using A;
using B;
class Class
{
void Method()
{
[|Console|].Write(1);
}
}",
@"using System;
using A;
using B;
class Class
{
void Method()
{
Console.Write(1);
}
}",
testHost);
}
[Theory, CombinatorialData]
public async Task TestSimpleSystemUnsortedUsings1(TestHost testHost)
{
await TestAsync(
@"
using C;
using B;
using System;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
@"
using C;
using B;
using System;
using A;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
testHost);
}
[Theory, CombinatorialData]
public async Task TestSimpleSystemUnsortedUsings2(TestHost testHost)
{
await TestAsync(
@"using System.Collections.Generic;
using System;
using B;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
@"using System.Collections.Generic;
using System;
using B;
using A;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
testHost);
}
[Theory, CombinatorialData]
public async Task TestSimpleSystemUnsortedUsings3(TestHost testHost)
{
await TestAsync(
@"using B;
using A;
class Class
{
void Method()
{
[|Console|].Write(1);
}
}",
@"using B;
using A;
using System;
class Class
{
void Method()
{
Console.Write(1);
}
}",
testHost);
}
[Theory, CombinatorialData]
public async Task TestSimpleBogusSystemUsings1(TestHost testHost)
{
await TestAsync(
@"using A.System;
class Class
{
void Method()
{
[|Console|].Write(1);
}
}",
@"using System;
using A.System;
class Class
{
void Method()
{
Console.Write(1);
}
}",
testHost);
}
[Theory, CombinatorialData]
public async Task TestSimpleBogusSystemUsings2(TestHost testHost)
{
await TestAsync(
@"using System.System;
class Class
{
void Method()
{
[|Console|].Write(1);
}
}",
@"using System;
using System.System;
class Class
{
void Method()
{
Console.Write(1);
}
}",
testHost);
}
[Theory, CombinatorialData]
public async Task TestUsingsWithComments(TestHost testHost)
{
await TestAsync(
@"using System./*...*/.Collections.Generic;
class Class
{
void Method()
{
[|Console|].Write(1);
}
}",
@"using System;
using System./*...*/.Collections.Generic;
class Class
{
void Method()
{
Console.Write(1);
}
}",
testHost);
}
// System Not on top cases
[Theory, CombinatorialData]
public async Task TestSimpleSystemUnsortedUsings4(TestHost testHost)
{
await TestAsync(
@"
using C;
using System;
using B;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
@"
using C;
using System;
using B;
using A;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
testHost);
}
[Theory, CombinatorialData]
public async Task TestSimpleSystemSortedUsings5(TestHost testHost)
{
await TestAsync(
@"using B;
using System;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
@"using A;
using B;
using System;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
testHost);
}
[Theory, CombinatorialData]
public async Task TestSimpleSystemSortedUsings4(TestHost testHost)
{
await TestAsync(
@"using A;
using B;
class Class
{
void Method()
{
[|Console|].Write(1);
}
}",
@"using A;
using B;
using System;
class Class
{
void Method()
{
Console.Write(1);
}
}",
testHost, options: Option(GenerationOptions.PlaceSystemNamespaceFirst, false));
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538136")]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538763")]
public async Task TestAddUsingForNamespace()
{
await TestMissingInRegularAndScriptAsync(
@"namespace A
{
class Class
{
[|C|].Test t;
}
}
namespace B
{
namespace C
{
class Test
{
}
}
}");
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538220")]
public async Task TestAddUsingForFieldWithFormatting(TestHost testHost)
{
await TestAsync(
@"class C { [|DateTime|] t; }",
@"using System;
class C { DateTime t; }", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539657")]
public async Task BugFix5688(TestHost testHost)
{
await TestAsync(
@"class Program { static void Main ( string [ ] args ) { [|Console|] . Out . NewLine = ""\r\n\r\n"" ; } } ",
@"using System;
class Program { static void Main ( string [ ] args ) { Console . Out . NewLine = ""\r\n\r\n"" ; } } ", testHost);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539853")]
public async Task BugFix5950()
{
await TestAsync(
@"using System.Console; WriteLine([|Expression|].Constant(123));",
@"using System.Console;
using System.Linq.Expressions;
WriteLine(Expression.Constant(123));",
parseOptions: GetScriptOptions());
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/540339")]
public async Task TestAddAfterDefineDirective1(TestHost testHost)
{
await TestAsync(
@"#define goo
using System.Collections.Generic;
using System.Linq;
class Program
{
static void Main(string[] args)
{
[|Console|].WriteLine();
}
}",
@"#define goo
using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static void Main(string[] args)
{
Console.WriteLine();
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/540339")]
public async Task TestAddAfterDefineDirective2(TestHost testHost)
{
await TestAsync(
@"#define goo
class Program
{
static void Main(string[] args)
{
[|Console|].WriteLine();
}
}",
@"#define goo
using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine();
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddAfterDefineDirective3(TestHost testHost)
{
await TestAsync(
@"#define goo
/// Goo
class Program
{
static void Main(string[] args)
{
[|Console|].WriteLine();
}
}",
@"#define goo
using System;
/// Goo
class Program
{
static void Main(string[] args)
{
Console.WriteLine();
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddAfterDefineDirective4(TestHost testHost)
{
await TestAsync(
@"#define goo
// Goo
class Program
{
static void Main(string[] args)
{
[|Console|].WriteLine();
}
}",
@"#define goo
// Goo
using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine();
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddAfterExistingBanner(TestHost testHost)
{
await TestAsync(
@"// Banner
// Banner
class Program
{
static void Main(string[] args)
{
[|Console|].WriteLine();
}
}",
@"// Banner
// Banner
using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine();
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddAfterExternAlias1(TestHost testHost)
{
await TestAsync(
@"#define goo
extern alias Goo;
class Program
{
static void Main(string[] args)
{
[|Console|].WriteLine();
}
}",
@"#define goo
extern alias Goo;
using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine();
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddAfterExternAlias2(TestHost testHost)
{
await TestAsync(
@"#define goo
extern alias Goo;
using System.Collections;
class Program
{
static void Main(string[] args)
{
[|Console|].WriteLine();
}
}",
@"#define goo
extern alias Goo;
using System;
using System.Collections;
class Program
{
static void Main(string[] args)
{
Console.WriteLine();
}
}", testHost);
}
[Fact]
public async Task TestWithReferenceDirective()
{
var resolver = new TestMetadataReferenceResolver(assemblyNames: new Dictionary<string, PortableExecutableReference>()
{
{ "exprs", AssemblyMetadata.CreateFromImage(Net461.Resources.SystemCore).GetReference() }
});
await TestAsync(
@"#r ""exprs""
[|Expression|]",
@"#r ""exprs""
using System.Linq.Expressions;
Expression",
GetScriptOptions(),
TestOptions.ReleaseDll.WithMetadataReferenceResolver(resolver));
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/542643")]
public async Task TestAssemblyAttribute(TestHost testHost)
{
await TestAsync(
@"[assembly: [|InternalsVisibleTo|](""Project"")]",
@"using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo(""Project"")]", testHost);
}
[Fact]
public async Task TestDoNotAddIntoHiddenRegion()
{
await TestMissingInRegularAndScriptAsync(
@"#line hidden
using System.Collections.Generic;
#line default
class Program
{
void Main()
{
[|DateTime|] d;
}
}");
}
[Theory, CombinatorialData]
public async Task TestAddToVisibleRegion(TestHost testHost)
{
await TestAsync(
@"#line default
using System.Collections.Generic;
#line hidden
class Program
{
void Main()
{
#line default
[|DateTime|] d;
#line hidden
}
}
#line default",
@"#line default
using System;
using System.Collections.Generic;
#line hidden
class Program
{
void Main()
{
#line default
DateTime d;
#line hidden
}
}
#line default", testHost);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545248")]
public async Task TestVenusGeneration1()
{
await TestMissingInRegularAndScriptAsync(
@"class C
{
void Goo()
{
#line 1 ""Default.aspx""
using (new [|StreamReader|]())
{
#line default
#line hidden
}
}");
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545774")]
public async Task TestAttribute_ActionCount()
{
var input = @"[ assembly : [|Guid|] ( ""9ed54f84-a89d-4fcd-a854-44251e925f09"" ) ] ";
await TestActionCountAsync(input, 2);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545774")]
public async Task TestAttribute(TestHost testHost)
{
var input = @"[ assembly : [|Guid|] ( ""9ed54f84-a89d-4fcd-a854-44251e925f09"" ) ] ";
await TestAsync(
input,
@"using System.Runtime.InteropServices;
[assembly : Guid ( ""9ed54f84-a89d-4fcd-a854-44251e925f09"" ) ] ", testHost);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/546833")]
public async Task TestNotOnOverloadResolutionError()
{
await TestMissingInRegularAndScriptAsync(
@"namespace ConsoleApplication1
{
class Program
{
void Main()
{
var test = new [|Test|]("""");
}
}
class Test
{
}
}");
}
[Theory, CombinatorialData]
[WorkItem(17020, "DevDiv_Projects/Roslyn")]
public async Task TestAddUsingForGenericArgument(TestHost testHost)
{
await TestAsync(
@"namespace ConsoleApplication10
{
class Program
{
static void Main(string[] args)
{
var inArgument = new InArgument<[|IEnumerable<int>|]>(new int[] { 1, 2, 3 });
}
}
public class InArgument<T>
{
public InArgument(T constValue)
{
}
}
}",
@"using System.Collections.Generic;
namespace ConsoleApplication10
{
class Program
{
static void Main(string[] args)
{
var inArgument = new InArgument<IEnumerable<int>>(new int[] { 1, 2, 3 });
}
}
public class InArgument<T>
{
public InArgument(T constValue)
{
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/775448")]
public async Task ShouldTriggerOnCS0308(TestHost testHost)
{
// CS0308: The non-generic type 'A' cannot be used with type arguments
await TestAsync(
@"using System.Collections;
class Test
{
static void Main(string[] args)
{
[|IEnumerable<int>|] f;
}
}",
@"using System.Collections;
using System.Collections.Generic;
class Test
{
static void Main(string[] args)
{
IEnumerable<int> f;
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/838253")]
public async Task TestConflictedInaccessibleType(TestHost testHost)
{
await TestAsync(
@"using System.Diagnostics;
namespace N
{
public class Log
{
}
}
class C
{
static void Main(string[] args)
{
[|Log|] }
}",
@"using System.Diagnostics;
using N;
namespace N
{
public class Log
{
}
}
class C
{
static void Main(string[] args)
{
Log }
}",
testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/858085")]
public async Task TestConflictedAttributeName(TestHost testHost)
{
await TestAsync(
@"[[|Description|]]
class Description
{
}",
@"using System.ComponentModel;
[Description]
class Description
{
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/872908")]
public async Task TestConflictedGenericName(TestHost testHost)
{
await TestAsync(
@"using Task = System.AccessViolationException;
class X
{
[|Task<X> x;|]
}",
@"using System.Threading.Tasks;
using Task = System.AccessViolationException;
class X
{
Task<X> x;
}", testHost);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/913300")]
public async Task TestNoDuplicateReport_ActionCount()
{
await TestActionCountInAllFixesAsync(
@"class C
{
void M(P p)
{
[|Console|]
}
static void Main(string[] args)
{
}
}", count: 1);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/913300")]
public async Task TestNoDuplicateReport(TestHost testHost)
{
await TestAsync(
@"class C
{
void M(P p)
{
[|Console|] }
static void Main(string[] args)
{
}
}",
@"using System;
class C
{
void M(P p)
{
Console }
static void Main(string[] args)
{
}
}", testHost);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/938296")]
public async Task TestNullParentInNode()
{
await TestMissingInRegularAndScriptAsync(
@"using System.Collections.Generic;
class MultiDictionary<K, V> : Dictionary<K, HashSet<V>>
{
void M()
{
new HashSet<V>([|Comparer|]);
}
}");
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/968303")]
public async Task TestMalformedUsingSection()
{
await TestMissingInRegularAndScriptAsync(
@"[ class Class
{
[|List<|] }");
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/875899")]
public async Task TestAddUsingsWithExternAlias(TestHost testHost)
{
const string InitialWorkspace = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""lib"" CommonReferences=""true"">
<Document FilePath=""lib.cs"">
namespace ProjectLib
{
public class Project
{
}
}
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Console"" CommonReferences=""true"">
<ProjectReference Alias=""P"">lib</ProjectReference>
<Document FilePath=""Program.cs"">
namespace ExternAliases
{
class Program
{
static void Main(string[] args)
{
Project p = new [|Project()|];
}
}
}
</Document>
</Project>
</Workspace>";
const string ExpectedDocumentText = @"extern alias P;
using P::ProjectLib;
namespace ExternAliases
{
class Program
{
static void Main(string[] args)
{
Project p = new Project();
}
}
}
";
await TestAsync(InitialWorkspace, ExpectedDocumentText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/875899")]
public async Task TestAddUsingsWithPreExistingExternAlias(TestHost testHost)
{
const string InitialWorkspace = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""lib"" CommonReferences=""true"">
<Document FilePath=""lib.cs"">
namespace ProjectLib
{
public class Project
{
}
}
namespace AnotherNS
{
public class AnotherClass
{
}
}
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Console"" CommonReferences=""true"">
<ProjectReference Alias=""P"">lib</ProjectReference>
<Document FilePath=""Program.cs"">
extern alias P;
using P::ProjectLib;
namespace ExternAliases
{
class Program
{
static void Main(string[] args)
{
Project p = new Project();
var x = new [|AnotherClass()|];
}
}
}
</Document>
</Project>
</Workspace>";
const string ExpectedDocumentText = @"
extern alias P;
using P::AnotherNS;
using P::ProjectLib;
namespace ExternAliases
{
class Program
{
static void Main(string[] args)
{
Project p = new Project();
var x = new [|AnotherClass()|];
}
}
}
";
await TestAsync(InitialWorkspace, ExpectedDocumentText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/875899")]
public async Task TestAddUsingsWithPreExistingExternAlias_FileScopedNamespace(TestHost testHost)
{
const string InitialWorkspace = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""lib"" CommonReferences=""true"">
<Document FilePath=""lib.cs"">
namespace ProjectLib;
{
public class Project
{
}
}
namespace AnotherNS
{
public class AnotherClass
{
}
}
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Console"" CommonReferences=""true"">
<ProjectReference Alias=""P"">lib</ProjectReference>
<Document FilePath=""Program.cs"">
extern alias P;
using P::ProjectLib;
namespace ExternAliases;
class Program
{
static void Main(string[] args)
{
Project p = new Project();
var x = new [|AnotherClass()|];
}
}
</Document>
</Project>
</Workspace>";
const string ExpectedDocumentText = @"
extern alias P;
using P::AnotherNS;
using P::ProjectLib;
namespace ExternAliases;
class Program
{
static void Main(string[] args)
{
Project p = new Project();
var x = new [|AnotherClass()|];
}
}
";
await TestAsync(InitialWorkspace, ExpectedDocumentText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/875899")]
public async Task TestAddUsingsNoExtern(TestHost testHost)
{
const string InitialWorkspace = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""lib"" CommonReferences=""true"">
<Document FilePath=""lib.cs"">
namespace AnotherNS
{
public class AnotherClass
{
}
}
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Console"" CommonReferences=""true"">
<ProjectReference Alias=""P"">lib</ProjectReference>
<Document FilePath=""Program.cs"">
using P::AnotherNS;
namespace ExternAliases
{
class Program
{
static void Main(string[] args)
{
var x = new [|AnotherClass()|];
}
}
}
</Document>
</Project>
</Workspace>";
const string ExpectedDocumentText = @"extern alias P;
using P::AnotherNS;
namespace ExternAliases
{
class Program
{
static void Main(string[] args)
{
var x = new AnotherClass();
}
}
}
";
await TestAsync(InitialWorkspace, ExpectedDocumentText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/875899")]
public async Task TestAddUsingsNoExtern_FileScopedNamespace(TestHost testHost)
{
const string InitialWorkspace = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""lib"" CommonReferences=""true"">
<Document FilePath=""lib.cs"">
namespace AnotherNS;
public class AnotherClass
{
}
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Console"" CommonReferences=""true"">
<ProjectReference Alias=""P"">lib</ProjectReference>
<Document FilePath=""Program.cs"">
using P::AnotherNS;
namespace ExternAliases;
class Program
{
static void Main(string[] args)
{
var x = new [|AnotherClass()|];
}
}
</Document>
</Project>
</Workspace>";
const string ExpectedDocumentText = @"extern alias P;
using P::AnotherNS;
namespace ExternAliases;
class Program
{
static void Main(string[] args)
{
var x = new AnotherClass();
}
}
";
await TestAsync(InitialWorkspace, ExpectedDocumentText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/875899")]
public async Task TestAddUsingsNoExternFilterGlobalAlias(TestHost testHost)
{
await TestAsync(
@"class Program
{
static void Main(string[] args)
{
[|INotifyPropertyChanged.PropertyChanged|]
}
}",
@"using System.ComponentModel;
class Program
{
static void Main(string[] args)
{
INotifyPropertyChanged.PropertyChanged
}
}", testHost);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/916368")]
public async Task TestAddUsingForCref()
{
var initialText =
@"/// <summary>
/// This is just like <see cref='[|INotifyPropertyChanged|]'/>, but this one is mine.
/// </summary>
interface MyNotifyPropertyChanged { }";
var expectedText =
@"using System.ComponentModel;
/// <summary>
/// This is just like <see cref='INotifyPropertyChanged'/>, but this one is mine.
/// </summary>
interface MyNotifyPropertyChanged { }";
var options = new CSharpParseOptions(documentationMode: DocumentationMode.Diagnose);
await TestAsync(initialText, expectedText, parseOptions: options);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/916368")]
public async Task TestAddUsingForCref2()
{
var initialText =
@"/// <summary>
/// This is just like <see cref='[|INotifyPropertyChanged.PropertyChanged|]'/>, but this one is mine.
/// </summary>
interface MyNotifyPropertyChanged { }";
var expectedText =
@"using System.ComponentModel;
/// <summary>
/// This is just like <see cref='INotifyPropertyChanged.PropertyChanged'/>, but this one is mine.
/// </summary>
interface MyNotifyPropertyChanged { }";
var options = new CSharpParseOptions(documentationMode: DocumentationMode.Diagnose);
await TestAsync(initialText, expectedText, parseOptions: options);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/916368")]
public async Task TestAddUsingForCref3()
{
var initialText =
@"namespace N1
{
public class D { }
}
public class MyClass
{
public static explicit operator N1.D (MyClass f)
{
return default(N1.D);
}
}
/// <seealso cref='MyClass.explicit operator [|D(MyClass)|]'/>
public class MyClass2
{
}";
var expectedText =
@"using N1;
namespace N1
{
public class D { }
}
public class MyClass
{
public static explicit operator N1.D (MyClass f)
{
return default(N1.D);
}
}
/// <seealso cref='MyClass.explicit operator D(MyClass)'/>
public class MyClass2
{
}";
var options = new CSharpParseOptions(documentationMode: DocumentationMode.Diagnose);
await TestAsync(initialText, expectedText, parseOptions: options);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/916368")]
public async Task TestAddUsingForCref4()
{
var initialText =
@"namespace N1
{
public class D { }
}
/// <seealso cref='[|Test(D)|]'/>
public class MyClass
{
public void Test(N1.D i)
{
}
}";
var expectedText =
@"using N1;
namespace N1
{
public class D { }
}
/// <seealso cref='Test(D)'/>
public class MyClass
{
public void Test(N1.D i)
{
}
}";
var options = new CSharpParseOptions(documentationMode: DocumentationMode.Diagnose);
await TestAsync(initialText, expectedText, parseOptions: options);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/773614")]
public async Task TestAddStaticType(TestHost testHost)
{
var initialText =
@"using System;
public static class Outer
{
[AttributeUsage(AttributeTargets.All)]
public class MyAttribute : Attribute
{
}
}
[[|My|]]
class Test
{}";
var expectedText =
@"using System;
using static Outer;
public static class Outer
{
[AttributeUsage(AttributeTargets.All)]
public class MyAttribute : Attribute
{
}
}
[My]
class Test
{}";
await TestAsync(initialText, expectedText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/773614")]
public async Task TestAddStaticType2(TestHost testHost)
{
var initialText =
@"using System;
public static class Outer
{
public static class Inner
{
[AttributeUsage(AttributeTargets.All)]
public class MyAttribute : Attribute
{
}
}
}
[[|My|]]
class Test
{}";
var expectedText =
@"using System;
using static Outer.Inner;
public static class Outer
{
public static class Inner
{
[AttributeUsage(AttributeTargets.All)]
public class MyAttribute : Attribute
{
}
}
}
[My]
class Test
{}";
await TestAsync(initialText, expectedText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/773614")]
public async Task TestAddStaticType3(TestHost testHost)
{
await TestAsync(
@"using System;
public static class Outer
{
public class Inner
{
[AttributeUsage(AttributeTargets.All)]
public class MyAttribute : Attribute
{
}
}
}
[[|My|]]
class Test
{
}",
@"using System;
using static Outer.Inner;
public static class Outer
{
public class Inner
{
[AttributeUsage(AttributeTargets.All)]
public class MyAttribute : Attribute
{
}
}
}
[My]
class Test
{
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/773614")]
public async Task TestAddStaticType4(TestHost testHost)
{
var initialText =
@"using System;
using Outer;
public static class Outer
{
public static class Inner
{
[AttributeUsage(AttributeTargets.All)]
public class MyAttribute : Attribute
{
}
}
}
[[|My|]]
class Test
{}";
var expectedText =
@"using System;
using Outer;
using static Outer.Inner;
public static class Outer
{
public static class Inner
{
[AttributeUsage(AttributeTargets.All)]
public class MyAttribute : Attribute
{
}
}
}
[My]
class Test
{}";
await TestAsync(initialText, expectedText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/991463")]
public async Task TestAddInsideUsingDirective1(TestHost testHost)
{
await TestAsync(
@"namespace ns
{
using B = [|Byte|];
}",
@"using System;
namespace ns
{
using B = Byte;
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/991463")]
public async Task TestAddInsideUsingDirective2(TestHost testHost)
{
await TestAsync(
@"using System.Collections;
namespace ns
{
using B = [|Byte|];
}",
@"using System;
using System.Collections;
namespace ns
{
using B = Byte;
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/991463")]
public async Task TestAddInsideUsingDirective3(TestHost testHost)
{
await TestAsync(
@"namespace ns2
{
namespace ns3
{
namespace ns
{
using B = [|Byte|];
namespace ns4
{
}
}
}
}",
@"using System;
namespace ns2
{
namespace ns3
{
namespace ns
{
using B = Byte;
namespace ns4
{
}
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/991463")]
public async Task TestAddInsideUsingDirective4(TestHost testHost)
{
await TestAsync(
@"namespace ns2
{
using System.Collections;
namespace ns3
{
namespace ns
{
using System.IO;
using B = [|Byte|];
}
}
}",
@"namespace ns2
{
using System;
using System.Collections;
namespace ns3
{
namespace ns
{
using System.IO;
using B = Byte;
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/991463")]
public async Task TestAddInsideUsingDirective5(TestHost testHost)
{
await TestAsync(
@"using System.IO;
namespace ns2
{
using System.Diagnostics;
namespace ns3
{
using System.Collections;
namespace ns
{
using B = [|Byte|];
}
}
}",
@"using System.IO;
namespace ns2
{
using System.Diagnostics;
namespace ns3
{
using System;
using System.Collections;
namespace ns
{
using B = Byte;
}
}
}", testHost);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/991463")]
public async Task TestAddInsideUsingDirective6()
{
await TestMissingInRegularAndScriptAsync(
@"using B = [|Byte|];");
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
public async Task TestAddConditionalAccessExpression(TestHost testHost)
{
var initialText =
@"<Workspace>
<Project Language=""C#"" AssemblyName=""CSAssembly"" CommonReferences=""true"">
<Document FilePath = ""Program"">
public class C
{
void Main(C a)
{
C x = a?[|.B()|];
}
}
</Document>
<Document FilePath = ""Extensions"">
namespace Extensions
{
public static class E
{
public static C B(this C c) { return c; }
}
}
</Document>
</Project>
</Workspace> ";
var expectedText =
@"
using Extensions;
public class C
{
void Main(C a)
{
C x = a?.B();
}
}
";
await TestAsync(initialText, expectedText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1064748")]
public async Task TestAddConditionalAccessExpression2(TestHost testHost)
{
var initialText =
@"<Workspace>
<Project Language=""C#"" AssemblyName=""CSAssembly"" CommonReferences=""true"">
<Document FilePath = ""Program"">
public class C
{
public E B { get; private set; }
void Main(C a)
{
int? x = a?.B.[|C()|];
}
public class E
{
}
}
</Document>
<Document FilePath = ""Extensions"">
namespace Extensions
{
public static class D
{
public static C.E C(this C.E c) { return c; }
}
}
</Document>
</Project>
</Workspace> ";
var expectedText =
@"
using Extensions;
public class C
{
public E B { get; private set; }
void Main(C a)
{
int? x = a?.B.C();
}
public class E
{
}
}
";
await TestAsync(initialText, expectedText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1089138")]
public async Task TestAmbiguousUsingName(TestHost testHost)
{
await TestAsync(
@"namespace ClassLibrary1
{
using System;
public class SomeTypeUser
{
[|SomeType|] field;
}
}
namespace SubNamespaceName
{
using System;
class SomeType
{
}
}
namespace ClassLibrary1.SubNamespaceName
{
using System;
class SomeOtherFile
{
}
}",
@"namespace ClassLibrary1
{
using System;
using global::SubNamespaceName;
public class SomeTypeUser
{
SomeType field;
}
}
namespace SubNamespaceName
{
using System;
class SomeType
{
}
}
namespace ClassLibrary1.SubNamespaceName
{
using System;
class SomeOtherFile
{
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddUsingInDirective(TestHost testHost)
{
await TestAsync(
@"#define DEBUG
#if DEBUG
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Text;
#endif
class Program
{
static void Main(string[] args)
{
var a = [|File|].OpenRead("""");
}
}",
@"#define DEBUG
#if DEBUG
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Text;
using System.IO;
#endif
class Program
{
static void Main(string[] args)
{
var a = File.OpenRead("""");
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddUsingInDirective2(TestHost testHost)
{
await TestAsync(
@"#define DEBUG
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
#if DEBUG
using System.Text;
#endif
class Program { static void Main ( string [ ] args ) { var a = [|File|] . OpenRead ( """" ) ; } } ",
@"#define DEBUG
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.IO;
#if DEBUG
using System.Text;
#endif
class Program { static void Main ( string [ ] args ) { var a = File . OpenRead ( """" ) ; } } ", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddUsingInDirective3(TestHost testHost)
{
await TestAsync(
@"#define DEBUG
using System;
using System.Collections.Generic;
#if DEBUG
using System.Text;
#endif
using System.Linq;
using System.Threading.Tasks;
class Program { static void Main ( string [ ] args ) { var a = [|File|] . OpenRead ( """" ) ; } } ",
@"#define DEBUG
using System;
using System.Collections.Generic;
#if DEBUG
using System.Text;
#endif
using System.Linq;
using System.Threading.Tasks;
using System.IO;
class Program { static void Main ( string [ ] args ) { var a = File . OpenRead ( """" ) ; } } ", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddUsingInDirective4(TestHost testHost)
{
await TestAsync(
@"#define DEBUG
#if DEBUG
using System;
#endif
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Threading.Tasks;
class Program { static void Main ( string [ ] args ) { var a = [|File|] . OpenRead ( """" ) ; } } ",
@"#define DEBUG
#if DEBUG
using System;
#endif
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Threading.Tasks;
using System.IO;
class Program { static void Main ( string [ ] args ) { var a = File . OpenRead ( """" ) ; } } ", testHost);
}
[Fact]
public async Task TestInaccessibleExtensionMethod()
{
const string initial = @"
namespace N1
{
public static class C
{
private static bool ExtMethod1(this string arg1)
{
return true;
}
}
}
namespace N2
{
class Program
{
static void Main(string[] args)
{
var x = ""str1"".[|ExtMethod1()|];
}
}
}";
await TestMissingInRegularAndScriptAsync(initial);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1116011")]
public async Task TestAddUsingForProperty(TestHost testHost)
{
await TestAsync(
@"using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
class Program
{
public BindingFlags BindingFlags
{
get
{
return BindingFlags.[|Instance|];
}
}
}",
@"using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
class Program
{
public BindingFlags BindingFlags
{
get
{
return BindingFlags.Instance;
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1116011")]
public async Task TestAddUsingForField(TestHost testHost)
{
await TestAsync(
@"using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
class Program
{
public B B
{
get
{
return B.[|Instance|];
}
}
}
namespace A
{
public class B
{
public static readonly B Instance;
}
}",
@"using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using A;
class Program
{
public B B
{
get
{
return B.Instance;
}
}
}
namespace A
{
public class B
{
public static readonly B Instance;
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/1893")]
public async Task TestNameSimplification(TestHost testHost)
{
// Generated using directive must be simplified from "using A.B;" to "using B;" below.
await TestAsync(
@"namespace A.B
{
class T1
{
}
}
namespace A.C
{
using System;
class T2
{
void Test()
{
Console.WriteLine();
[|T1|] t1;
}
}
}",
@"namespace A.B
{
class T1
{
}
}
namespace A.C
{
using System;
using A.B;
class T2
{
void Test()
{
Console.WriteLine();
T1 t1;
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/935")]
public async Task TestAddUsingWithOtherExtensionsInScope(TestHost testHost)
{
await TestAsync(
@"using System.Linq;
using System.Collections;
using X;
namespace X
{
public static class Ext
{
public static void ExtMethod(this int a)
{
}
}
}
namespace Y
{
public static class Ext
{
public static void ExtMethod(this int a, int v)
{
}
}
}
public class B
{
static void Main()
{
var b = 0;
b.[|ExtMethod|](0);
}
}",
@"using System.Linq;
using System.Collections;
using X;
using Y;
namespace X
{
public static class Ext
{
public static void ExtMethod(this int a)
{
}
}
}
namespace Y
{
public static class Ext
{
public static void ExtMethod(this int a, int v)
{
}
}
}
public class B
{
static void Main()
{
var b = 0;
b.ExtMethod(0);
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/935")]
public async Task TestAddUsingWithOtherExtensionsInScope2(TestHost testHost)
{
await TestAsync(
@"using System.Linq;
using System.Collections;
using X;
namespace X
{
public static class Ext
{
public static void ExtMethod(this int? a)
{
}
}
}
namespace Y
{
public static class Ext
{
public static void ExtMethod(this int? a, int v)
{
}
}
}
public class B
{
static void Main()
{
var b = new int?();
b?[|.ExtMethod|](0);
}
}",
@"using System.Linq;
using System.Collections;
using X;
using Y;
namespace X
{
public static class Ext
{
public static void ExtMethod(this int? a)
{
}
}
}
namespace Y
{
public static class Ext
{
public static void ExtMethod(this int? a, int v)
{
}
}
}
public class B
{
static void Main()
{
var b = new int?();
b?.ExtMethod(0);
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/562")]
public async Task TestAddUsingWithOtherExtensionsInScope3(TestHost testHost)
{
await TestAsync(
@"using System.Linq;
class C
{
int i = 0.[|All|]();
}
namespace X
{
static class E
{
public static int All(this int o) => 0;
}
}",
@"using System.Linq;
using X;
class C
{
int i = 0.All();
}
namespace X
{
static class E
{
public static int All(this int o) => 0;
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/562")]
public async Task TestAddUsingWithOtherExtensionsInScope4(TestHost testHost)
{
await TestAsync(
@"using System.Linq;
class C
{
static void Main(string[] args)
{
var a = new int?();
int? i = a?[|.All|]();
}
}
namespace X
{
static class E
{
public static int? All(this int? o) => 0;
}
}",
@"using System.Linq;
using X;
class C
{
static void Main(string[] args)
{
var a = new int?();
int? i = a?.All();
}
}
namespace X
{
static class E
{
public static int? All(this int? o) => 0;
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/3080")]
public async Task TestNestedNamespaceSimplified(TestHost testHost)
{
await TestAsync(
@"namespace Microsoft.MyApp
{
using Win32;
class Program
{
static void Main(string[] args)
{
[|SafeRegistryHandle|] h;
}
}
}",
@"namespace Microsoft.MyApp
{
using Microsoft.Win32.SafeHandles;
using Win32;
class Program
{
static void Main(string[] args)
{
SafeRegistryHandle h;
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/3080")]
public async Task TestNestedNamespaceSimplified2(TestHost testHost)
{
await TestAsync(
@"namespace Microsoft.MyApp
{
using Zin32;
class Program
{
static void Main(string[] args)
{
[|SafeRegistryHandle|] h;
}
}
}",
@"namespace Microsoft.MyApp
{
using Microsoft.Win32.SafeHandles;
using Zin32;
class Program
{
static void Main(string[] args)
{
SafeRegistryHandle h;
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/3080")]
public async Task TestNestedNamespaceSimplified3(TestHost testHost)
{
await TestAsync(
@"namespace Microsoft.MyApp
{
using System;
using Win32;
class Program
{
static void Main(string[] args)
{
[|SafeRegistryHandle|] h;
}
}
}",
@"namespace Microsoft.MyApp
{
using System;
using Microsoft.Win32.SafeHandles;
using Win32;
class Program
{
static void Main(string[] args)
{
SafeRegistryHandle h;
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/3080")]
public async Task TestNestedNamespaceSimplified4(TestHost testHost)
{
await TestAsync(
@"namespace Microsoft.MyApp
{
using System;
using Zin32;
class Program
{
static void Main(string[] args)
{
[|SafeRegistryHandle|] h;
}
}
}",
@"namespace Microsoft.MyApp
{
using System;
using Microsoft.Win32.SafeHandles;
using Zin32;
class Program
{
static void Main(string[] args)
{
SafeRegistryHandle h;
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/3080")]
public async Task TestNestedNamespaceSimplified5(TestHost testHost)
{
await TestAsync(
@"namespace Microsoft.MyApp
{
#if true
using Win32;
#else
using System;
#endif
class Program
{
static void Main(string[] args)
{
[|SafeRegistryHandle|] h;
}
}
}",
@"namespace Microsoft.MyApp
{
using Microsoft.Win32.SafeHandles;
#if true
using Win32;
#else
using System;
#endif
class Program
{
static void Main(string[] args)
{
SafeRegistryHandle h;
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/3080")]
public async Task TestNestedNamespaceSimplified6(TestHost testHost)
{
await TestAsync(
@"namespace Microsoft.MyApp
{
using System;
#if false
using Win32;
#endif
using Win32;
class Program
{
static void Main(string[] args)
{
[|SafeRegistryHandle|] h;
}
}
}",
@"namespace Microsoft.MyApp
{
using System;
using Microsoft.Win32.SafeHandles;
#if false
using Win32;
#endif
using Win32;
class Program
{
static void Main(string[] args)
{
SafeRegistryHandle h;
}
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddUsingOrdinalUppercase(TestHost testHost)
{
await TestAsync(
@"namespace A
{
class A
{
static void Main(string[] args)
{
var b = new [|B|]();
}
}
}
namespace lowercase
{
class b
{
}
}
namespace Uppercase
{
class B
{
}
}",
@"using Uppercase;
namespace A
{
class A
{
static void Main(string[] args)
{
var b = new B();
}
}
}
namespace lowercase
{
class b
{
}
}
namespace Uppercase
{
class B
{
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddUsingOrdinalLowercase(TestHost testHost)
{
await TestAsync(
@"namespace A
{
class A
{
static void Main(string[] args)
{
var a = new [|b|]();
}
}
}
namespace lowercase
{
class b
{
}
}
namespace Uppercase
{
class B
{
}
}",
@"using lowercase;
namespace A
{
class A
{
static void Main(string[] args)
{
var a = new b();
}
}
}
namespace lowercase
{
class b
{
}
}
namespace Uppercase
{
class B
{
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/7443")]
public async Task TestWithExistingIncompatibleExtension(TestHost testHost)
{
await TestAsync(
@"using N;
class C
{
int x()
{
System.Collections.Generic.IEnumerable<int> x = null;
return x.[|Any|]
}
}
namespace N
{
static class Extensions
{
public static void Any(this string s)
{
}
}
}",
@"using System.Linq;
using N;
class C
{
int x()
{
System.Collections.Generic.IEnumerable<int> x = null;
return x.Any
}
}
namespace N
{
static class Extensions
{
public static void Any(this string s)
{
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem(1744, @"https://github.com/dotnet/roslyn/issues/1744")]
public async Task TestIncompleteCatchBlockInLambda(TestHost testHost)
{
await TestAsync(
@"class A
{
System.Action a = () => {
try
{
}
catch ([|Exception|]",
@"using System;
class A
{
System.Action a = () => {
try
{
}
catch (Exception", testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1033612")]
public async Task TestAddInsideLambda(TestHost testHost)
{
var initialText =
@"using System;
static void Main(string[] args)
{
Func<int> f = () => { [|List<int>|]. }
}";
var expectedText =
@"using System;
using System.Collections.Generic;
static void Main(string[] args)
{
Func<int> f = () => { List<int>. }
}";
await TestAsync(initialText, expectedText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1033612")]
public async Task TestAddInsideLambda2(TestHost testHost)
{
var initialText =
@"using System;
static void Main(string[] args)
{
Func<int> f = () => { [|List<int>|] }
}";
var expectedText =
@"using System;
using System.Collections.Generic;
static void Main(string[] args)
{
Func<int> f = () => { List<int> }
}";
await TestAsync(initialText, expectedText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1033612")]
public async Task TestAddInsideLambda3(TestHost testHost)
{
var initialText =
@"using System;
static void Main(string[] args)
{
Func<int> f = () => {
var a = 3;
[|List<int>|].
return a;
};
}";
var expectedText =
@"using System;
using System.Collections.Generic;
static void Main(string[] args)
{
Func<int> f = () => {
var a = 3;
List<int>.
return a;
};
}";
await TestAsync(initialText, expectedText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1033612")]
public async Task TestAddInsideLambda4(TestHost testHost)
{
var initialText =
@"using System;
static void Main(string[] args)
{
Func<int> f = () => {
var a = 3;
[|List<int>|]
return a;
};
}";
var expectedText =
@"using System;
using System.Collections.Generic;
static void Main(string[] args)
{
Func<int> f = () => {
var a = 3;
List<int>
return a;
};
}";
await TestAsync(initialText, expectedText, testHost);
}
[Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/860648")]
[CombinatorialData]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/902014")]
public async Task TestIncompleteParenthesizedLambdaExpression(TestHost testHost)
{
await TestAsync(
@"using System;
class Test
{
void Goo()
{
Action a = () => {
[|IBindCtx|] };
string a;
}
}",
@"using System;
using System.Runtime.InteropServices.ComTypes;
class Test
{
void Goo()
{
Action a = () => {
IBindCtx };
string a;
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/7461")]
public async Task TestExtensionWithIncompatibleInstance(TestHost testHost)
{
await TestAsync(
@"using System.IO;
namespace Namespace1
{
static class StreamExtensions
{
public static void Write(this Stream stream, byte[] bytes)
{
}
}
}
namespace Namespace2
{
class Goo
{
void Bar()
{
Stream stream = null;
stream.[|Write|](new byte[] { 1, 2, 3 });
}
}
}",
@"using System.IO;
using Namespace1;
namespace Namespace1
{
static class StreamExtensions
{
public static void Write(this Stream stream, byte[] bytes)
{
}
}
}
namespace Namespace2
{
class Goo
{
void Bar()
{
Stream stream = null;
stream.Write(new byte[] { 1, 2, 3 });
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/5499")]
public async Task TestFormattingForNamespaceUsings(TestHost testHost)
{
await TestAsync(
@"namespace N
{
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class Program
{
void Main()
{
[|Task<int>|]
}
}
}",
@"namespace N
{
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
void Main()
{
Task<int>
}
}
}", testHost);
}
[Fact]
public async Task TestGenericAmbiguityInSameNamespace()
{
await TestMissingInRegularAndScriptAsync(
@"namespace NS
{
class C<T> where T : [|C|].N
{
public class N
{
}
}
}");
}
[Fact]
public async Task TestNotOnVar1()
{
await TestMissingInRegularAndScriptAsync(
@"namespace N
{
class var { }
}
class C
{
void M()
{
[|var|]
}
}
");
}
[Fact]
public async Task TestNotOnVar2()
{
await TestMissingInRegularAndScriptAsync(
@"namespace N
{
class Bar { }
}
class C
{
void M()
{
[|var|]
}
}
");
}
[Theory, CombinatorialData]
[WorkItem("https://devdiv.visualstudio.com/DevDiv/_workitems?id=226826")]
public async Task TestAddUsingWithLeadingDocCommentInFrontOfUsing1(TestHost testHost)
{
await TestAsync(
@"
/// Copyright 2016 - MyCompany
/// All Rights Reserved
using System;
class C : [|IEnumerable|]<int>
{
}
",
@"
/// Copyright 2016 - MyCompany
/// All Rights Reserved
using System;
using System.Collections.Generic;
class C : IEnumerable<int>
{
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://devdiv.visualstudio.com/DevDiv/_workitems?id=226826")]
public async Task TestAddUsingWithLeadingDocCommentInFrontOfUsing2(TestHost testHost)
{
await TestAsync(
@"
/// Copyright 2016 - MyCompany
/// All Rights Reserved
using System.Collections;
class C
{
[|DateTime|] d;
}
",
@"
/// Copyright 2016 - MyCompany
/// All Rights Reserved
using System;
using System.Collections;
class C
{
DateTime d;
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://devdiv.visualstudio.com/DevDiv/_workitems?id=226826")]
public async Task TestAddUsingWithLeadingDocCommentInFrontOfClass1(TestHost testHost)
{
await TestAsync(
@"
/// Copyright 2016 - MyCompany
/// All Rights Reserved
class C
{
[|DateTime|] d;
}
",
@"
using System;
/// Copyright 2016 - MyCompany
/// All Rights Reserved
class C
{
DateTime d;
}
", testHost);
}
[Theory, CombinatorialData]
public async Task TestPlaceUsingWithUsings_NotWithAliases(TestHost testHost)
{
await TestAsync(
@"
using System;
namespace N
{
using C = System.Collections;
class Class
{
[|List<int>|] Method()
{
Goo();
}
}
}",
@"
using System;
using System.Collections.Generic;
namespace N
{
using C = System.Collections;
class Class
{
List<int> Method()
{
Goo();
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/15025")]
public async Task TestPreferSystemNamespaceFirst(TestHost testHost)
{
await TestAsync(
@"
namespace Microsoft
{
public class SomeClass { }
}
namespace System
{
public class SomeClass { }
}
namespace N
{
class Class
{
[|SomeClass|] c;
}
}",
@"
using System;
namespace Microsoft
{
public class SomeClass { }
}
namespace System
{
public class SomeClass { }
}
namespace N
{
class Class
{
SomeClass c;
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/15025")]
public async Task TestPreferSystemNamespaceFirst2(TestHost testHost)
{
await TestAsync(
@"
namespace Microsoft
{
public class SomeClass { }
}
namespace System
{
public class SomeClass { }
}
namespace N
{
class Class
{
[|SomeClass|] c;
}
}",
@"
using Microsoft;
namespace Microsoft
{
public class SomeClass { }
}
namespace System
{
public class SomeClass { }
}
namespace N
{
class Class
{
SomeClass c;
}
}", testHost, index: 1);
}
[Fact, WorkItem("https://github.com/dotnet/roslyn/issues/18275")]
public async Task TestContextualKeyword1()
{
await TestMissingInRegularAndScriptAsync(
@"
namespace N
{
class nameof
{
}
}
class C
{
void M()
{
[|nameof|]
}
}");
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/19218")]
public async Task TestChangeCaseWithUsingsInNestedNamespace(TestHost testHost)
{
await TestAsync(
@"namespace VS
{
interface IVsStatusbar
{
}
}
namespace Outer
{
using System;
class C
{
void M()
{
// Note: IVsStatusBar is cased incorrectly.
[|IVsStatusBar|] b;
}
}
}
",
@"namespace VS
{
interface IVsStatusbar
{
}
}
namespace Outer
{
using System;
using VS;
class C
{
void M()
{
// Note: IVsStatusBar is cased incorrectly.
IVsStatusbar b;
}
}
}
", testHost);
}
[Fact, WorkItem("https://github.com/dotnet/roslyn/issues/19575")]
public async Task TestNoNonGenericsWithGenericCodeParsedAsExpression()
{
var code = @"
class C
{
private void GetEvaluationRuleNames()
{
[|IEnumerable|] < Int32 >
return ImmutableArray.CreateRange();
}
}";
await TestActionCountAsync(code, count: 1);
await TestInRegularAndScriptAsync(
code,
@"
using System.Collections.Generic;
class C
{
private void GetEvaluationRuleNames()
{
IEnumerable < Int32 >
return ImmutableArray.CreateRange();
}
}");
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/19796")]
public async Task TestWhenInRome1(TestHost testHost)
{
// System is set to be sorted first, but the actual file shows it at the end.
// Keep things sorted, but respect that 'System' is at the end.
await TestAsync(
@"
using B;
using System;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
@"
using A;
using B;
using System;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/19796")]
public async Task TestWhenInRome2(TestHost testHost)
{
// System is set to not be sorted first, but the actual file shows it sorted first.
// Keep things sorted, but respect that 'System' is at the beginning.
await TestAsync(
@"
using System;
using B;
class Class
{
void Method()
{
[|Goo|].Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}",
@"
using System;
using A;
using B;
class Class
{
void Method()
{
Goo.Bar();
}
}
namespace A
{
class Goo
{
public static void Bar()
{
}
}
}", testHost);
}
[Fact]
public async Task TestExactMatchNoGlyph()
{
await TestSmartTagGlyphTagsAsync(
@"namespace VS
{
interface Other
{
}
}
class C
{
void M()
{
[|Other|] b;
}
}
", ImmutableArray<string>.Empty);
}
[Fact]
public async Task TestFuzzyMatchGlyph()
{
await TestSmartTagGlyphTagsAsync(
@"namespace VS
{
interface Other
{
}
}
class C
{
void M()
{
[|Otter|] b;
}
}
", WellKnownTagArrays.Namespace);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/29313")]
public async Task TestGetAwaiterExtensionMethod1(TestHost testHost)
{
await TestAsync(
@"
namespace A
{
using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
class C
{
async Task M() => await [|Goo|];
C Goo { get; set; }
}
}
namespace B
{
using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using A;
static class Extensions
{
public static Awaiter GetAwaiter(this C scheduler) => null;
public class Awaiter : INotifyCompletion
{
public object GetResult() => null;
public void OnCompleted(Action continuation) { }
public bool IsCompleted => true;
}
}
}",
@"
namespace A
{
using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using B;
class C
{
async Task M() => await Goo;
C Goo { get; set; }
}
}
namespace B
{
using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using A;
static class Extensions
{
public static Awaiter GetAwaiter(this C scheduler) => null;
public class Awaiter : INotifyCompletion
{
public object GetResult() => null;
public void OnCompleted(Action continuation) { }
public bool IsCompleted => true;
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/29313")]
public async Task TestGetAwaiterExtensionMethod2(TestHost testHost)
{
await TestAsync(
@"
namespace A
{
using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
class C
{
async Task M() => await [|GetC|]();
C GetC() => null;
}
}
namespace B
{
using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using A;
static class Extensions
{
public static Awaiter GetAwaiter(this C scheduler) => null;
public class Awaiter : INotifyCompletion
{
public object GetResult() => null;
public void OnCompleted(Action continuation) { }
public bool IsCompleted => true;
}
}
}",
@"
namespace A
{
using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using B;
class C
{
async Task M() => await GetC();
C GetC() => null;
}
}
namespace B
{
using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using A;
static class Extensions
{
public static Awaiter GetAwaiter(this C scheduler) => null;
public class Awaiter : INotifyCompletion
{
public object GetResult() => null;
public void OnCompleted(Action continuation) { }
public bool IsCompleted => true;
}
}
}", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/745490")]
public async Task TestAddUsingForAwaitableReturningExtensionMethod(TestHost testHost)
{
await TestAsync(
@"
namespace A
{
using System;
using System.Threading.Tasks;
class C
{
C Instance { get; }
async Task M() => await Instance.[|Foo|]();
}
}
namespace B
{
using System;
using System.Threading.Tasks;
using A;
static class Extensions
{
public static Task Foo(this C instance) => null;
}
}",
@"
namespace A
{
using System;
using System.Threading.Tasks;
using B;
class C
{
C Instance { get; }
async Task M() => await Instance.Foo();
}
}
namespace B
{
using System;
using System.Threading.Tasks;
using A;
static class Extensions
{
public static Task Foo(this C instance) => null;
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddUsingForExtensionGetEnumeratorReturningIEnumerator(TestHost testHost)
{
await TestAsync(
@"
namespace A
{
class C
{
C Instance { get; }
void M() { foreach (var i in [|Instance|]); }
}
}
namespace B
{
using A;
using System.Collections.Generic;
static class Extensions
{
public static IEnumerator<int> GetEnumerator(this C instance) => null;
}
}",
@"
using B;
namespace A
{
class C
{
C Instance { get; }
void M() { foreach (var i in Instance); }
}
}
namespace B
{
using A;
using System.Collections.Generic;
static class Extensions
{
public static IEnumerator<int> GetEnumerator(this C instance) => null;
}
}", testHost);
}
[Theory, CombinatorialData]
public async Task TestAddUsingForExtensionGetEnumeratorReturningPatternEnumerator(TestHost testHost)
{
await TestAsync(
@"
namespace A
{
class C
{
C Instance { get; }
void M() { foreach (var i in [|Instance|]); }
}
}
namespace B
{
using A;
static class Extensions
{
public static Enumerator GetEnumerator(this C instance) => null;
}
public class Enumerator
{
public int Current { get; }
public bool MoveNext();
}
}",
@"
using B;
namespace A
{
class C
{
C Instance { get; }
void M() { foreach (var i in Instance); }
}
}
namespace B
{
using A;
static class Extensions
{
public static Enumerator GetEnumerator(this C instance) => null;
}
public class Enumerator
{
public int Current { get; }
public bool MoveNext();
}
}", testHost);
}
[Fact]
public async Task TestMissingForExtensionInvalidGetEnumerator()
{
await TestMissingAsync(
@"
namespace A
{
class C
{
C Instance { get; }
void M() { foreach (var i in [|Instance|]); }
}
}
namespace B
{
using A;
static class Extensions
{
public static bool GetEnumerator(this C instance) => null;
}
}");
}
[Theory, CombinatorialData]
public async Task TestAddUsingForExtensionGetEnumeratorReturningPatternEnumeratorWrongAsync(TestHost testHost)
{
await TestAsync(
@"
namespace A
{
class C
{
C Instance { get; };
void M() { foreach (var i in [|Instance|]); }
public Enumerator GetAsyncEnumerator(System.Threading.CancellationToken token = default)
{
return new Enumerator();
}
public sealed class Enumerator
{
public async System.Threading.Tasks.Task<bool> MoveNextAsync() => throw null;
public int Current => throw null;
}
}
}
namespace B
{
using A;
static class Extensions
{
public static Enumerator GetEnumerator(this C instance) => null;
}
public class Enumerator
{
public int Current { get; }
public bool MoveNext();
}
}",
@"
using B;
namespace A
{
class C
{
C Instance { get; };
void M() { foreach (var i in Instance); }
public Enumerator GetAsyncEnumerator(System.Threading.CancellationToken token = default)
{
return new Enumerator();
}
public sealed class Enumerator
{
public async System.Threading.Tasks.Task<bool> MoveNextAsync() => throw null;
public int Current => throw null;
}
}
}
namespace B
{
using A;
static class Extensions
{
public static Enumerator GetEnumerator(this C instance) => null;
}
public class Enumerator
{
public int Current { get; }
public bool MoveNext();
}
}", testHost);
}
[Fact]
public async Task TestMissingForExtensionGetAsyncEnumeratorOnForeach()
{
await TestMissingAsync(
@"
namespace A
{
class C
{
C Instance { get; }
void M() { foreach (var i in [|Instance|]); }
}
}
namespace B
{
using A;
using System.Collections.Generic;
static class Extensions
{
public static IAsyncEnumerator<int> GetAsyncEnumerator(this C instance) => null;
}
}" + IAsyncEnumerable);
}
[Theory, CombinatorialData]
public async Task TestAddUsingForExtensionGetAsyncEnumeratorReturningIAsyncEnumerator(TestHost testHost)
{
await TestAsync(
@"
using System.Threading.Tasks;
namespace A
{
class C
{
C Instance { get; }
async Task M() { await foreach (var i in [|Instance|]); }
}
}
namespace B
{
using A;
using System.Collections.Generic;
static class Extensions
{
public static IAsyncEnumerator<int> GetAsyncEnumerator(this C instance) => null;
}
}" + IAsyncEnumerable,
@"
using System.Threading.Tasks;
using B;
namespace A
{
class C
{
C Instance { get; }
async Task M() { await foreach (var i in Instance); }
}
}
namespace B
{
using A;
using System.Collections.Generic;
static class Extensions
{
public static IAsyncEnumerator<int> GetAsyncEnumerator(this C instance) => null;
}
}" + IAsyncEnumerable, testHost);
}
[Theory, CombinatorialData]
public async Task TestAddUsingForExtensionGetAsyncEnumeratorReturningPatternEnumerator(TestHost testHost)
{
await TestAsync(
@"
using System.Threading.Tasks;
namespace A
{
class C
{
C Instance { get; }
async Task M() { await foreach (var i in [|Instance|]); }
}
}
namespace B
{
using A;
static class Extensions
{
public static Enumerator GetAsyncEnumerator(this C instance) => null;
}
public class Enumerator
{
public int Current { get; }
public Task<bool> MoveNextAsync();
}
}",
@"
using System.Threading.Tasks;
using B;
namespace A
{
class C
{
C Instance { get; }
async Task M() { await foreach (var i in Instance); }
}
}
namespace B
{
using A;
static class Extensions
{
public static Enumerator GetAsyncEnumerator(this C instance) => null;
}
public class Enumerator
{
public int Current { get; }
public Task<bool> MoveNextAsync();
}
}", testHost);
}
[Fact]
public async Task TestMissingForExtensionInvalidGetAsyncEnumerator()
{
await TestMissingAsync(
@"
using System.Threading.Tasks;
namespace A
{
class C
{
C Instance { get; }
async Task M() { await foreach (var i in [|Instance|]); }
}
}
namespace B
{
using A;
static class Extensions
{
public static bool GetAsyncEnumerator(this C instance) => null;
}
}");
}
[Theory, CombinatorialData]
public async Task TestAddUsingForExtensionGetAsyncEnumeratorReturningPatternEnumeratorWrongAsync(TestHost testHost)
{
await TestAsync(
@"
using System.Threading.Tasks;
namespace A
{
class C
{
C Instance { get; }
Task M() { await foreach (var i in [|Instance|]); }
public Enumerator GetEnumerator()
{
return new Enumerator();
}
public class Enumerator
{
public int Current { get; }
public bool MoveNext();
}
}
}
namespace B
{
using A;
static class Extensions
{
public static Enumerator GetAsyncEnumerator(this C instance) => null;
}
public sealed class Enumerator
{
public async System.Threading.Tasks.Task<bool> MoveNextAsync() => throw null;
public int Current => throw null;
}
}",
@"
using System.Threading.Tasks;
using B;
namespace A
{
class C
{
C Instance { get; }
Task M() { await foreach (var i in Instance); }
public Enumerator GetEnumerator()
{
return new Enumerator();
}
public class Enumerator
{
public int Current { get; }
public bool MoveNext();
}
}
}
namespace B
{
using A;
static class Extensions
{
public static Enumerator GetAsyncEnumerator(this C instance) => null;
}
public sealed class Enumerator
{
public async System.Threading.Tasks.Task<bool> MoveNextAsync() => throw null;
public int Current => throw null;
}
}", testHost);
}
[Fact]
public async Task TestMissingForExtensionGetEnumeratorOnAsyncForeach()
{
await TestMissingAsync(
@"
using System.Threading.Tasks;
namespace A
{
class C
{
C Instance { get; }
Task M() { await foreach (var i in [|Instance|]); }
}
}
namespace B
{
using A;
using System.Collections.Generic;
static class Extensions
{
public static IEnumerator<int> GetEnumerator(this C instance) => null;
}
}");
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithStaticUsingInNamespace_WhenNoExistingUsings(TestHost testHost)
{
await TestAsync(
@"
namespace N
{
using static System.Math;
class C
{
public [|List<int>|] F;
}
}
",
@"
namespace N
{
using System.Collections.Generic;
using static System.Math;
class C
{
public List<int> F;
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithStaticUsingInInnerNestedNamespace_WhenNoExistingUsings(TestHost testHost)
{
await TestAsync(
@"
namespace N
{
namespace M
{
using static System.Math;
class C
{
public [|List<int>|] F;
}
}
}
",
@"
namespace N
{
namespace M
{
using System.Collections.Generic;
using static System.Math;
class C
{
public List<int> F;
}
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithStaticUsingInOuterNestedNamespace_WhenNoExistingUsings(TestHost testHost)
{
await TestAsync(
@"
namespace N
{
using static System.Math;
namespace M
{
class C
{
public [|List<int>|] F;
}
}
}
",
@"
namespace N
{
using System.Collections.Generic;
using static System.Math;
namespace M
{
class C
{
public List<int> F;
}
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithExistingUsingInCompilationUnit_WhenStaticUsingInNamespace(TestHost testHost)
{
await TestAsync(
@"
using System;
namespace N
{
using static System.Math;
class C
{
public [|List<int>|] F;
}
}
",
@"
using System;
using System.Collections.Generic;
namespace N
{
using static System.Math;
class C
{
public List<int> F;
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithExistingUsing_WhenStaticUsingInInnerNestedNamespace(TestHost testHost)
{
await TestAsync(
@"
namespace N
{
using System;
namespace M
{
using static System.Math;
class C
{
public [|List<int>|] F;
}
}
}
",
@"
namespace N
{
using System;
using System.Collections.Generic;
namespace M
{
using static System.Math;
class C
{
public List<int> F;
}
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithExistingUsing_WhenStaticUsingInOuterNestedNamespace(TestHost testHost)
{
await TestAsync(
@"
namespace N
{
using static System.Math;
namespace M
{
using System;
class C
{
public [|List<int>|] F;
}
}
}
",
@"
namespace N
{
using static System.Math;
namespace M
{
using System;
using System.Collections.Generic;
class C
{
public List<int> F;
}
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithUsingAliasInNamespace_WhenNoExistingUsing(TestHost testHost)
{
await TestAsync(
@"
namespace N
{
using SAction = System.Action;
class C
{
public [|List<int>|] F;
}
}
",
@"
namespace N
{
using System.Collections.Generic;
using SAction = System.Action;
class C
{
public List<int> F;
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithUsingAliasInInnerNestedNamespace_WhenNoExistingUsing(TestHost testHost)
{
await TestAsync(
@"
namespace N
{
namespace M
{
using SAction = System.Action;
class C
{
public [|List<int>|] F;
}
}
}
",
@"
namespace N
{
namespace M
{
using System.Collections.Generic;
using SAction = System.Action;
class C
{
public List<int> F;
}
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithUsingAliasInOuterNestedNamespace_WhenNoExistingUsing(TestHost testHost)
{
await TestAsync(
@"
namespace N
{
using SAction = System.Action;
namespace M
{
class C
{
public [|List<int>|] F;
}
}
}
",
@"
namespace N
{
using System.Collections.Generic;
using SAction = System.Action;
namespace M
{
class C
{
public List<int> F;
}
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithExistingUsingInCompilationUnit_WhenUsingAliasInNamespace(TestHost testHost)
{
await TestAsync(
@"
using System;
namespace N
{
using SAction = System.Action;
class C
{
public [|List<int>|] F;
}
}
",
@"
using System;
using System.Collections.Generic;
namespace N
{
using SAction = System.Action;
class C
{
public List<int> F;
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithExistingUsing_WhenUsingAliasInInnerNestedNamespace(TestHost testHost)
{
await TestAsync(
@"
namespace N
{
using System;
namespace M
{
using SAction = System.Action;
class C
{
public [|List<int>|] F;
}
}
}
",
@"
namespace N
{
using System;
using System.Collections.Generic;
namespace M
{
using SAction = System.Action;
class C
{
public [|List<int>|] F;
}
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/30734")]
public async Task UsingPlacedWithExistingUsing_WhenUsingAliasInOuterNestedNamespace(TestHost testHost)
{
await TestAsync(
@"
namespace N
{
using SAction = System.Action;
namespace M
{
using System;
class C
{
public [|List<int>|] F;
}
}
}
",
@"
namespace N
{
using SAction = System.Action;
namespace M
{
using System;
using System.Collections.Generic;
class C
{
public [|List<int>|] F;
}
}
}
", testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/25003")]
public async Task KeepUsingsGrouped1(TestHost testHost)
{
await TestAsync(
@"
using System;
class Program
{
static void Main(string[] args)
{
[|Goo|]
}
}
namespace Microsoft
{
public class Goo
{
}
}",
@"
using System;
using Microsoft;
class Program
{
static void Main(string[] args)
{
Goo
}
}
namespace Microsoft
{
public class Goo
{
}
}", testHost);
}
[Fact, WorkItem(1239, @"https://github.com/dotnet/roslyn/issues/1239")]
public async Task TestIncompleteLambda1()
{
await TestInRegularAndScriptAsync(
@"using System.Linq;
class C
{
C()
{
"""".Select(() => {
new [|Byte|]",
@"using System;
using System.Linq;
class C
{
C()
{
"""".Select(() => {
new Byte");
}
[Fact, WorkItem(1239, @"https://github.com/dotnet/roslyn/issues/1239")]
public async Task TestIncompleteLambda2()
{
await TestInRegularAndScriptAsync(
@"using System.Linq;
class C
{
C()
{
"""".Select(() => {
new [|Byte|]() }",
@"using System;
using System.Linq;
class C
{
C()
{
"""".Select(() => {
new Byte() }");
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/902014")]
[WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/860648")]
public async Task TestIncompleteSimpleLambdaExpression()
{
await TestInRegularAndScriptAsync(
@"using System.Linq;
class Program
{
static void Main(string[] args)
{
args[0].Any(x => [|IBindCtx|]
string a;
}
}",
@"using System.Linq;
using System.Runtime.InteropServices.ComTypes;
class Program
{
static void Main(string[] args)
{
args[0].Any(x => IBindCtx
string a;
}
}");
}
[Theory, CombinatorialData]
[WorkItem("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1266354")]
public async Task TestAddUsingsEditorBrowsableNeverSameProject(TestHost testHost)
{
const string InitialWorkspace = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""lib"" CommonReferences=""true"">
<Document FilePath=""lib.cs"">
using System.ComponentModel;
namespace ProjectLib
{
[EditorBrowsable(EditorBrowsableState.Never)]
public class Project
{
}
}
</Document>
<Document FilePath=""Program.cs"">
class Program
{
static void Main(string[] args)
{
Project p = new [|Project()|];
}
}
</Document>
</Project>
</Workspace>";
const string ExpectedDocumentText = @"
using ProjectLib;
class Program
{
static void Main(string[] args)
{
Project p = new [|Project()|];
}
}
";
await TestAsync(InitialWorkspace, ExpectedDocumentText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1266354")]
public async Task TestAddUsingsEditorBrowsableNeverDifferentProject(TestHost testHost)
{
const string InitialWorkspace = @"
<Workspace>
<Project Language=""Visual Basic"" AssemblyName=""lib"" CommonReferences=""true"">
<Document FilePath=""lib.vb"">
imports System.ComponentModel
namespace ProjectLib
<EditorBrowsable(EditorBrowsableState.Never)>
public class Project
end class
end namespace
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Console"" CommonReferences=""true"">
<ProjectReference>lib</ProjectReference>
<Document FilePath=""Program.cs"">
class Program
{
static void Main(string[] args)
{
[|Project|] p = new Project();
}
}
</Document>
</Project>
</Workspace>";
await TestMissingAsync(InitialWorkspace, new TestParameters(testHost: testHost));
}
[Theory, CombinatorialData]
[WorkItem("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1266354")]
public async Task TestAddUsingsEditorBrowsableAdvancedDifferentProjectOptionOn(TestHost testHost)
{
const string InitialWorkspace = @"
<Workspace>
<Project Language=""Visual Basic"" AssemblyName=""lib"" CommonReferences=""true"">
<Document FilePath=""lib.vb"">
imports System.ComponentModel
namespace ProjectLib
<EditorBrowsable(EditorBrowsableState.Advanced)>
public class Project
end class
end namespace
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Console"" CommonReferences=""true"">
<ProjectReference>lib</ProjectReference>
<Document FilePath=""Program.cs"">
class Program
{
static void Main(string[] args)
{
[|Project|] p = new Project();
}
}
</Document>
</Project>
</Workspace>";
const string ExpectedDocumentText = @"
using ProjectLib;
class Program
{
static void Main(string[] args)
{
Project p = new [|Project()|];
}
}
";
await TestAsync(InitialWorkspace, ExpectedDocumentText, testHost);
}
[Theory, CombinatorialData]
[WorkItem("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1266354")]
public async Task TestAddUsingsEditorBrowsableAdvancedDifferentProjectOptionOff(TestHost testHost)
{
var initialWorkspace = @"
<Workspace>
<Project Language=""Visual Basic"" AssemblyName=""lib"" CommonReferences=""true"">
<Document FilePath=""lib.vb"">
imports System.ComponentModel
namespace ProjectLib
<EditorBrowsable(EditorBrowsableState.Advanced)>
public class Project
end class
end namespace
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Console"" CommonReferences=""true"">
<ProjectReference>lib</ProjectReference>
<Document FilePath=""Program.cs"">
class Program
{
static void Main(string[] args)
{
[|Project|] p = new Project();
}
}
</Document>
</Project>
</Workspace>";
await TestMissingAsync(initialWorkspace, new TestParameters(
options: Option(MemberDisplayOptionsStorage.HideAdvancedMembers, true),
testHost: testHost));
}
/// <summary>
/// Note that this test verifies the current end of line sequence in using directives is preserved regardless of
/// whether this matches the end_of_line value in .editorconfig or not.
/// </summary>
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/62976")]
public async Task TestAddUsingPreservesNewlines1(TestHost testHost, [CombinatorialValues("\n", "\r\n")] string sourceNewLine, [CombinatorialValues("\n", "\r\n")] string configuredNewLine)
{
await TestInRegularAndScript1Async(
"""
namespace ANamespace
{
public class TheAType { }
}
namespace N
{
class Class
{
[|TheAType|] a;
}
}
""".ReplaceLineEndings(sourceNewLine),
"""
using ANamespace;
namespace ANamespace
{
public class TheAType { }
}
namespace N
{
class Class
{
TheAType a;
}
}
""".ReplaceLineEndings(sourceNewLine),
index: 0,
parameters: new TestParameters(options: Option(FormattingOptions2.NewLine, configuredNewLine), testHost: testHost));
}
/// <summary>
/// Note that this test verifies the current end of line sequence in using directives is preserved regardless of
/// whether this matches the end_of_line value in .editorconfig or not.
/// </summary>
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/62976")]
public async Task TestAddUsingPreservesNewlines2(TestHost testHost, [CombinatorialValues("\n", "\r\n")] string sourceNewLine, [CombinatorialValues("\n", "\r\n")] string configuredNewLine)
{
await TestInRegularAndScript1Async(
"""
using BNamespace;
namespace ANamespace
{
public class TheAType { }
}
namespace BNamespace
{
public class TheBType { }
}
namespace N
{
class Class
{
[|TheAType|] a;
TheBType b;
}
}
""".ReplaceLineEndings(sourceNewLine),
"""
using ANamespace;
using BNamespace;
namespace ANamespace
{
public class TheAType { }
}
namespace BNamespace
{
public class TheBType { }
}
namespace N
{
class Class
{
TheAType a;
TheBType b;
}
}
""".ReplaceLineEndings(sourceNewLine),
index: 0,
parameters: new TestParameters(options: Option(FormattingOptions2.NewLine, configuredNewLine), testHost: testHost));
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/62976")]
public async Task TestAddUsingPreservesNewlines3(TestHost testHost, [CombinatorialValues("\n", "\r\n")] string sourceNewLine, [CombinatorialValues("\n", "\r\n")] string configuredNewLine)
{
await TestInRegularAndScript1Async(
"""
using ANamespace;
namespace ANamespace
{
public class TheAType { }
}
namespace BNamespace
{
public class TheBType { }
}
namespace N
{
class Class
{
TheAType a;
[|TheBType|] b;
}
}
""".ReplaceLineEndings(sourceNewLine),
"""
using ANamespace;
using BNamespace;
namespace ANamespace
{
public class TheAType { }
}
namespace BNamespace
{
public class TheBType { }
}
namespace N
{
class Class
{
TheAType a;
TheBType b;
}
}
""".ReplaceLineEndings(sourceNewLine),
index: 0,
parameters: new TestParameters(options: Option(FormattingOptions2.NewLine, configuredNewLine), testHost: testHost));
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/24642")]
public async Task TestAddUsingWithMalformedGeneric(TestHost testHost)
{
await TestInRegularAndScript1Async(
"""
class Class
{
[|List<Y|] x;
}
""",
"""
using System.Collections.Generic;
class Class
{
List<Y x;
}
""",
index: 0,
parameters: new TestParameters(testHost: testHost));
}
[Theory, CombinatorialData]
public async Task TestOutsideOfMethodWithMalformedGenericParameters(TestHost testHost)
{
await TestInRegularAndScript1Async(
"""
using System;
class Program
{
Func<[|FlowControl|] x
}
""",
"""
using System;
using System.Reflection.Emit;
class Program
{
Func<FlowControl x
}
""",
index: 0,
parameters: new TestParameters(testHost: testHost));
}
}
|