|
// 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;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Completion.Providers;
using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Completion.CompletionProviders;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Recommendations
{
/// <summary>
/// The <see cref="AwaitCompletionProvider"/> adds async modifier if the return type is Task or ValueTask.
/// The tests here are only checking whether the completion item is provided or not.
/// Tests for checking adding async modifier are in:
/// src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_AwaitCompletion.vb
/// </summary>
[Trait(Traits.Feature, Traits.Features.Completion)]
public class AwaitCompletionProviderTests : AbstractCSharpCompletionProviderTests
{
internal override Type GetCompletionProviderType() => typeof(AwaitCompletionProvider);
private const string CompletionDisplayTextAwait = "await";
private const string CompletionDisplayTextAwaitAndConfigureAwait = "awaitf";
private async Task VerifyAbsenceAsync(string code)
{
await VerifyItemIsAbsentAsync(code, CompletionDisplayTextAwait);
await VerifyItemIsAbsentAsync(code, CompletionDisplayTextAwaitAndConfigureAwait);
}
private async Task VerifyAbsenceAsync(string code, LanguageVersion languageVersion = LanguageVersion.Default)
{
await VerifyItemIsAbsentAsync(GetMarkup(code, languageVersion), CompletionDisplayTextAwait);
await VerifyItemIsAbsentAsync(GetMarkup(code, languageVersion), CompletionDisplayTextAwaitAndConfigureAwait);
}
private async Task VerifyKeywordAsync(string code, LanguageVersion languageVersion = LanguageVersion.Default, string? inlineDescription = null, bool dotAwait = false, bool dotAwaitf = false)
{
var expectedDescription = dotAwait
? GetDescription(CompletionDisplayTextAwait, FeaturesResources.Await_the_preceding_expression)
: GetDescription(CompletionDisplayTextAwait, FeaturesResources.Asynchronously_waits_for_the_task_to_finish);
await VerifyItemExistsAsync(GetMarkup(code, languageVersion), CompletionDisplayTextAwait, glyph: (int)Glyph.Keyword, expectedDescriptionOrNull: expectedDescription, inlineDescription: inlineDescription);
if (dotAwaitf)
{
expectedDescription = string.Format(FeaturesResources.Await_the_preceding_expression_and_add_ConfigureAwait_0, "false");
await VerifyItemExistsAsync(GetMarkup(code, languageVersion), CompletionDisplayTextAwaitAndConfigureAwait, glyph: (int)Glyph.Keyword, expectedDescriptionOrNull: expectedDescription, inlineDescription: inlineDescription);
}
else
{
await VerifyItemIsAbsentAsync(GetMarkup(code, languageVersion), CompletionDisplayTextAwaitAndConfigureAwait);
}
static string GetDescription(string keyword, string tooltip)
=> $"{string.Format(FeaturesResources._0_Keyword, keyword)}\r\n{tooltip}";
}
[Fact]
public async Task TestNotInTypeContext()
{
await VerifyAbsenceAsync(@"
class Program
{
$$
}");
}
[Fact]
public async Task TestStatementInMethod()
{
await VerifyKeywordAsync(@"
class C
{
void F()
{
$$ }
}", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestStatementInMethod_Async()
{
await VerifyKeywordAsync(@"
class C
{
async Task F()
{
$$ }
}", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestStatementInMethod_TopLevel()
{
await VerifyKeywordAsync("$$", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestExpressionInAsyncMethod()
{
await VerifyKeywordAsync(@"
class C
{
async Task F()
{
var z = $$ }
}
", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestExpressionInNonAsyncMethodWithTaskReturn()
{
await VerifyKeywordAsync(@"
class C
{
Task F()
{
var z = $$ }
}
", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestExpressionInAsyncMethod_TopLevel()
{
await VerifyKeywordAsync("var z = $$", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestUsingStatement()
{
await VerifyAbsenceAsync(@"
class C
{
async Task F()
{
using $$ }
}", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestUsingStatement_TopLevel()
{
await VerifyAbsenceAsync("using $$", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestUsingDirective()
=> await VerifyAbsenceAsync("using $$");
[Fact]
public async Task TestGlobalUsingDirective()
=> await VerifyAbsenceAsync("global using $$");
[Fact]
public async Task TestForeachStatement()
{
await VerifyAbsenceAsync(@"
class C
{
async Task F()
{
foreach $$ }
}", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestForeachStatement_TopLevel()
{
await VerifyAbsenceAsync("foreach $$", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestNotInQuery()
{
await VerifyAbsenceAsync(@"
class C
{
async Task F()
{
var z = from a in ""char""
select $$ }
}
", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestNotInQuery_TopLevel()
{
await VerifyAbsenceAsync(
@"var z = from a in ""char""
select $$", LanguageVersion.CSharp9);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/907052")]
public async Task TestInFinally()
{
await VerifyKeywordAsync(@"
class C
{
async Task F()
{
try { }
finally { $$ } }
}", LanguageVersion.CSharp9);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/907052")]
public async Task TestInFinally_TopLevel()
{
await VerifyKeywordAsync(
@"try { }
finally { $$ }", LanguageVersion.CSharp9);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/907052")]
public async Task TestInCatch()
{
await VerifyKeywordAsync(@"
class C
{
async Task F()
{
try { }
catch { $$ } }
}", LanguageVersion.CSharp9);
}
[Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/907052")]
public async Task TestInCatch_TopLevel()
{
await VerifyKeywordAsync(
@"try { }
catch { $$ }", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestNotInLock()
{
await VerifyAbsenceAsync(@"
class C
{
async Task F()
{
lock(this) { $$ } }
}", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestNotInLock_TopLevel()
{
await VerifyAbsenceAsync("lock (this) { $$ }", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestInAsyncLambdaInCatch()
{
await VerifyKeywordAsync(@"
class C
{
async Task F()
{
try { }
catch { var z = async () => $$ } }
}", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestInAsyncLambdaInCatch_TopLevel()
{
await VerifyKeywordAsync(
@"try { }
catch { var z = async () => $$ }", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestAwaitInLock()
{
await VerifyKeywordAsync(@"
class C
{
async Task F()
{
lock($$ }
}", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestAwaitInLock_TopLevel()
{
await VerifyKeywordAsync("lock($$", LanguageVersion.CSharp9);
}
[Fact]
public async Task TestDotAwaitSuggestAfterDotOnTask()
{
await VerifyKeywordAsync(@"
using System.Threading.Tasks;
class C
{
async Task F(Task someTask)
{
someTask.$$
}
}
", dotAwait: true, dotAwaitf: true);
}
[Fact]
public async Task TestDotAwaitSuggestAfterDotOnTaskOfT()
{
await VerifyKeywordAsync(@"
using System.Threading.Tasks;
class C
{
async Task F(Task<int> someTask)
{
someTask.$$
}
}
", dotAwait: true, dotAwaitf: true);
}
[Fact]
public async Task TestDotAwaitSuggestAfterDotOnValueTask()
{
var valueTaskAssembly = typeof(ValueTask).Assembly.Location;
var markup = @$"
<Workspace>
<Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
<MetadataReference>{valueTaskAssembly}</MetadataReference>
<Document FilePath=""Test2.cs"">
using System.Threading.Tasks;
class C
{{
async Task F(ValueTask someTask)
{{
someTask.$$
}}
}}
</Document>
</Project>
</Workspace>
";
await VerifyItemExistsAsync(markup, "await");
await VerifyItemExistsAsync(markup, "awaitf");
}
[Fact]
public async Task TestDotAwaitSuggestAfterDotOnCustomAwaitable()
{
await VerifyKeywordAsync(@"
using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
public class DummyAwaiter: INotifyCompletion {
public bool IsCompleted => true;
public void OnCompleted(Action continuation) => continuation();
public void GetResult() {}
}
public class CustomAwaitable
{
public DummyAwaiter GetAwaiter() => new DummyAwaiter();
}
static class Program
{
static async Task Main()
{
var awaitable = new CustomAwaitable();
awaitable.$$;
}
}", dotAwait: true);
}
[Fact]
public async Task TestDotAwaitSuggestAfterDotOnCustomAwaitableButNotConfigureAwaitEvenIfPresent()
{
await VerifyKeywordAsync(@"
using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
public class DummyAwaiter: INotifyCompletion {
public bool IsCompleted => true;
public void OnCompleted(Action continuation) => continuation();
public void GetResult() {}
}
public class CustomAwaitable
{
public DummyAwaiter GetAwaiter() => new DummyAwaiter();
public ConfiguredTaskAwaitable ConfigureAwait(bool continueOnCapturedContext) => default;
}
static class Program
{
static async Task Main()
{
var awaitable = new CustomAwaitable();
awaitable.$$;
}
}", dotAwait: true, dotAwaitf: false);
}
[Fact]
public async Task TestDotAwaitSuggestAfterDotDot()
{
await VerifyKeywordAsync(@"
using System.Threading.Tasks;
static class Program
{
static async Task Main(Task someTask)
{
someTask.$$.;
}
}", dotAwait: true, dotAwaitf: true);
}
[Fact]
public async Task TestDotAwaitSuggestAfterDotBeforeType()
{
await VerifyKeywordAsync(@"
using System;
using System.Threading.Tasks;
static class Program
{
static async Task Main(Task someTask)
{
someTask.$$
Int32 i = 0;
}
}", dotAwait: true, dotAwaitf: true);
}
[Fact]
public async Task TestDotAwaitSuggestAfterDotBeforeAnotherAwait()
{
await VerifyKeywordAsync(@"
using System;
using System.Threading.Tasks;
static class Program
{
static async Task Main(Task someTask)
{
someTask.$$
await Test();
}
async Task Test() { }
}", dotAwait: true, dotAwaitf: true);
}
[Theory]
[InlineData("")]
[InlineData("X.Y Test();")]
[InlineData("var x;")]
[InlineData("int x;")]
[InlineData("System.Int32 x;")]
[InlineData("if (true) { }")]
[InlineData("System.Int32 Test() => 0;")]
[InlineData("async Task<System.Int32> Test() => await Task.FromResult(1);")]
public async Task TestDotAwaitSuggestAfterDotBeforeDifferentStatements(string statement)
{
await VerifyKeywordAsync($@"
using System;
using System.Threading.Tasks;
static class Program
{{
static async Task Main(Task someTask)
{{
someTask.$$
{statement}
}}
}}", dotAwait: true, dotAwaitf: true);
}
[Theory]
// static
[InlineData("StaticField.$$")]
[InlineData("StaticProperty.$$")]
[InlineData("StaticMethod().$$")]
// parameters, locals and local function
[InlineData("local.$$")]
[InlineData("parameter.$$")]
[InlineData("LocalFunction().$$")]
// members
[InlineData("c.Field.$$")]
[InlineData("c.Property.$$")]
[InlineData("c.Method().$$")]
[InlineData("c.Self.Field.$$")]
[InlineData("c.Self.Property.$$")]
[InlineData("c.Self.Method().$$")]
[InlineData("c.Function()().$$")]
// indexer, operator, conversion
[InlineData("c[0].$$")]
[InlineData("(c + c).$$")]
[InlineData("((Task)c).$$")]
[InlineData("(c as Task).$$")]
// parenthesized
[InlineData("(parameter).$$")]
[InlineData("((parameter)).$$")]
[InlineData("(true ? parameter : parameter).$$")]
[InlineData("(null ?? Task.CompletedTask).$$")]
public async Task TestDotAwaitSuggestAfterDifferentExpressions(string expression)
{
await VerifyKeywordAsync($@"
using System;
using System.Threading.Tasks;
class C
{{
public C Self => this;
public Task Field = Task.CompletedTask;
public Task Method() => Task.CompletedTask;
public Task Property => Task.CompletedTask;
public Task this[int i] => Task.CompletedTask;
public Func<Task> Function() => () => Task.CompletedTask;
public static Task operator +(C left, C right) => Task.CompletedTask;
public static explicit operator Task(C c) => Task.CompletedTask;
}}
static class Program
{{
static Task StaticField = Task.CompletedTask;
static Task StaticProperty => Task.CompletedTask;
static Task StaticMethod() => Task.CompletedTask;
static async Task Main(Task parameter)
{{
Task local = Task.CompletedTask;
var c = new C();
{expression}
Task LocalFunction() => Task.CompletedTask;
}}
}}", dotAwait: true, dotAwaitf: true);
}
[Fact(Skip = "Fails because speculative binding can't figure out that local is a Task.")]
[WorkItem("https://github.com/dotnet/roslyn/issues/56245")]
public async Task TestDotAwaitSuggestBeforeLocalFunction()
{
// Speculative binding a local as expression finds the local as ILocalSymbol, but the type is ErrorType.
// This is only the case when
// * await is partially written (local.a),
// * only for locals (e.g. IParameterSymbols are fine) which
// * are declared with var
// * The return type of the local function is used as first name in a MemberAccess in the declarator
await VerifyKeywordAsync(@"
using System.Threading.Tasks;
static class Program
{
static async Task Main()
{
var local = Task.CompletedTask;
local.a$$
Task LocalFunction() => Task.CompletedTask;
}
}");
}
[Theory]
[InlineData("await Task.Run(async () => Task.CompletedTask.$$")]
[InlineData("await Task.Run(async () => someTask.$$")]
[InlineData("await Task.Run(async () => someTask.$$);")]
[InlineData("await Task.Run(async () => { someTask.$$ }")]
[InlineData("await Task.Run(async () => { someTask.$$ });")]
[InlineData("Task.Run(async () => await someTask).$$")]
[InlineData("await Task.Run(() => someTask.$$")]
public async Task TestDotAwaitSuggestInLambdas(string lambda)
{
await VerifyKeywordAsync($@"
using System.Threading.Tasks;
static class Program
{{
static async Task Main()
{{
var someTask = Task.CompletedTask;
{lambda}
}}
}}", dotAwait: true, dotAwaitf: true);
}
[Fact]
public async Task TestDotAwaitNotAfterDotOnTaskIfAlreadyAwaited()
{
await VerifyAbsenceAsync(@"
using System.Threading.Tasks;
class C
{
async Task F(Task someTask)
{
await someTask.$$
}
}
");
}
[Fact]
public async Task TestDotAwaitNotAfterTaskType()
{
await VerifyAbsenceAsync(@"
using System.Threading.Tasks;
class C
{
async Task F()
{
Task.$$
}
}
");
}
[Fact]
public async Task TestDotAwaitNotInLock()
{
await VerifyAbsenceAsync(@"
using System.Threading.Tasks;
class C
{
async Task F(Task someTask)
{
lock(this) { someTask.$$ }
}
}
");
}
[Fact]
public async Task TestDotAwaitNotInLock_TopLevel()
{
await VerifyAbsenceAsync(@"
using System.Threading.Tasks;
lock(this) { Task.CompletedTask.$$ }
");
}
[Fact]
public async Task TestDotAwaitQueryNotInSelect()
{
await VerifyAbsenceAsync(@"
using System.Linq;
using System.Threading.Tasks;
class C
{
async Task F()
{
var z = from t in new[] { Task.CompletedTask }
select t.$$
}
}
");
}
[Fact]
public async Task TestDotAwaitQueryInFirstFromClause()
{
await VerifyKeywordAsync(@"
using System.Linq;
using System.Threading.Tasks;
class C
{
async Task F()
{
var arrayTask2 = Task.FromResult(new int[0]);
var z = from t in arrayTask2.$$
select t;
}
}
", dotAwait: true, dotAwaitf: true);
}
[Fact]
public async Task TestDotAwaitQueryNotInSecondFromClause()
{
await VerifyNoItemsExistAsync(@"
using System.Linq;
using System.Threading.Tasks;
class C
{
async Task F()
{
var array1 = new int[0];
var arrayTask2 = Task.FromResult(new int[0]);
var z = from i1 in array1
from i2 in arrayTask2.$$
select i2;
}
}
");
}
[Fact]
public async Task TestDotAwaitQueryNotInContinuation()
{
await VerifyNoItemsExistAsync(@"
using System.Linq;
using System.Threading.Tasks;
class C
{
async Task F()
{
var array1 = new int[0];
var arrayTask2 = Task.FromResult(new int[0]);
var z = from i1 in array1
select i1 into c
from i2 in arrayTask2.$$
select i2;
}
}
");
}
[Fact]
public async Task TestDotAwaitQueryInJoinClause()
{
await VerifyKeywordAsync(@"
using System.Linq;
using System.Threading.Tasks;
class C
{
async Task F()
{
var array1 = new int[0];
var arrayTask2 = Task.FromResult(new int[0]);
var z = from i1 in array1
join i2 in arrayTask2.$$ on i1 equals i2
select i1;
}
}
", dotAwait: true, dotAwaitf: true);
}
[Fact]
public async Task TestDotAwaitQueryInJoinIntoClause()
{
await VerifyKeywordAsync(@"
using System.Linq;
using System.Threading.Tasks;
class C
{
async Task F()
{
var array1 = new int[0];
var arrayTask2 = Task.FromResult(new int[0]);
var z = from i1 in array1
join i2 in arrayTask2.$$ on i1 equals i2 into g
select g;
}
}
", dotAwait: true, dotAwaitf: true);
}
[Fact]
public async Task TestDotAwaitNotAfterConditionalAccessOfTaskMembers()
{
// The conditional access suggests, that someTask can be null.
// await on null throws at runtime, so the user should do
// if (someTask is not null) await someTask;
// or
// await (someTask ?? Task.CompletedTask)
// Completion should not offer await, because the patterns above would change to much code.
// This decision should be revised after https://github.com/dotnet/csharplang/issues/35
// is implemented.
await VerifyAbsenceAsync(@"
using System.Threading.Tasks;
class C
{
async Task F(Task someTask)
{
someTask?.$$
}
}
");
}
[Theory]
[InlineData("c?.SomeTask.$$")]
[InlineData("c.M()?.SomeTask.$$")]
[InlineData("c.Pro?.SomeTask.$$")]
[InlineData("c?.M().SomeTask.$$")]
[InlineData("c?.Pro.SomeTask.$$")]
[InlineData("c?.M()?.SomeTask.$$")]
[InlineData("c?.Pro?.SomeTask.$$")]
[InlineData("c.M()?.Pro.SomeTask.$$")]
[InlineData("c.Pro?.M().SomeTask.$$")]
[InlineData("c.M()?.M().M()?.M().SomeTask.$$")]
[InlineData("new C().M()?.Pro.M()?.M().SomeTask.$$")]
public async Task TestDotAwaitNotAfterDotInConditionalAccessChain(string conditionalAccess)
{
await VerifyAbsenceAsync($@"
using System.Threading.Tasks;
public class C
{{
public Task SomeTask => Task.CompletedTask;
public C Pro => this;
public C M() => this;
}}
static class Program
{{
public static async Task Main()
{{
var c = new C();
{conditionalAccess}
}}
}}
");
}
[Theory]
[InlineData("c!.SomeTask.$$")]
[InlineData("c.SomeTask!.$$")]
[InlineData("c.M()!.SomeTask.$$")]
[InlineData("c.Pro!.SomeTask.$$")]
[InlineData("c!.M().SomeTask.$$")]
[InlineData("c!.Pro.SomeTask.$$")]
[InlineData("c!.M()!.SomeTask.$$")]
[InlineData("c!.Pro!.SomeTask.$$")]
[InlineData("c.M()!.Pro.SomeTask.$$")]
[InlineData("c.Pro!.M().SomeTask.$$")]
[InlineData("c.M()!.M().M()!.M().SomeTask.$$")]
[InlineData("new C().M()!.Pro.M()!.M().SomeTask.$$")]
public async Task TestDotAwaitAfterNullForgivingOperatorAccessChain(string nullForgivingAccess)
{
await VerifyKeywordAsync($@"
#nullable enable
using System.Threading.Tasks;
public class C
{{
public Task? SomeTask => Task.CompletedTask;
public C? Pro => this;
public C? M() => this;
}}
static class Program
{{
public static async Task Main(params string[] args)
{{
var c = args[1] == string.Empty ? new C() : null;
{nullForgivingAccess}
}}
}}
", dotAwait: true, dotAwaitf: true);
}
[Theory, CombinatorialData]
[WorkItem("https://github.com/dotnet/roslyn/issues/58921")]
public async Task TestInCastExpressionThatMightBeParenthesizedExpression(bool hasNewline)
{
var code = $@"
class C
{{
void M()
{{
var data = (n$$) {(hasNewline ? Environment.NewLine : string.Empty)} M();
}}
}}";
if (hasNewline)
await VerifyKeywordAsync(code);
else
await VerifyAbsenceAsync(code);
}
}
}
|