diff --git a/src/EditorFeatures/CSharpTest/BraceMatching/CSharpBraceMatcherTests.cs b/src/EditorFeatures/CSharpTest/BraceMatching/CSharpBraceMatcherTests.cs
index 395af990ccf2853737c9bde394e6c6e731a35b98..410684a65c64b16baf4ec3d2bd23f939dec8f0ef 100644
--- a/src/EditorFeatures/CSharpTest/BraceMatching/CSharpBraceMatcherTests.cs
+++ b/src/EditorFeatures/CSharpTest/BraceMatching/CSharpBraceMatcherTests.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.UnitTests.BraceMatching;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Text;
@@ -10,495 +11,495 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.BraceMatching
 {
     public class CSharpBraceMatcherTests : AbstractBraceMatcherTests
     {
-        protected override TestWorkspace CreateWorkspaceFromCode(string code)
+        protected override Task<TestWorkspace> CreateWorkspaceFromCodeAsync(string code)
         {
-            return CSharpWorkspaceFactory.CreateWorkspaceFromLines(code);
+            return CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestEmptyFile()
+        public async Task TestEmptyFile()
         {
             var code = @"$$";
             var expected = @"";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestAtFirstPositionInFile()
+        public async Task TestAtFirstPositionInFile()
         {
             var code = @"$$public class C { }";
             var expected = @"public class C { }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestAtLastPositionInFile()
+        public async Task TestAtLastPositionInFile()
         {
             var code = @"public class C { }$$";
             var expected = @"public class C [|{|] }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestCurlyBrace1()
+        public async Task TestCurlyBrace1()
         {
             var code = @"public class C $${ }";
             var expected = @"public class C { [|}|]";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestCurlyBrace2()
+        public async Task TestCurlyBrace2()
         {
             var code = @"public class C {$$ }";
             var expected = @"public class C { [|}|]";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestCurlyBrace3()
+        public async Task TestCurlyBrace3()
         {
             var code = @"public class C { $$}";
             var expected = @"public class C [|{|] }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestCurlyBrace4()
+        public async Task TestCurlyBrace4()
         {
             var code = @"public class C { }$$";
             var expected = @"public class C [|{|] }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestParen1()
+        public async Task TestParen1()
         {
             var code = @"public class C { void Foo$$() { } }";
             var expected = @"public class C { void Foo([|)|] { } }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestParen2()
+        public async Task TestParen2()
         {
             var code = @"public class C { void Foo($$) { } }";
             var expected = @"public class C { void Foo([|)|] { } }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestParen3()
+        public async Task TestParen3()
         {
             var code = @"public class C { void Foo($$ ) { } }";
             var expected = @"public class C { void Foo( [|)|] { } }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestParen4()
+        public async Task TestParen4()
         {
             var code = @"public class C { void Foo( $$) { } }";
             var expected = @"public class C { void Foo[|(|] ) { } }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestParen5()
+        public async Task TestParen5()
         {
             var code = @"public class C { void Foo( )$$ { } }";
             var expected = @"public class C { void Foo[|(|] ) { } }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestParen6()
+        public async Task TestParen6()
         {
             var code = @"public class C { void Foo()$$ { } }";
             var expected = @"public class C { void Foo[|(|]) { } }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestSquareBracket1()
+        public async Task TestSquareBracket1()
         {
             var code = @"public class C { int$$[] i; }";
             var expected = @"public class C { int[[|]|] i; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestSquareBracket2()
+        public async Task TestSquareBracket2()
         {
             var code = @"public class C { int[$$] i; }";
             var expected = @"public class C { int[[|]|] i; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestSquareBracket3()
+        public async Task TestSquareBracket3()
         {
             var code = @"public class C { int[$$ ] i; }";
             var expected = @"public class C { int[ [|]|] i; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestSquareBracket4()
+        public async Task TestSquareBracket4()
         {
             var code = @"public class C { int[ $$] i; }";
             var expected = @"public class C { int[|[|] ] i; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestSquareBracket5()
+        public async Task TestSquareBracket5()
         {
             var code = @"public class C { int[ ]$$ i; }";
             var expected = @"public class C { int[|[|] ] i; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestSquareBracket6()
+        public async Task TestSquareBracket6()
         {
             var code = @"public class C { int[]$$ i; }";
             var expected = @"public class C { int[|[|]] i; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestAngleBracket1()
+        public async Task TestAngleBracket1()
         {
             var code = @"public class C { Foo$$<int> f; }";
             var expected = @"public class C { Foo<int[|>|] f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestAngleBracket2()
+        public async Task TestAngleBracket2()
         {
             var code = @"public class C { Foo<$$int> f; }";
             var expected = @"public class C { Foo<int[|>|] f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestAngleBracket3()
+        public async Task TestAngleBracket3()
         {
             var code = @"public class C { Foo<int$$> f; }";
             var expected = @"public class C { Foo[|<|]int> f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestAngleBracket4()
+        public async Task TestAngleBracket4()
         {
             var code = @"public class C { Foo<int>$$ f; }";
             var expected = @"public class C { Foo[|<|]int> f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestNestedAngleBracket1()
+        public async Task TestNestedAngleBracket1()
         {
             var code = @"public class C { Func$$<Func<int,int>> f; }";
             var expected = @"public class C { Func<Func<int,int>[|>|] f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestNestedAngleBracket2()
+        public async Task TestNestedAngleBracket2()
         {
             var code = @"public class C { Func<$$Func<int,int>> f; }";
             var expected = @"public class C { Func<Func<int,int>[|>|] f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestNestedAngleBracket3()
+        public async Task TestNestedAngleBracket3()
         {
             var code = @"public class C { Func<Func$$<int,int>> f; }";
             var expected = @"public class C { Func<Func<int,int[|>|]> f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestNestedAngleBracket4()
+        public async Task TestNestedAngleBracket4()
         {
             var code = @"public class C { Func<Func<$$int,int>> f; }";
             var expected = @"public class C { Func<Func<int,int[|>|]> f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestNestedAngleBracket5()
+        public async Task TestNestedAngleBracket5()
         {
             var code = @"public class C { Func<Func<int,int$$>> f; }";
             var expected = @"public class C { Func<Func[|<|]int,int>> f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestNestedAngleBracket6()
+        public async Task TestNestedAngleBracket6()
         {
             var code = @"public class C { Func<Func<int,int>$$> f; }";
             var expected = @"public class C { Func<Func[|<|]int,int>> f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestNestedAngleBracket7()
+        public async Task TestNestedAngleBracket7()
         {
             var code = @"public class C { Func<Func<int,int> $$> f; }";
             var expected = @"public class C { Func[|<|]Func<int,int> > f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestNestedAngleBracket8()
+        public async Task TestNestedAngleBracket8()
         {
             var code = @"public class C { Func<Func<int,int>>$$ f; }";
             var expected = @"public class C { Func[|<|]Func<int,int>> f; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestString1()
+        public async Task TestString1()
         {
             var code = @"public class C { string s = $$""Foo""; }";
             var expected = @"public class C { string s = ""Foo[|""|]; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestString2()
+        public async Task TestString2()
         {
             var code = @"public class C { string s = ""$$Foo""; }";
             var expected = @"public class C { string s = ""Foo[|""|]; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestString3()
+        public async Task TestString3()
         {
             var code = @"public class C { string s = ""Foo$$""; }";
             var expected = @"public class C { string s = [|""|]Foo""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestString4()
+        public async Task TestString4()
         {
             var code = @"public class C { string s = ""Foo""$$; }";
             var expected = @"public class C { string s = [|""|]Foo""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestString5()
+        public async Task TestString5()
         {
             var code = @"public class C { string s = ""Foo$$ ";
             var expected = @"public class C { string s = ""Foo ";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestVerbatimString1()
+        public async Task TestVerbatimString1()
         {
             var code = @"public class C { string s = $$@""Foo""; }";
             var expected = @"public class C { string s = @""Foo[|""|]; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestVerbatimString2()
+        public async Task TestVerbatimString2()
         {
             var code = @"public class C { string s = @$$""Foo""; }";
             var expected = @"public class C { string s = @""Foo[|""|]; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestVerbatimString3()
+        public async Task TestVerbatimString3()
         {
             var code = @"public class C { string s = @""$$Foo""; }";
             var expected = @"public class C { string s = @""Foo[|""|]; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestVerbatimString4()
+        public async Task TestVerbatimString4()
         {
             var code = @"public class C { string s = @""Foo$$""; }";
             var expected = @"public class C { string s = [|@""|]Foo""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestVerbatimString5()
+        public async Task TestVerbatimString5()
         {
             var code = @"public class C { string s = @""Foo""$$; }";
             var expected = @"public class C { string s = [|@""|]Foo""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString1()
+        public async Task TestInterpolatedString1()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""$${x}, {y}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x[|}|], {y}""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString2()
+        public async Task TestInterpolatedString2()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{$$x}, {y}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x[|}|], {y}""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString3()
+        public async Task TestInterpolatedString3()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x$$}, {y}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""[|{|]x}, {y}""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString4()
+        public async Task TestInterpolatedString4()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x}$$, {y}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""[|{|]x}, {y}""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString5()
+        public async Task TestInterpolatedString5()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x}, $${y}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x}, {y[|}|]""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString6()
+        public async Task TestInterpolatedString6()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x}, {$$y}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x}, {y[|}|]""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString7()
+        public async Task TestInterpolatedString7()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x}, {y$$}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x}, [|{|]y}""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString8()
+        public async Task TestInterpolatedString8()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x}, {y}$$""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x}, [|{|]y}""; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString9()
+        public async Task TestInterpolatedString9()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $$[||]$""{x}, {y}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x}, {y}[|""|]; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString10()
+        public async Task TestInterpolatedString10()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $[||]$$""{x}, {y}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $""{x}, {y}[|""|]; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString11()
+        public async Task TestInterpolatedString11()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $$[||]$@""{x}, {y}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $@""{x}, {y}[|""|]; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString12()
+        public async Task TestInterpolatedString12()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $[||]$$@""{x}, {y}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $@""{x}, {y}[|""|]; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)]
-        public void TestInterpolatedString13()
+        public async Task TestInterpolatedString13()
         {
             var code = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $@$$""{x}, {y}""; }";
             var expected = @"public class C { void M() { var x = ""Hello""; var y = ""World""; var s = $@""{x}, {y}[|""|]; }";
 
-            Test(code, expected);
+            await TestAsync(code, expected);
         }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/CommentSelection/CSharpCommentSelectionTests.cs b/src/EditorFeatures/CSharpTest/CommentSelection/CSharpCommentSelectionTests.cs
index ad1e66a8ef3892df4218c2a55ede5c75a5b8458d..f5b36c67a2410e8119bdfb06f664ffc99599e2bc 100644
--- a/src/EditorFeatures/CSharpTest/CommentSelection/CSharpCommentSelectionTests.cs
+++ b/src/EditorFeatures/CSharpTest/CommentSelection/CSharpCommentSelectionTests.cs
@@ -2,6 +2,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Implementation.CommentSelection;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Utilities;
@@ -18,7 +19,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CommentSelection
     public class CSharpCommentSelectionTests
     {
         [WpfFact, Trait(Traits.Feature, Traits.Features.CommentSelection)]
-        public void UncommentAndFormat1()
+        public async Task UncommentAndFormat1()
         {
             var code = @"class A
 {
@@ -34,11 +35,11 @@ void Method()
 
     }
 }";
-            UncommentSelection(code, expected);
+            await UncommentSelectionAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.CommentSelection)]
-        public void UncommentAndFormat2()
+        public async Task UncommentAndFormat2()
         {
             var code = @"class A
 {
@@ -54,11 +55,11 @@ void Method()
 
     }
 }";
-            UncommentSelection(code, expected);
+            await UncommentSelectionAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.CommentSelection)]
-        public void UncommentSingleLineCommentInPseudoBlockComment()
+        public async Task UncommentSingleLineCommentInPseudoBlockComment()
         {
             var code = @"
 class C
@@ -82,11 +83,11 @@ protected void RtlTranslateAlignment2()
     /* Hello world */
 }";
 
-            UncommentSelection(code, expected);
+            await UncommentSelectionAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.CommentSelection)]
-        public void UncommentAndFormat3()
+        public async Task UncommentAndFormat3()
         {
             var code = @"class A
 {
@@ -102,12 +103,12 @@ void Method()
 
     }
 }";
-            UncommentSelection(code, expected);
+            await UncommentSelectionAsync(code, expected);
         }
 
-        private static void UncommentSelection(string markup, string expected)
+        private static async Task UncommentSelectionAsync(string markup, string expected)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(markup))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(markup))
             {
                 var doc = workspace.Documents.First();
                 SetupSelection(doc.GetTextView(), doc.SelectedSpans.Select(s => Span.FromBounds(s.Start, s.End)));
diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/MockDiagnosticAnalyzerTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/MockDiagnosticAnalyzerTests.cs
index 4e34f87b7691bf5180c2983a9bac8d8d972ce080..63b7fcaf53e46c0f869fc1efdfddbd8f7943b7e4 100644
--- a/src/EditorFeatures/CSharpTest/Diagnostics/MockDiagnosticAnalyzerTests.cs
+++ b/src/EditorFeatures/CSharpTest/Diagnostics/MockDiagnosticAnalyzerTests.cs
@@ -55,7 +55,7 @@ public void AnalyzeCompilation(CompilationAnalysisContext context)
              string source,
              params DiagnosticDescription[] expectedDiagnostics)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(source))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(source))
             {
                 var actualDiagnostics = await this.GetDiagnosticsAsync(workspace);
                 actualDiagnostics.Verify(expectedDiagnostics);
diff --git a/src/EditorFeatures/CSharpTest/DocumentationComments/DocumentationCommentTests.cs b/src/EditorFeatures/CSharpTest/DocumentationComments/DocumentationCommentTests.cs
index fa3e4a1e5e52c0c0789f27f67909671d06b5713b..6a49738888d3cea7e8eb1b58ae90faa167192ba3 100644
--- a/src/EditorFeatures/CSharpTest/DocumentationComments/DocumentationCommentTests.cs
+++ b/src/EditorFeatures/CSharpTest/DocumentationComments/DocumentationCommentTests.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.CSharp.DocumentationComments;
 using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.Editor.UnitTests.DocumentationComments;
@@ -13,7 +14,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.DocumentationComments
     public class DocumentationCommentTests : AbstractDocumentationCommentTests
     {
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_Class()
+        public async Task TypingCharacter_Class()
         {
             var code =
 @"//$$
@@ -29,11 +30,11 @@ class C
 {
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_Class_AutoGenerateXmlDocCommentsOff()
+        public async Task TypingCharacter_Class_AutoGenerateXmlDocCommentsOff()
         {
             var code =
 @"//$$
@@ -47,11 +48,11 @@ class C
 {
 }";
 
-            VerifyTypingCharacter(code, expected, autoGenerateXmlDocComments: false);
+            await VerifyTypingCharacterAsync(code, expected, autoGenerateXmlDocComments: false);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_Method()
+        public async Task TypingCharacter_Method()
         {
             var code =
 @"class C
@@ -72,11 +73,11 @@ public void TypingCharacter_Method()
     int M<T>(int foo) { return 0; }
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_Method_WithVerbatimParams()
+        public async Task TypingCharacter_Method_WithVerbatimParams()
         {
             var code =
 @"class C
@@ -97,11 +98,11 @@ public void TypingCharacter_Method_WithVerbatimParams()
     int M<@int>(int @foo) { return 0; }
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_AutoProperty()
+        public async Task TypingCharacter_AutoProperty()
         {
             var code =
 @"class C
@@ -119,11 +120,11 @@ public void TypingCharacter_AutoProperty()
     int P { get; set; }
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_Property()
+        public async Task TypingCharacter_Property()
         {
             var code =
 @"class C
@@ -149,11 +150,11 @@ int P
     }
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_Indexer()
+        public async Task TypingCharacter_Indexer()
         {
             var code =
 @"class C
@@ -181,11 +182,11 @@ public void TypingCharacter_Indexer()
     }
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_VoidMethod1()
+        public async Task TypingCharacter_VoidMethod1()
         {
             var code =
 @"class C
@@ -205,11 +206,11 @@ public void TypingCharacter_VoidMethod1()
     void M<T>(int foo) {  }
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_VoidMethod_WithVerbatimParams()
+        public async Task TypingCharacter_VoidMethod_WithVerbatimParams()
         {
             var code =
 @"class C
@@ -229,12 +230,12 @@ public void TypingCharacter_VoidMethod_WithVerbatimParams()
     void M<@T>(int @int) {  }
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WorkItem(538699)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_VoidMethod2()
+        public async Task TypingCharacter_VoidMethod2()
         {
             var code =
 @"class C
@@ -250,11 +251,11 @@ public void TypingCharacter_VoidMethod2()
     /// </summary>
     void Method() { }
 }";
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_NotWhenDocCommentExists1()
+        public async Task TypingCharacter_NotWhenDocCommentExists1()
         {
             var code = @"
 ///
@@ -270,11 +271,11 @@ class C
 {
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_NotWhenDocCommentExists2()
+        public async Task TypingCharacter_NotWhenDocCommentExists2()
         {
             var code = @"
 ///
@@ -292,11 +293,11 @@ class C
 {
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_NotWhenDocCommentExists3()
+        public async Task TypingCharacter_NotWhenDocCommentExists3()
         {
             var code = @"
 class B { } ///
@@ -314,11 +315,11 @@ class C
 {
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_NotWhenDocCommentExists4()
+        public async Task TypingCharacter_NotWhenDocCommentExists4()
         {
             var code =
 @"//$$
@@ -334,11 +335,11 @@ class C
 {
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_NotWhenDocCommentExists5()
+        public async Task TypingCharacter_NotWhenDocCommentExists5()
         {
             var code =
 @"class C
@@ -356,11 +357,11 @@ public void TypingCharacter_NotWhenDocCommentExists5()
     int M<T>(int foo) { return 0; }
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_NotInsideMethodBody1()
+        public async Task TypingCharacter_NotInsideMethodBody1()
         {
             var code =
 @"class C
@@ -380,11 +381,11 @@ void M(int foo)
     }
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_NotInsideMethodBody2()
+        public async Task TypingCharacter_NotInsideMethodBody2()
         {
             var code =
 @"class C
@@ -406,11 +407,11 @@ void M(int foo)
     }
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_NotAfterClassName()
+        public async Task TypingCharacter_NotAfterClassName()
         {
             var code =
 @"class C//$$
@@ -422,11 +423,11 @@ public void TypingCharacter_NotAfterClassName()
 {
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_NotAfterOpenBrace()
+        public async Task TypingCharacter_NotAfterOpenBrace()
         {
             var code =
 @"class C
@@ -438,11 +439,11 @@ public void TypingCharacter_NotAfterOpenBrace()
 {///$$
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_NotAfterCtorName()
+        public async Task TypingCharacter_NotAfterCtorName()
         {
             var code =
 @"class C
@@ -456,11 +457,11 @@ public void TypingCharacter_NotAfterCtorName()
 C() ///$$
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TypingCharacter_NotInsideCtor()
+        public async Task TypingCharacter_NotInsideCtor()
         {
             var code =
 @"class C
@@ -480,11 +481,11 @@ public void TypingCharacter_NotInsideCtor()
 }
 }";
 
-            VerifyTypingCharacter(code, expected);
+            await VerifyTypingCharacterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertComment_Class1()
+        public async Task PressingEnter_InsertComment_Class1()
         {
             var code =
 @"///$$
@@ -500,12 +501,12 @@ class C
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(4817, "https://github.com/dotnet/roslyn/issues/4817")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertComment_Class1_AutoGenerateXmlDocCommentsOff()
+        public async Task PressingEnter_InsertComment_Class1_AutoGenerateXmlDocCommentsOff()
         {
             var code =
 @"///$$
@@ -520,11 +521,11 @@ class C
 {
 }";
 
-            VerifyPressingEnter(code, expected, autoGenerateXmlDocComments: false);
+            await VerifyPressingEnterAsync(code, expected, autoGenerateXmlDocComments: false);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertComment_Class2()
+        public async Task PressingEnter_InsertComment_Class2()
         {
             var code =
 @"///$$class C
@@ -539,11 +540,11 @@ class C
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertComment_Class3()
+        public async Task PressingEnter_InsertComment_Class3()
         {
             var code =
 @"///$$[Foo] class C
@@ -558,11 +559,11 @@ public void PressingEnter_InsertComment_Class3()
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertComment_NotAfterWhitespace()
+        public async Task PressingEnter_InsertComment_NotAfterWhitespace()
         {
             var code =
             @"///    $$class C
@@ -575,11 +576,11 @@ public void PressingEnter_InsertComment_NotAfterWhitespace()
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertComment_Method1()
+        public async Task PressingEnter_InsertComment_Method1()
         {
             var code =
 @"class C
@@ -600,11 +601,11 @@ public void PressingEnter_InsertComment_Method1()
     int M<T>(int foo) { return 0; }
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertComment_Method2()
+        public async Task PressingEnter_InsertComment_Method2()
         {
             var code =
 @"class C
@@ -624,11 +625,11 @@ public void PressingEnter_InsertComment_Method2()
     int M<T>(int foo) { return 0; }
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_NotInMethodBody1()
+        public async Task PressingEnter_NotInMethodBody1()
         {
             var code =
 @"class C
@@ -649,12 +650,12 @@ void Foo()
 }
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(537513)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_NotInterleavedInClassName1()
+        public async Task PressingEnter_NotInterleavedInClassName1()
         {
             var code =
 @"class///$$ C
@@ -667,12 +668,12 @@ public void PressingEnter_NotInterleavedInClassName1()
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(537513)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_NotInterleavedInClassName2()
+        public async Task PressingEnter_NotInterleavedInClassName2()
         {
             var code =
 @"class ///$$C
@@ -685,12 +686,12 @@ public void PressingEnter_NotInterleavedInClassName2()
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(537513)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_NotInterleavedInClassName3()
+        public async Task PressingEnter_NotInterleavedInClassName3()
         {
             var code =
 @"class /// $$C
@@ -703,13 +704,13 @@ public void PressingEnter_NotInterleavedInClassName3()
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(537514)]
         [WorkItem(537532)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_NotAfterClassName1()
+        public async Task PressingEnter_NotAfterClassName1()
         {
             var code =
 @"class C ///$$
@@ -722,12 +723,12 @@ public void PressingEnter_NotAfterClassName1()
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(537552)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_NotAfterClassName2()
+        public async Task PressingEnter_NotAfterClassName2()
         {
             var code =
 @"class C /** $$
@@ -740,12 +741,12 @@ public void PressingEnter_NotAfterClassName2()
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(537535)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_NotAfterCtorName()
+        public async Task PressingEnter_NotAfterCtorName()
         {
             var code =
 @"class C
@@ -760,12 +761,12 @@ public void PressingEnter_NotAfterCtorName()
 $$
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(537511)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_NotInsideCtor()
+        public async Task PressingEnter_NotInsideCtor()
         {
             var code =
 @"class C
@@ -786,12 +787,12 @@ public void PressingEnter_NotInsideCtor()
 }
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(537550)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_NotBeforeDocComment()
+        public async Task PressingEnter_NotBeforeDocComment()
         {
             var code =
 @"    class c1
@@ -800,7 +801,7 @@ public void PressingEnter_NotBeforeDocComment()
         /// 
         /// </summary>
         /// <returns></returns>
-        public void foo()
+        public async Task foo()
         {
             var x = 1;
         }
@@ -814,17 +815,17 @@ public void foo()
         /// 
         /// </summary>
         /// <returns></returns>
-        public void foo()
+        public async Task foo()
         {
             var x = 1;
         }
     }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes1()
+        public async Task PressingEnter_InsertSlashes1()
         {
             var code =
 @"///$$
@@ -841,11 +842,11 @@ class C
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes2()
+        public async Task PressingEnter_InsertSlashes2()
         {
             var code =
 @"/// <summary>
@@ -864,11 +865,11 @@ class C
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes3()
+        public async Task PressingEnter_InsertSlashes3()
         {
             var code =
 @"    /// <summary>
@@ -887,11 +888,11 @@ class C
     {
     }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes4()
+        public async Task PressingEnter_InsertSlashes4()
         {
             var code =
 @"/// <summary>$$</summary>
@@ -906,11 +907,11 @@ class C
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes5()
+        public async Task PressingEnter_InsertSlashes5()
         {
             var code =
 @"    /// <summary>
@@ -929,11 +930,11 @@ class C
     {
     }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes6()
+        public async Task PressingEnter_InsertSlashes6()
         {
             var code =
 @"/// <summary></summary>$$
@@ -948,11 +949,11 @@ class C
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes7()
+        public async Task PressingEnter_InsertSlashes7()
         {
             var code =
 @"    /// <summary>$$</summary>
@@ -967,12 +968,12 @@ class C
     {
     }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(538702)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes8()
+        public async Task PressingEnter_InsertSlashes8()
         {
             var code =
 @"/// <summary>
@@ -985,11 +986,11 @@ public void PressingEnter_InsertSlashes8()
 /// </summary>
 ///
 /// $$class C {}";
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes9()
+        public async Task PressingEnter_InsertSlashes9()
         {
             var code =
 @"class C
@@ -1008,11 +1009,11 @@ public void PressingEnter_InsertSlashes9()
     int M<T>(int foo) { return 0; }
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes10()
+        public async Task PressingEnter_InsertSlashes10()
         {
             var code =
 @"/// <summary>
@@ -1026,11 +1027,11 @@ public void PressingEnter_InsertSlashes10()
 ///
 /// $$Go ahead and add some slashes";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes11()
+        public async Task PressingEnter_InsertSlashes11()
         {
             var code =
 @"class C
@@ -1057,12 +1058,12 @@ void Foo(int i)
     }
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(4817, "https://github.com/dotnet/roslyn/issues/4817")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InsertSlashes12_AutoGenerateXmlDocCommentsOff()
+        public async Task PressingEnter_InsertSlashes12_AutoGenerateXmlDocCommentsOff()
         {
             var code =
 @"///$$
@@ -1079,12 +1080,12 @@ class C
 {
 }";
 
-            VerifyPressingEnter(code, expected, autoGenerateXmlDocComments: false);
+            await VerifyPressingEnterAsync(code, expected, autoGenerateXmlDocComments: false);
         }
 
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_DontInsertSlashes1()
+        public async Task PressingEnter_DontInsertSlashes1()
         {
             var code =
 @"/// <summary></summary>
@@ -1101,12 +1102,12 @@ class C
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(538701)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_DontInsertSlashes2()
+        public async Task PressingEnter_DontInsertSlashes2()
         {
             var code =
 @"///<summary></summary>
@@ -1119,12 +1120,12 @@ class C{}";
 ///
 $$
 class C{}";
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(542426)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_PreserveParams()
+        public async Task PressingEnter_PreserveParams()
         {
             var code =
 @"/// <summary>
@@ -1142,12 +1143,12 @@ static void Main(string[] args)
 static void Main(string[] args)
 { }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(2091, "https://github.com/dotnet/roslyn/issues/2091")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_InTextBeforeSpace()
+        public async Task PressingEnter_InTextBeforeSpace()
         {
             const string code =
 @"class C
@@ -1172,12 +1173,12 @@ void M()
     }
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(2108, "https://github.com/dotnet/roslyn/issues/2108")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_Indentation1()
+        public async Task PressingEnter_Indentation1()
         {
             const string code =
 @"class C
@@ -1202,12 +1203,12 @@ void M()
     }
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(2108, "https://github.com/dotnet/roslyn/issues/2108")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_Indentation2()
+        public async Task PressingEnter_Indentation2()
         {
             const string code =
 @"class C
@@ -1232,12 +1233,12 @@ void M()
     }
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(2108, "https://github.com/dotnet/roslyn/issues/2108")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_Indentation3()
+        public async Task PressingEnter_Indentation3()
         {
             const string code =
 @"class C
@@ -1262,12 +1263,12 @@ void M()
     }
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(2108, "https://github.com/dotnet/roslyn/issues/2108")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_Indentation4()
+        public async Task PressingEnter_Indentation4()
         {
             const string code =
 @"class C
@@ -1292,12 +1293,12 @@ void M()
     }
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(2108, "https://github.com/dotnet/roslyn/issues/2108")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_Indentation5_UseTabs()
+        public async Task PressingEnter_Indentation5_UseTabs()
         {
             const string code =
 @"class C
@@ -1322,12 +1323,12 @@ void M()
     }
 }";
 
-            VerifyPressingEnter(code, expected, useTabs: true);
+            await VerifyPressingEnterAsync(code, expected, useTabs: true);
         }
 
         [WorkItem(5486, "https://github.com/dotnet/roslyn/issues/5486")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_Selection1()
+        public async Task PressingEnter_Selection1()
         {
             var code =
 @"/// <summary>
@@ -1345,12 +1346,12 @@ class C
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WorkItem(5486, "https://github.com/dotnet/roslyn/issues/5486")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void PressingEnter_Selection2()
+        public async Task PressingEnter_Selection2()
         {
             var code =
 @"/// <summary>
@@ -1368,11 +1369,11 @@ class C
 {
 }";
 
-            VerifyPressingEnter(code, expected);
+            await VerifyPressingEnterAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_Class()
+        public async Task Command_Class()
         {
             var code =
 @"class C
@@ -1387,12 +1388,12 @@ class C
 {
 }";
 
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WorkItem(4817, "https://github.com/dotnet/roslyn/issues/4817")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_Class_AutoGenerateXmlDocCommentsOff()
+        public async Task Command_Class_AutoGenerateXmlDocCommentsOff()
         {
             var code =
 @"class C
@@ -1407,12 +1408,12 @@ class C
 {
 }";
 
-            VerifyInsertCommentCommand(code, expected, autoGenerateXmlDocComments: false);
+            await VerifyInsertCommentCommandAsync(code, expected, autoGenerateXmlDocComments: false);
         }
 
         [WorkItem(538714)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_BeforeClass1()
+        public async Task Command_BeforeClass1()
         {
             var code =
 @"$$
@@ -1424,12 +1425,12 @@ class C { }";
 /// </summary>
 class C { }";
 
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WorkItem(538714)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_BeforeClass2()
+        public async Task Command_BeforeClass2()
         {
             var code =
 @"class B { }
@@ -1443,12 +1444,12 @@ class C { }";
 /// </summary>
 class C { }";
 
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WorkItem(538714)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_BeforeClass3()
+        public async Task Command_BeforeClass3()
         {
             var code =
 @"class B
@@ -1466,12 +1467,12 @@ class C { }
     class C { }
 }";
 
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WorkItem(527604)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_Class_NotIfMultilineDocCommentExists()
+        public async Task Command_Class_NotIfMultilineDocCommentExists()
         {
             var code =
 @"/**
@@ -1482,11 +1483,11 @@ class C { $$ }";
 @"/**
 */
 class C { $$ }";
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_Method()
+        public async Task Command_Method()
         {
             var code =
 @"class C
@@ -1506,11 +1507,11 @@ public void Command_Method()
     int M<T>(int foo) { return 0; }
 }";
 
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_Class_NotIfCommentExists()
+        public async Task Command_Class_NotIfCommentExists()
         {
             var code =
 @"/// <summary></summary>
@@ -1524,11 +1525,11 @@ class C
 {$$
 }";
 
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_Method_NotIfCommentExists()
+        public async Task Command_Method_NotIfCommentExists()
         {
             var code =
 @"class C
@@ -1544,12 +1545,12 @@ public void Command_Method_NotIfCommentExists()
     int M<T>(int foo) { $$return 0; }
 }";
 
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WorkItem(538482)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_FirstClassOnLine()
+        public async Task Command_FirstClassOnLine()
         {
             var code = @"$$class C { } class D { }";
 
@@ -1559,23 +1560,23 @@ public void Command_FirstClassOnLine()
 /// </summary>
 class C { } class D { }";
 
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WorkItem(538482)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_NotOnSecondClassOnLine()
+        public async Task Command_NotOnSecondClassOnLine()
         {
             var code = @"class C { } $$class D { }";
 
             var expected = @"class C { } $$class D { }";
 
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WorkItem(538482)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_FirstMethodOnLine()
+        public async Task Command_FirstMethodOnLine()
         {
             var code =
 @"class C
@@ -1592,12 +1593,12 @@ public void Command_FirstMethodOnLine()
     protected abstract void Foo(); protected abstract void Bar();
 }";
 
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WorkItem(538482)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void Command_NotOnSecondMethodOnLine()
+        public async Task Command_NotOnSecondMethodOnLine()
         {
             var code =
 @"class C
@@ -1611,12 +1612,12 @@ public void Command_NotOnSecondMethodOnLine()
     protected abstract void Foo(); protected abstract void $$Bar();
 }";
 
-            VerifyInsertCommentCommand(code, expected);
+            await VerifyInsertCommentCommandAsync(code, expected);
         }
 
         [WorkItem(917904)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TestUseTab()
+        public async Task TestUseTab()
         {
             var code =
 @"using System;
@@ -1642,12 +1643,12 @@ public Class1()
 	}
 }";
 
-            VerifyTypingCharacter(code, expected, useTabs: true);
+            await VerifyTypingCharacterAsync(code, expected, useTabs: true);
         }
 
         [WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TestOpenLineAbove1()
+        public async Task TestOpenLineAbove1()
         {
             const string code =
 @"class C
@@ -1672,12 +1673,12 @@ void M()
     }
 }";
 
-            VerifyOpenLineAbove(code, expected);
+            await VerifyOpenLineAboveAsync(code, expected);
         }
 
         [WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TestOpenLineAbove2()
+        public async Task TestOpenLineAbove2()
         {
             const string code =
 @"class C
@@ -1702,12 +1703,12 @@ void M()
     }
 }";
 
-            VerifyOpenLineAbove(code, expected);
+            await VerifyOpenLineAboveAsync(code, expected);
         }
 
         [WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TestOpenLineAbove3()
+        public async Task TestOpenLineAbove3()
         {
             const string code =
 @"class C
@@ -1734,12 +1735,12 @@ void M()
     }
 }";
 
-            VerifyOpenLineAbove(code, expected);
+            await VerifyOpenLineAboveAsync(code, expected);
         }
 
         [WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TestOpenLineAbove4_Tabs()
+        public async Task TestOpenLineAbove4_Tabs()
         {
             const string code =
 @"class C
@@ -1764,12 +1765,12 @@ void M()
     }
 }";
 
-            VerifyOpenLineAbove(code, expected, useTabs: true);
+            await VerifyOpenLineAboveAsync(code, expected, useTabs: true);
         }
 
         [WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TestOpenLineBelow1()
+        public async Task TestOpenLineBelow1()
         {
             const string code =
 @"class C
@@ -1794,12 +1795,12 @@ void M()
     }
 }";
 
-            VerifyOpenLineBelow(code, expected);
+            await VerifyOpenLineBelowAsync(code, expected);
         }
 
         [WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TestOpenLineBelow2()
+        public async Task TestOpenLineBelow2()
         {
             const string code =
 @"class C
@@ -1824,12 +1825,12 @@ void M()
     }
 }";
 
-            VerifyOpenLineBelow(code, expected);
+            await VerifyOpenLineBelowAsync(code, expected);
         }
 
         [WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TestOpenLineBelow3()
+        public async Task TestOpenLineBelow3()
         {
             const string code =
 @"/// <summary>
@@ -1844,12 +1845,12 @@ public void TestOpenLineBelow3()
 /// $$
 ";
 
-            VerifyOpenLineBelow(code, expected);
+            await VerifyOpenLineBelowAsync(code, expected);
         }
 
         [WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)]
-        public void TestOpenLineBelow4_Tabs()
+        public async Task TestOpenLineBelow4_Tabs()
         {
             const string code =
 @"class C
@@ -1874,7 +1875,7 @@ void M()
     }
 }";
 
-            VerifyOpenLineBelow(code, expected, useTabs: true);
+            await VerifyOpenLineBelowAsync(code, expected, useTabs: true);
         }
 
         protected override char DocumentationCommentCharacter
@@ -1891,9 +1892,9 @@ protected override char DocumentationCommentCharacter
             return new DocumentationCommentCommandHandler(waitIndicator, undoHistoryRegistry, editorOperationsFactoryService, completionService);
         }
 
-        protected override TestWorkspace CreateTestWorkspace(string code)
+        protected override Task<TestWorkspace> CreateTestWorkspaceAsync(string code)
         {
-            return CSharpWorkspaceFactory.CreateWorkspaceFromLines(code);
+            return CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code);
         }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/DocumentationComments/XmlTagCompletionTests.cs b/src/EditorFeatures/CSharpTest/DocumentationComments/XmlTagCompletionTests.cs
index a862985a2d0cf29c15e56972378ddd9113c1f412..f464db93e35197c8b495b62552e4adf870b02daa 100644
--- a/src/EditorFeatures/CSharpTest/DocumentationComments/XmlTagCompletionTests.cs
+++ b/src/EditorFeatures/CSharpTest/DocumentationComments/XmlTagCompletionTests.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Commands;
 using Microsoft.CodeAnalysis.Editor.CSharp.DocumentationComments;
 using Microsoft.CodeAnalysis.Editor.UnitTests.DocumentationComments;
@@ -14,7 +15,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.DocumentationComments
     public class XmlTagCompletionTests : AbstractXmlTagCompletionTests
     {
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void SimpleTagCompletion()
+        public async Task SimpleTagCompletion()
         {
             var text = @"
 /// <foo$$
@@ -24,11 +25,11 @@ class c { }";
 /// <foo>$$</foo>
 class c { }";
 
-            Verify(text, expected, '>');
+            await VerifyAsync(text, expected, '>');
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void NestedTagCompletion()
+        public async Task NestedTagCompletion()
         {
             var text = @"
 /// <summary>
@@ -42,11 +43,11 @@ class c { }";
 /// </summary>
 class c { }";
 
-            Verify(text, expected, '>');
+            await VerifyAsync(text, expected, '>');
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void CompleteBeforeIncompleteTag()
+        public async Task CompleteBeforeIncompleteTag()
         {
             var text = @"
 /// <foo$$
@@ -58,11 +59,11 @@ class c { }";
 /// </summary>
 class c { }";
 
-            Verify(text, expected, '>');
+            await VerifyAsync(text, expected, '>');
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void NotEmptyElement()
+        public async Task NotEmptyElement()
         {
             var text = @"
 /// <$$
@@ -72,11 +73,11 @@ class c { }";
 /// <>$$
 class c { }";
 
-            Verify(text, expected, '>');
+            await VerifyAsync(text, expected, '>');
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void NotAlreadyCompleteTag()
+        public async Task NotAlreadyCompleteTag()
         {
             var text = @"
 /// <foo$$</foo>
@@ -86,11 +87,11 @@ class c { }";
 /// <foo>$$</foo>
 class c { }";
 
-            Verify(text, expected, '>');
+            await VerifyAsync(text, expected, '>');
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void NotAlreadyCompleteTag2()
+        public async Task NotAlreadyCompleteTag2()
         {
             var text = @"
 /// <foo$$
@@ -104,11 +105,11 @@ class c { }";
 /// </foo>
 class c { }";
 
-            Verify(text, expected, '>');
+            await VerifyAsync(text, expected, '>');
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void SimpleSlashCompletion()
+        public async Task SimpleSlashCompletion()
         {
             var text = @"
 /// <foo><$$
@@ -118,11 +119,11 @@ class c { }";
 /// <foo></foo>$$
 class c { }";
 
-            Verify(text, expected, '/');
+            await VerifyAsync(text, expected, '/');
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void NestedSlashTagCompletion()
+        public async Task NestedSlashTagCompletion()
         {
             var text = @"
 /// <summary>
@@ -136,11 +137,11 @@ class c { }";
 /// </summary>
 class c { }";
 
-            Verify(text, expected, '/');
+            await VerifyAsync(text, expected, '/');
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void SlashCompleteBeforeIncompleteTag()
+        public async Task SlashCompleteBeforeIncompleteTag()
         {
             var text = @"
 /// <foo><$$
@@ -152,11 +153,11 @@ class c { }";
 /// </summary>
 class c { }";
 
-            Verify(text, expected, '/');
+            await VerifyAsync(text, expected, '/');
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void SlashNotEmptyElement()
+        public async Task SlashNotEmptyElement()
         {
             var text = @"
 /// <><$$
@@ -166,11 +167,11 @@ class c { }";
 /// <></$$
 class c { }";
 
-            Verify(text, expected, '/');
+            await VerifyAsync(text, expected, '/');
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void SlashNotAlreadyCompleteTag()
+        public async Task SlashNotAlreadyCompleteTag()
         {
             var text = @"
 /// <foo><$$foo>
@@ -180,11 +181,11 @@ class c { }";
 /// <foo></$$foo>
 class c { }";
 
-            Verify(text, expected, '/');
+            await VerifyAsync(text, expected, '/');
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void SlashNotAlreadyCompleteTag2()
+        public async Task SlashNotAlreadyCompleteTag2()
         {
             var text = @"
 /// <foo>
@@ -198,12 +199,12 @@ class c { }";
 /// </$$foo>
 class c { }";
 
-            Verify(text, expected, '/');
+            await VerifyAsync(text, expected, '/');
         }
 
         [WorkItem(638800)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void NestedIdenticalTags()
+        public async Task NestedIdenticalTags()
         {
             var text = @"
 /// <foo><foo$$</foo>
@@ -213,12 +214,12 @@ class c { }";
 /// <foo><foo>$$</foo></foo>
 class c { }";
 
-            Verify(text, expected, '>');
+            await VerifyAsync(text, expected, '>');
         }
 
         [WorkItem(638800)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void MultipleNestedIdenticalTags()
+        public async Task MultipleNestedIdenticalTags()
         {
             var text = @"
 /// <foo><foo><foo$$</foo></foo>
@@ -228,12 +229,12 @@ class c { }";
 /// <foo><foo><foo>$$</foo></foo></foo>
 class c { }";
 
-            Verify(text, expected, '>');
+            await VerifyAsync(text, expected, '>');
         }
 
         [WorkItem(638235)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)]
-        public void SlashNotIfCloseTagFollows()
+        public async Task SlashNotIfCloseTagFollows()
         {
             var text = @"
 /// <summary>
@@ -247,7 +248,7 @@ class c { }";
 /// </summary>
 class c { }";
 
-            Verify(text, expected, '/');
+            await VerifyAsync(text, expected, '/');
         }
 
         internal override ICommandHandler<TypeCharCommandArgs> CreateCommandHandler(ITextUndoHistoryRegistry undoHistory)
@@ -255,9 +256,9 @@ internal override ICommandHandler<TypeCharCommandArgs> CreateCommandHandler(ITex
             return new XmlTagCompletionCommandHandler(undoHistory, TestWaitIndicator.Default);
         }
 
-        protected override TestWorkspace CreateTestWorkspace(string initialMarkup)
+        protected override Task<TestWorkspace> CreateTestWorkspaceAsync(string initialMarkup)
         {
-            return CSharpWorkspaceFactory.CreateWorkspaceFromLines(initialMarkup);
+            return CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(initialMarkup);
         }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs b/src/EditorFeatures/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs
index ae6710d6407fc30934412de0fa376b149eb834aa..f46fcc651903d9e9bd35b0929c52bf9d2a20e7d3 100644
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs
@@ -5,6 +5,7 @@
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Differencing;
@@ -231,7 +232,7 @@ public void ErrorSpansAllKinds()
         }
 
         [WpfFact]
-        public void AnalyzeDocumentAsync_InsignificantChangesInMethodBody()
+        public async Task AnalyzeDocumentAsync_InsignificantChangesInMethodBody()
         {
             string source1 = @"
 class C
@@ -254,7 +255,7 @@ public static void Main()
 ";
             var analyzer = new CSharpEditAndContinueAnalyzer();
 
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(source1))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(source1))
             {
                 var documentId = workspace.CurrentSolution.Projects.First().Documents.First().Id;
                 var oldSolution = workspace.CurrentSolution;
@@ -289,7 +290,7 @@ public static void Main()
         }
 
         [WpfFact]
-        public void AnalyzeDocumentAsync_SyntaxError_Change()
+        public async Task AnalyzeDocumentAsync_SyntaxError_Change()
         {
             string source1 = @"
 class C
@@ -311,7 +312,7 @@ public static void Main()
 ";
             var analyzer = new CSharpEditAndContinueAnalyzer();
 
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(source1))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(source1))
             {
                 var documentId = workspace.CurrentSolution.Projects.First().Documents.First().Id;
                 var oldSolution = workspace.CurrentSolution;
@@ -327,7 +328,7 @@ public static void Main()
         }
 
         [WpfFact]
-        public void AnalyzeDocumentAsync_SyntaxError_NoChange()
+        public async Task AnalyzeDocumentAsync_SyntaxError_NoChange()
         {
             string source = @"
 class C
@@ -340,7 +341,7 @@ public static void Main()
 ";
             var analyzer = new CSharpEditAndContinueAnalyzer();
 
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(source))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(source))
             {
                 var document = workspace.CurrentSolution.Projects.First().Documents.First();
                 var baseActiveStatements = ImmutableArray.Create<ActiveStatementSpan>();
@@ -353,7 +354,7 @@ public static void Main()
         }
 
         [WpfFact]
-        public void AnalyzeDocumentAsync_SyntaxError_NoChange2()
+        public async Task AnalyzeDocumentAsync_SyntaxError_NoChange2()
         {
             string source1 = @"
 class C
@@ -375,7 +376,7 @@ public static void Main()
 ";
             var analyzer = new CSharpEditAndContinueAnalyzer();
 
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(source1))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(source1))
             {
                 var documentId = workspace.CurrentSolution.Projects.First().Documents.First().Id;
                 var oldSolution = workspace.CurrentSolution;
@@ -470,7 +471,7 @@ public static void Main()
         }
 
         [WpfFact]
-        public void AnalyzeDocumentAsync_SemanticError_NoChange()
+        public async Task AnalyzeDocumentAsync_SemanticError_NoChange()
         {
             string source = @"
 class C
@@ -484,7 +485,7 @@ public static void Main()
 ";
             var analyzer = new CSharpEditAndContinueAnalyzer();
 
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(source))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(source))
             {
                 var document = workspace.CurrentSolution.Projects.First().Documents.First();
                 var baseActiveStatements = ImmutableArray.Create<ActiveStatementSpan>();
@@ -497,7 +498,7 @@ public static void Main()
         }
 
         [WpfFact]
-        public void AnalyzeDocumentAsync_SemanticError_Change()
+        public async Task AnalyzeDocumentAsync_SemanticError_Change()
         {
             string source1 = @"
 class C
@@ -521,7 +522,7 @@ public static void Main()
 ";
             var analyzer = new CSharpEditAndContinueAnalyzer();
 
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(source1))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(source1))
             {
                 var documentId = workspace.CurrentSolution.Projects.First().Documents.First().Id;
                 var oldSolution = workspace.CurrentSolution;
@@ -537,7 +538,7 @@ public static void Main()
         }
 
         [WpfFact]
-        public void AnalyzeDocumentAsync_AddingNewFileHavingRudeEdits()
+        public async Task AnalyzeDocumentAsync_AddingNewFileHavingRudeEdits()
         {
             string source1 = @"
 namespace N
@@ -560,7 +561,7 @@ public class D
 ";
             var analyzer = new CSharpEditAndContinueAnalyzer();
 
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(source1))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(source1))
             {
                 // fork the solution to introduce a change
                 var project = workspace.CurrentSolution.Projects.Single();
@@ -593,7 +594,7 @@ public class D
         }
 
         [WpfFact]
-        public void AnalyzeDocumentAsync_AddingNewFile()
+        public async Task AnalyzeDocumentAsync_AddingNewFile()
         {
             string source1 = @"
 namespace N
@@ -610,7 +611,7 @@ public static void Main()
 ";
             var analyzer = new CSharpEditAndContinueAnalyzer();
 
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(source1))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(source1))
             {
                 // fork the solution to introduce a change
                 var project = workspace.CurrentSolution.Projects.Single();
diff --git a/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodBase.cs b/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodBase.cs
index 6fd24f6ad28fabdf5595fa9875e829c796b18bc6..dbeae71e2dac21f96751b4bd148295e0c6d8d692 100644
--- a/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodBase.cs
+++ b/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodBase.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.ExtractMethod;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -14,9 +15,9 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ExtractMethod
 {
     public class ExtractMethodBase
     {
-        protected void ExpectExtractMethodToFail(string codeWithMarker, bool allowMovingDeclaration = true, bool dontPutOutOrRefOnStruct = true)
+        protected async Task ExpectExtractMethodToFailAsync(string codeWithMarker, bool allowMovingDeclaration = true, bool dontPutOutOrRefOnStruct = true)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(codeWithMarker))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(codeWithMarker))
             {
                 var testDocument = workspace.Documents.First();
                 var textSpan = testDocument.SelectedSpans.Single();
@@ -24,14 +25,14 @@ protected void ExpectExtractMethodToFail(string codeWithMarker, bool allowMoving
             }
         }
 
-        protected void ExpectExtractMethodToFail(
+        protected async Task ExpectExtractMethodToFailAsync(
             string codeWithMarker,
             string expected,
             bool allowMovingDeclaration = true,
             bool dontPutOutOrRefOnStruct = true,
             CSharpParseOptions parseOptions = null)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(new[] { codeWithMarker }, parseOptions: parseOptions))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(new[] { codeWithMarker }, parseOptions: parseOptions))
             {
                 var testDocument = workspace.Documents.Single();
                 var subjectBuffer = testDocument.TextBuffer;
@@ -48,9 +49,9 @@ protected void ExpectExtractMethodToFail(string codeWithMarker, bool allowMoving
             }
         }
 
-        protected void NotSupported_ExtractMethod(string codeWithMarker)
+        protected async Task NotSupported_ExtractMethodAsync(string codeWithMarker)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(codeWithMarker))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(codeWithMarker))
             {
                 Assert.NotNull(Record.Exception(() =>
                 {
diff --git a/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.LanguageInteraction.cs b/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.LanguageInteraction.cs
index 60ae2fe6bd4ebaa9082ef5b0fc320ee8fbd8bf98..f33d8d55c08e33eca6b28bbef439794907d9a7a8 100644
--- a/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.LanguageInteraction.cs
+++ b/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.LanguageInteraction.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -817,7 +818,7 @@ private static int NewMethod()
 
             [WorkItem(11155, "DevDiv_Projects/Roslyn")]
             [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-            public void AnonymousTypeMember1()
+            public async Task AnonymousTypeMember1()
             {
                 var code = @"using System;
  
@@ -830,7 +831,7 @@ static void Main(string[] args)
     }
 }
 ";
-                ExpectExtractMethodToFail(code);
+                await ExpectExtractMethodToFailAsync(code);
             }
 
             [WorkItem(544259)]
@@ -862,7 +863,7 @@ private static Program NewMethod()
 
             [WorkItem(543984)]
             [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-            public void ExtractMethod_UnsafeAddressTaken()
+            public async Task ExtractMethod_UnsafeAddressTaken()
             {
                 var code = @"class C
 {
@@ -886,7 +887,7 @@ unsafe void M()
     }
 }";
 
-                ExpectExtractMethodToFail(code, expected);
+                await ExpectExtractMethodToFailAsync(code, expected);
             }
 
             [WorkItem(544387)]
@@ -926,7 +927,7 @@ private static unsafe int GetA1(int* p1)
 
             [WorkItem(544514)]
             [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-            public void ExtractMethod_AnonymousType()
+            public async Task ExtractMethod_AnonymousType()
             {
                 var code = @"public class Test
 {
@@ -954,7 +955,7 @@ private static void NewMethod(object p2)
     }
 }";
 
-                ExpectExtractMethodToFail(code, expected);
+                await ExpectExtractMethodToFailAsync(code, expected);
             }
 
             [WorkItem(544920)]
@@ -990,7 +991,7 @@ private static void NewMethod()
 
             [WorkItem(539310)]
             [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-            public void Readonly_Field_WrittenTo()
+            public async Task Readonly_Field_WrittenTo()
             {
                 var code = @"class C
 {
@@ -1001,7 +1002,7 @@ public void Readonly_Field_WrittenTo()
         [|i = 1;|]
     }
 }";
-                ExpectExtractMethodToFail(code);
+                await ExpectExtractMethodToFailAsync(code);
             }
 
             [WorkItem(539310)]
@@ -1038,7 +1039,7 @@ private void NewMethod()
 
             [WorkItem(545180)]
             [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-            public void NodeHasSyntacticErrors()
+            public async Task NodeHasSyntacticErrors()
             {
                 var code = @"using System;
 using System.Collections.Generic;
@@ -1055,12 +1056,12 @@ static void Main(string[] args)
     }
 }
 ";
-                ExpectExtractMethodToFail(code);
+                await ExpectExtractMethodToFailAsync(code);
             }
 
             [WorkItem(545292)]
             [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-            public void LocalConst()
+            public async Task LocalConst()
             {
                 var code = @"class Test
 {
@@ -1069,7 +1070,7 @@ public static void Main()
         const int v = [|3|];
     }
 }";
-                ExpectExtractMethodToFail(code);
+                await ExpectExtractMethodToFailAsync(code);
             }
 
             [WorkItem(545315)]
@@ -1105,7 +1106,7 @@ private static void NewMethod(int? q)
 
             [WorkItem(545263)]
             [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-            public void SyntacticErrorInSelection()
+            public async Task SyntacticErrorInSelection()
             {
                 var code = @"class Program
 {
@@ -1122,7 +1123,7 @@ private static string NewMethod()
     }
 }
 ";
-                ExpectExtractMethodToFail(code);
+                await ExpectExtractMethodToFailAsync(code);
             }
 
             [WorkItem(544497)]
@@ -1663,7 +1664,7 @@ private static async Task<int> NewMethod(int i)
             }
 
             [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-            public void AwaitExpression_Normal_AwaitWithReturnParameter_Error()
+            public async Task AwaitExpression_Normal_AwaitWithReturnParameter_Error()
             {
                 var code = @"using System;
 using System.Threading.Tasks;
@@ -1677,7 +1678,7 @@ public async void Test(int i)
         Console.WriteLine(i);
     }
 }";
-                ExpectExtractMethodToFail(code);
+                await ExpectExtractMethodToFailAsync(code);
             }
 
             [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
diff --git a/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.cs b/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.cs
index 000ac740c4e5b2d2b299f4404a28524b5149250f..2ed6811d3fd38cb5a5a6318db385ca348fdffc69 100644
--- a/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.cs
+++ b/src/EditorFeatures/CSharpTest/ExtractMethod/ExtractMethodTests.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using System.Xml.Linq;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.ExtractMethod;
@@ -1636,7 +1637,7 @@ private static void NewMethod(int unassigned)
 
         [WorkItem(538303)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void ExtractMethod40()
+        public async Task ExtractMethod40()
         {
             var code = @"class Program
 {
@@ -1645,7 +1646,7 @@ static void Main(string[] args)
         [|int x;|]
     }
 }";
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(868414)]
@@ -1685,7 +1686,7 @@ private static void NewMethod()
 
         [WorkItem(632351)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void ExtractMethodFailForTypeInFromClause()
+        public async Task ExtractMethodFailForTypeInFromClause()
         {
             var code = @"class Program
 {
@@ -1694,12 +1695,12 @@ static void Main(string[] args)
         var z = from [|T|] x in e;
     }
 }";
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(632351)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void ExtractMethodFailForTypeInFromClause_1()
+        public async Task ExtractMethodFailForTypeInFromClause_1()
         {
             var code = @"class Program
 {
@@ -1708,7 +1709,7 @@ static void Main(string[] args)
         var z = from [|W.T|] x in e;
     }
 }";
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(538314)]
@@ -2628,7 +2629,7 @@ private static T GetT<T>()
 
         [WorkItem(4782, "DevDiv_Projects/Roslyn")]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void BugFix4782_2()
+        public async Task BugFix4782_2()
         {
             var code = @"class A<T>
 {
@@ -2644,7 +2645,7 @@ static void Foo()
     }
 }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(4791, "DevDiv_Projects/Roslyn")]
@@ -3293,7 +3294,7 @@ private static void NewMethod(int i)
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void MatrixCase_NoNoNoYesNoNoNoNo()
+        public async Task MatrixCase_NoNoNoYesNoNoNoNo()
         {
             var code = @"using System;
 
@@ -3307,11 +3308,11 @@ void Test5()
     }
 }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void MatrixCase_NoNoNoYesNoNoNoYes()
+        public async Task MatrixCase_NoNoNoYesNoNoNoYes()
         {
             var code = @"using System;
 
@@ -3327,7 +3328,7 @@ void Test6()
     }
 }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
@@ -4270,7 +4271,7 @@ private static int NewMethod(int i)
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void MatrixCase_NoYesNoYesNoNoYesNo()
+        public async Task MatrixCase_NoYesNoYesNoNoYesNo()
         {
             var code = @"using System;
 
@@ -4286,11 +4287,11 @@ void Test23()
     }
 }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void MatrixCase_NoYesNoYesNoNoYesYes()
+        public async Task MatrixCase_NoYesNoYesNoNoYesYes()
         {
             var code = @"using System;
 
@@ -4308,7 +4309,7 @@ void Test24()
     }
 }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
@@ -5938,7 +5939,7 @@ private static void NewMethod(out int x, out int y)
 
         [WorkItem(539225)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void Bug5098()
+        public async Task Bug5098()
         {
             var code = @"class Program
 {
@@ -5949,7 +5950,7 @@ static void Main(string[] args)
     }
 }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(539229)]
@@ -6481,7 +6482,7 @@ private static void NewMethod()
 
         [WorkItem(539963)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void ExtractMethod53()
+        public async Task ExtractMethod53()
         {
             var code = @"class Class
 {
@@ -6492,12 +6493,12 @@ void Main()
 }
 enum Enum { }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(539964)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void ExtractMethod54()
+        public async Task ExtractMethod54()
         {
             var code = @"class Class
 {
@@ -6506,7 +6507,7 @@ void Main([|string|][] args)
     }
 }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(540072)]
@@ -6921,7 +6922,7 @@ private static void NewMethod(bool b)
 
         [WorkItem(540154)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void Bug6313_1()
+        public async Task Bug6313_1()
         {
             var code = @"using System;
 
@@ -6937,12 +6938,12 @@ void Test(bool b)
     }
 }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(540154)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void Bug6313_2()
+        public async Task Bug6313_2()
         {
             var code = @"using System;
 
@@ -6958,7 +6959,7 @@ int Test(bool b)
     }
 }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(540154)]
@@ -7135,7 +7136,7 @@ private static void NewMethod()
 
         [WorkItem(540154)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void Bug6313_6()
+        public async Task Bug6313_6()
         {
             var code = @"using System;
 
@@ -7154,7 +7155,7 @@ void Test()
         };
     }
 }";
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(540170)]
@@ -7536,14 +7537,14 @@ private static int GetY()
 
         [WorkItem(540335)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void Bug6562_1()
+        public async Task Bug6562_1()
         {
             var code = @"using System;
 class Program
 {
     const int i = [|10|];
 }";
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(540335)]
@@ -7594,7 +7595,7 @@ private static string NewMethod()
 
         [WorkItem(540361)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void Bug6598()
+        public async Task Bug6598()
         {
             var code = @"using System;
 using System.Collections.Generic;
@@ -7607,7 +7608,7 @@ static void Main(string[] args)
         [|Program|]
     }
 }";
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(540372)]
@@ -7649,7 +7650,7 @@ private static void NewMethod()
 
         [WorkItem(540396)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void InvalidSelection_MethodBody()
+        public async Task InvalidSelection_MethodBody()
         {
             var code = @"using System;
 
@@ -7669,7 +7670,7 @@ void Method5(bool b1, bool b2)
         }|]
     }
 }    ";
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(541586)]
@@ -7728,7 +7729,7 @@ private static int GetX2(int x1)
 
         [WorkItem(541668)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void BreakInSelection()
+        public async Task BreakInSelection()
         {
             var code = @"using System;
 using System.Collections.Generic;
@@ -7763,7 +7764,7 @@ static void Main(string[] args)
         }
     }
 }";
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(541671)]
@@ -7900,7 +7901,7 @@ private static Program NewMethod()
 
         [WorkItem(541889)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void DontCrashOnRangeVariableSymbol()
+        public async Task DontCrashOnRangeVariableSymbol()
         {
             var code = @"class Test
 {
@@ -7910,7 +7911,7 @@ public void Linq1()
         var lowNums = [|from|] n in numbers where n < 5 select n;
     }
 }";
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
@@ -9512,7 +9513,7 @@ private static string NewMethod(string a)
 
         [WorkItem(544675)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void HiddenPosition()
+        public async Task HiddenPosition()
         {
             var code = @"class Program
 {
@@ -9525,7 +9526,7 @@ static void Main(string[] args)
 #line hidden
 }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(530609)]
@@ -9999,7 +10000,7 @@ private static int NewMethod()
 
         [WorkItem(574576)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void TestAsyncMethodWithRefOrOutParameters()
+        public async Task TestAsyncMethodWithRefOrOutParameters()
         {
             var code =
 @"using System.Threading.Tasks;
@@ -10016,12 +10017,12 @@ public async void Foo()
     }
 }";
 
-            ExpectExtractMethodToFail(code);
+            await ExpectExtractMethodToFailAsync(code);
         }
 
         [WorkItem(1025272)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void TestAsyncMethodWithWellKnownValueType()
+        public async Task TestAsyncMethodWithWellKnownValueType()
         {
             var code =
 @"using System;
@@ -10073,11 +10074,11 @@ private static async Task<int> NewMethod(ref CancellationToken cancellationToken
         }, cancellationToken);
     }
 }";
-            ExpectExtractMethodToFail(code, expected);
+            await ExpectExtractMethodToFailAsync(code, expected);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void TestAsyncMethodWithWellKnownValueType1()
+        public async Task TestAsyncMethodWithWellKnownValueType1()
         {
             var code =
 @"using System;
@@ -10102,11 +10103,11 @@ public async Task Hello()
         Console.WriteLine(i);
     }
 }";
-            ExpectExtractMethodToFail(code, allowMovingDeclaration: false);
+            await ExpectExtractMethodToFailAsync(code, allowMovingDeclaration: false);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
-        public void TestDontPutOutOrRefForStructOff()
+        public async Task TestDontPutOutOrRefForStructOff()
         {
             var code =
 @"using System.Threading.Tasks;
@@ -10135,7 +10136,7 @@ private async Task<int> Test()
         }
     }
 }";
-            ExpectExtractMethodToFail(code, dontPutOutOrRefOnStruct: false);
+            await ExpectExtractMethodToFailAsync(code, dontPutOutOrRefOnStruct: false);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.ExtractMethod)]
diff --git a/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTestBase.cs b/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTestBase.cs
index d44e5a0bc329be5aa694d9127445b26ca3fcde4e..d3373820aa1ae216a4750bb907fdb078853def0c 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTestBase.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTestBase.cs
@@ -25,14 +25,15 @@
 using Roslyn.Test.Utilities;
 using Xunit;
 using Roslyn.Utilities;
+using System.Threading.Tasks;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Formatting
 {
     public class FormattingEngineTestBase
     {
-        protected void AssertFormat(string expected, string code, bool debugMode = false, Dictionary<OptionKey, object> changedOptionSet = null, bool useTab = false, bool testWithTransformation = true)
+        protected async Task AssertFormatAsync(string expected, string code, bool debugMode = false, Dictionary<OptionKey, object> changedOptionSet = null, bool useTab = false, bool testWithTransformation = true)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(code))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code))
             {
                 var hostdoc = workspace.Documents.First();
 
@@ -110,9 +111,9 @@ private static string ApplyResultAndGetFormattedText(ITextBuffer buffer, IList<T
             return buffer.CurrentSnapshot.GetText();
         }
 
-        protected void AssertFormat(string expected, string code, IEnumerable<TextSpan> spans, bool debugMode = false, Dictionary<OptionKey, object> changedOptionSet = null, int? baseIndentation = null)
+        protected async Task AssertFormatAsync(string expected, string code, IEnumerable<TextSpan> spans, bool debugMode = false, Dictionary<OptionKey, object> changedOptionSet = null, int? baseIndentation = null)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(code))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code))
             {
                 var hostdoc = workspace.Documents.First();
                 var buffer = hostdoc.GetTextBuffer();
@@ -173,7 +174,7 @@ internal static void AssertFormat(Workspace workspace, string expected, OptionSe
             Assert.Equal(expected, actual);
         }
 
-        protected static void AssertFormatWithView(string expectedWithMarker, string codeWithMarker, bool debugMode = false)
+        protected static async Task AssertFormatWithViewAsync(string expectedWithMarker, string codeWithMarker, bool debugMode = false)
         {
             var editorOperations = new Mock<IEditorOperations>(MockBehavior.Strict);
             var editorOperationsFactoryService = new Mock<IEditorOperationsFactoryService>(MockBehavior.Strict);
@@ -183,7 +184,7 @@ protected static void AssertFormatWithView(string expectedWithMarker, string cod
 
             editorOperationsFactoryService.Setup(s => s.GetEditorOperations(It.IsAny<ITextView>())).Returns(editorOperations.Object);
 
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(codeWithMarker))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(codeWithMarker))
             {
                 // set up caret position
                 var testDocument = workspace.Documents.Single();
@@ -210,9 +211,9 @@ protected static void AssertFormatWithView(string expectedWithMarker, string cod
             }
         }
 
-        protected static void AssertFormatWithPasteOrReturn(string expectedWithMarker, string codeWithMarker, bool allowDocumentChanges, bool isPaste = true)
+        protected static async Task AssertFormatWithPasteOrReturnAsync(string expectedWithMarker, string codeWithMarker, bool allowDocumentChanges, bool isPaste = true)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(codeWithMarker))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(codeWithMarker))
             {
                 workspace.CanApplyChangeDocument = allowDocumentChanges;
 
@@ -256,13 +257,13 @@ protected static void AssertFormatWithPasteOrReturn(string expectedWithMarker, s
             }
         }
 
-        protected void AssertFormatWithBaseIndent(string expected, string markupCode, int baseIndentation)
+        protected async Task AssertFormatWithBaseIndentAsync(string expected, string markupCode, int baseIndentation)
         {
             string code;
             TextSpan span;
             MarkupTestFile.GetSpan(markupCode, out code, out span);
 
-            AssertFormat(
+            await AssertFormatAsync(
                 expected,
                 code,
             new List<TextSpan> { span },
diff --git a/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs b/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs
index e2c0def2a53c9ff6f5febc70290d3b49941e8163..9d99acfc0e3727499899363898edc348ef4c8352 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests.cs
@@ -2,6 +2,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Commands;
 using Microsoft.CodeAnalysis.Editor.Implementation.Formatting;
 using Microsoft.CodeAnalysis.Editor.Options;
@@ -23,7 +24,7 @@ public class FormattingEngineTests : FormattingEngineTestBase
         [WpfFact]
         [WorkItem(539682)]
         [Trait(Traits.Feature, Traits.Features.Formatting)]
-        public void FormatDocumentCommandHandler()
+        public async Task FormatDocumentCommandHandler()
         {
             var code = @"class Program
 {
@@ -45,13 +46,13 @@ static void Main(string[] args)
 }
 ";
 
-            AssertFormatWithView(expected, code);
+            await AssertFormatWithViewAsync(expected, code);
         }
 
         [WpfFact]
         [WorkItem(539682)]
         [Trait(Traits.Feature, Traits.Features.Formatting)]
-        public void FormatDocumentPasteCommandHandler()
+        public async Task FormatDocumentPasteCommandHandler()
         {
             var code = @"class Program
 {
@@ -73,13 +74,13 @@ static void Main(string[] args)
 }
 ";
 
-            AssertFormatWithPasteOrReturn(expected, code, allowDocumentChanges: true);
+            await AssertFormatWithPasteOrReturnAsync(expected, code, allowDocumentChanges: true);
         }
 
         [WpfFact]
         [WorkItem(547261)]
         [Trait(Traits.Feature, Traits.Features.Formatting)]
-        public void FormatDocumentReadOnlyWorkspacePasteCommandHandler()
+        public async Task FormatDocumentReadOnlyWorkspacePasteCommandHandler()
         {
             var code = @"class Program
 {
@@ -101,13 +102,13 @@ static void Main(string[] args)
 }
 ";
 
-            AssertFormatWithPasteOrReturn(expected, code, allowDocumentChanges: false);
+            await AssertFormatWithPasteOrReturnAsync(expected, code, allowDocumentChanges: false);
         }
 
         [WpfFact]
         [WorkItem(912965)]
         [Trait(Traits.Feature, Traits.Features.Formatting)]
-        public void FormatUsingStatementOnReturn()
+        public async Task FormatUsingStatementOnReturn()
         {
             var code = @"class Program
 {
@@ -129,13 +130,13 @@ static void Main(string[] args)
 }
 ";
 
-            AssertFormatWithPasteOrReturn(expected, code, allowDocumentChanges: true, isPaste: false);
+            await AssertFormatWithPasteOrReturnAsync(expected, code, allowDocumentChanges: true, isPaste: false);
         }
 
         [WpfFact]
         [WorkItem(912965)]
         [Trait(Traits.Feature, Traits.Features.Formatting)]
-        public void FormatNotUsingStatementOnReturn()
+        public async Task FormatNotUsingStatementOnReturn()
         {
             var code = @"class Program
 {
@@ -157,7 +158,7 @@ static void Main(string[] args)
 }
 ";
 
-            AssertFormatWithPasteOrReturn(expected, code, allowDocumentChanges: true, isPaste: false);
+            await AssertFormatWithPasteOrReturnAsync(expected, code, allowDocumentChanges: true, isPaste: false);
         }
 
         [WorkItem(977133)]
diff --git a/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests_Venus.cs b/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests_Venus.cs
index cef9877ef991c51f7fb461c830cc13766f36dd57..3ea30c8bad0dd525b077381db2d4f1af7a9c2603 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests_Venus.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/FormattingEngineTests_Venus.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -9,7 +10,7 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Formatting
     public class FormattingEngineTests_Venus : FormattingEngineTestBase
     {
         [WpfFact, Trait(Traits.Feature, Traits.Features.Formatting), Trait(Traits.Feature, Traits.Features.Venus)]
-        public void SimpleOneLineNugget()
+        public async Task SimpleOneLineNugget()
         {
             var code = @"public class Default
 {
@@ -33,11 +34,11 @@ void PreRender()
 }
 }";
 
-            AssertFormatWithBaseIndent(expected, code, baseIndentation: 7);
+            await AssertFormatWithBaseIndentAsync(expected, code, baseIndentation: 7);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.Formatting), Trait(Traits.Feature, Traits.Features.Venus)]
-        public void SimpleMultiLineNugget()
+        public async Task SimpleMultiLineNugget()
         {
             var code = @"public class Default
 {
@@ -66,11 +67,11 @@ void PreRender()
 }
 }";
 
-            AssertFormatWithBaseIndent(expected, code, baseIndentation: 3);
+            await AssertFormatWithBaseIndentAsync(expected, code, baseIndentation: 3);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.Formatting), Trait(Traits.Feature, Traits.Features.Venus)]
-        public void SimpleQueryWithinNugget()
+        public async Task SimpleQueryWithinNugget()
         {
             var code = @"public class Default
 {
@@ -100,11 +101,11 @@ void PreRender()
 }
 }";
 
-            AssertFormatWithBaseIndent(expected, code, baseIndentation: 7);
+            await AssertFormatWithBaseIndentAsync(expected, code, baseIndentation: 7);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.Formatting), Trait(Traits.Feature, Traits.Features.Venus)]
-        public void LambdaExpressionInNugget()
+        public async Task LambdaExpressionInNugget()
         {
             var code = @"public class Default
 {
@@ -134,12 +135,12 @@ void PreRender()
 }
 }";
 
-            AssertFormatWithBaseIndent(expected, code, baseIndentation: 3);
+            await AssertFormatWithBaseIndentAsync(expected, code, baseIndentation: 3);
         }
 
         [WorkItem(576457)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.Formatting), Trait(Traits.Feature, Traits.Features.Venus)]
-        public void StatementLambdaInNugget()
+        public async Task StatementLambdaInNugget()
         {
             var code = @"public class Default
 {
@@ -190,7 +191,7 @@ void PreRender()
             // It is somewhat odd that the 'x' and the ')' maintain their
             // position relative to 'foreach', but the block doesn't, but that isn't
             // Venus specific, just the way the formatting engine is.
-            AssertFormatWithBaseIndent(expected, code, baseIndentation: 3);
+            await AssertFormatWithBaseIndentAsync(expected, code, baseIndentation: 3);
         }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/Formatting/Indentation/FormatterTestsBase.cs b/src/EditorFeatures/CSharpTest/Formatting/Indentation/FormatterTestsBase.cs
index d8ba3176a1adfc98936d6ddc5cc69899850a72ac..0b9b2baa5261d4c996188895eb7fc6f814f42a7e 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/Indentation/FormatterTestsBase.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/Indentation/FormatterTestsBase.cs
@@ -94,7 +94,7 @@ private static void ApplyChanges(ITextBuffer buffer, IList<TextChange> changes)
             }
         }
 
-        protected Task<int> GetSmartTokenFormatterIndentationAsync(
+        protected async Task<int> GetSmartTokenFormatterIndentationAsync(
             string code,
             int indentationLine,
             char ch,
@@ -102,7 +102,7 @@ private static void ApplyChanges(ITextBuffer buffer, IList<TextChange> changes)
             TextSpan span = default(TextSpan))
         {
             // create tree service
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(code))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code))
             {
                 if (baseIndentation.HasValue)
                 {
@@ -114,7 +114,7 @@ private static void ApplyChanges(ITextBuffer buffer, IList<TextChange> changes)
                 }
 
                 var buffer = workspace.Documents.First().GetTextBuffer();
-                return GetSmartTokenFormatterIndentationWorkerAsync(workspace, buffer, indentationLine, ch);
+                return await GetSmartTokenFormatterIndentationWorkerAsync(workspace, buffer, indentationLine, ch);
             }
         }
 
diff --git a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs
index 7e4d99bf3c2b54e9830d7c0bc246d44026bd2736..136c92343ca399133ce00d78c4301821791e6afc 100644
--- a/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs
+++ b/src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
@@ -34,17 +35,17 @@ public class SmartTokenFormatterFormatRangeTests
     {
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void BeginningOfFile()
+        public async Task BeginningOfFile()
         {
             var code = @"        using System;$$";
             var expected = @"        using System;";
 
-            Assert.NotNull(Record.Exception(() => AutoFormatOnSemicolon(code, expected, SyntaxKind.None)));
+            Assert.NotNull(await Record.ExceptionAsync(async () => await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.None)));
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Namespace1()
+        public async Task Namespace1()
         {
             var code = @"using System;
 namespace NS
@@ -58,12 +59,12 @@ namespace NS
 
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Namespace2()
+        public async Task Namespace2()
         {
             var code = @"using System;
 namespace NS
@@ -81,12 +82,12 @@ class Class
     }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Namespace3()
+        public async Task Namespace3()
         {
             var code = @"using System;
 namespace NS { }$$";
@@ -94,12 +95,12 @@ namespace NS { }$$";
             var expected = @"using System;
 namespace NS { }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Namespace4()
+        public async Task Namespace4()
         {
             var code = @"using System;
 namespace NS { 
@@ -110,12 +111,12 @@ namespace NS
 {
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Namespace5()
+        public async Task Namespace5()
         {
             var code = @"using System;
 namespace NS
@@ -129,12 +130,12 @@ namespace NS
     class Class { }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Namespace6()
+        public async Task Namespace6()
         {
             var code = @"using System;
 namespace NS
@@ -151,12 +152,12 @@ class Class
     }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Namespace7()
+        public async Task Namespace7()
         {
             var code = @"using System;
 namespace NS
@@ -177,12 +178,12 @@ namespace NS2
     { }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Namespace8()
+        public async Task Namespace8()
         {
             var code = @"using System;
 namespace NS { class Class { } namespace NS2 { } }$$";
@@ -190,12 +191,12 @@ namespace NS { class Class { } namespace NS2 { } }$$";
             var expected = @"using System;
 namespace NS { class Class { } namespace NS2 { } }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Class1()
+        public async Task Class1()
         {
             var code = @"using System;
     class Class { 
@@ -206,12 +207,12 @@ class Class
 {
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Class2()
+        public async Task Class2()
         {
             var code = @"using System;
     class Class
@@ -228,12 +229,12 @@ void Method(int i)
     }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Class3()
+        public async Task Class3()
         {
             var code = @"using System;
     class Class
@@ -247,12 +248,12 @@ class Class
     void Method(int i) { }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Class4()
+        public async Task Class4()
         {
             var code = @"using System;
     class Class
@@ -266,12 +267,12 @@ class Class
     delegate void Test(int i);
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Class5()
+        public async Task Class5()
         {
             var code = @"using System;
     class Class
@@ -291,12 +292,12 @@ void Method()
     }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Interface1()
+        public async Task Interface1()
         {
             var code = @"using System;
     interface II
@@ -312,12 +313,12 @@ interface II
     int Prop { get; set; }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Struct1()
+        public async Task Struct1()
         {
             var code = @"using System;
     struct Struct
@@ -335,12 +336,12 @@ struct Struct
     }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Enum1()
+        public async Task Enum1()
         {
             var code = @"using System;
     enum Enum
@@ -356,12 +357,12 @@ enum Enum
     C = 3
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void AccessorList1()
+        public async Task AccessorList1()
         {
             var code = @"using System;
 class Class
@@ -373,12 +374,12 @@ class Class
 {
     int Prop { get { return 1; }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void AccessorList2()
+        public async Task AccessorList2()
         {
             var code = @"using System;
 class Class
@@ -390,12 +391,12 @@ class Class
 {
     int Prop { get { return 1; } }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.IntKeyword);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.IntKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void AccessorList3()
+        public async Task AccessorList3()
         {
             var code = @"using System;
 class Class
@@ -411,12 +412,12 @@ int Prop
         get { return 1; }
     }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.IntKeyword);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.IntKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void AccessorList4()
+        public async Task AccessorList4()
         {
             var code = @"using System;
 class Class
@@ -432,12 +433,12 @@ class Class
             return 1;
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.GetKeyword);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.GetKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void AccessorList5()
+        public async Task AccessorList5()
         {
             var code = @"using System;
 class Class
@@ -455,12 +456,12 @@ class Class
             return 1;
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.GetKeyword);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.GetKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void AccessorList6()
+        public async Task AccessorList6()
         {
             var code = @"using System;
 class Class
@@ -481,12 +482,12 @@ int Prop
         }
     }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.IntKeyword);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.IntKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void AccessorList7()
+        public async Task AccessorList7()
         {
             var code = @"using System;
 class Class
@@ -510,12 +511,12 @@ int Prop
         }
     }";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Block1()
+        public async Task Block1()
         {
             var code = @"using System;
 class Class
@@ -529,12 +530,12 @@ class Class
     public int Method()
     { }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Block2()
+        public async Task Block2()
         {
             var code = @"using System;
 class Class
@@ -546,12 +547,12 @@ class Class
 {
     public int Method() { }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Block3()
+        public async Task Block3()
         {
             var code = @"using System;
 class Class
@@ -568,12 +569,12 @@ public int Method()
     }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Block4()
+        public async Task Block4()
         {
             var code = @"using System;
 class Class
@@ -590,12 +591,12 @@ class Class
     }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Block5()
+        public async Task Block5()
         {
             var code = @"using System;
 class Class
@@ -611,12 +612,12 @@ void Method()
     {
         { }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Block6()
+        public async Task Block6()
         {
             var code = @"using System;
 class Class
@@ -634,12 +635,12 @@ void Method()
         {
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Block7()
+        public async Task Block7()
         {
             var code = @"using System;
 class Class
@@ -655,12 +656,12 @@ void Method()
     {
         { { }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Block8()
+        public async Task Block8()
         {
             var code = @"using System;
 class Class
@@ -681,12 +682,12 @@ void Method()
             }
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void SwitchStatement1()
+        public async Task SwitchStatement1()
         {
             var code = @"using System;
 class Class
@@ -713,12 +714,12 @@ void Method()
     }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void SwitchStatement2()
+        public async Task SwitchStatement2()
         {
             var code = @"using System;
 class Class
@@ -734,12 +735,12 @@ void Method()
     {
         switch (true) { }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void SwitchStatement3()
+        public async Task SwitchStatement3()
         {
             var code = @"using System;
 class Class
@@ -759,12 +760,12 @@ void Method()
         {
             case 1: { }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.ColonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.ColonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void SwitchStatement4()
+        public async Task SwitchStatement4()
         {
             var code = @"using System;
 class Class
@@ -787,12 +788,12 @@ void Method()
                 {
                 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.ColonToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.ColonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Initializer1()
+        public async Task Initializer1()
         {
             var code = @"using System;
 class Class
@@ -808,12 +809,12 @@ void Method()
     {
         var arr = new int[] { }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.NewKeyword);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.NewKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Initializer2()
+        public async Task Initializer2()
         {
             var code = @"using System;
 class Class
@@ -831,12 +832,12 @@ void Method()
         var arr = new int[] {
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.NewKeyword);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.NewKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Initializer3()
+        public async Task Initializer3()
         {
             var code = @"using System;
 class Class
@@ -857,12 +858,12 @@ void Method()
             B = 2
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.NewKeyword);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.NewKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Initializer4()
+        public async Task Initializer4()
         {
             var code = @"using System;
 class Class
@@ -878,12 +879,12 @@ void Method()
     {
         var arr = new { A = 1, B = 2 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.NewKeyword);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.NewKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Initializer5()
+        public async Task Initializer5()
         {
             var code = @"using System;
 class Class
@@ -903,12 +904,12 @@ void Method()
             1, 2, 3, 4,
             5 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.NewKeyword);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.NewKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Initializer6()
+        public async Task Initializer6()
         {
             var code = @"using System;
 class Class
@@ -928,12 +929,12 @@ void Method()
             1, 2, 3, 4,
             5 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.NewKeyword);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.NewKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement1()
+        public async Task EmbeddedStatement1()
         {
             var code = @"using System;
 class Class
@@ -949,12 +950,12 @@ void Method()
     {
         if (true) { }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement2()
+        public async Task EmbeddedStatement2()
         {
             var code = @"using System;
 class Class
@@ -975,12 +976,12 @@ void Method()
         }
     }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement3()
+        public async Task EmbeddedStatement3()
         {
             var code = @"using System;
 class Class
@@ -998,12 +999,12 @@ void Method()
         if (true)
         { }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement4()
+        public async Task EmbeddedStatement4()
         {
             var code = @"using System;
 class Class
@@ -1024,12 +1025,12 @@ void Method()
         }
     }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement5()
+        public async Task EmbeddedStatement5()
         {
             var code = @"using System;
 class Class
@@ -1052,12 +1053,12 @@ void Method()
     }
 }";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement6()
+        public async Task EmbeddedStatement6()
         {
             var code = @"using System;
 class Class
@@ -1078,12 +1079,12 @@ void Method()
         }
     }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement7()
+        public async Task EmbeddedStatement7()
         {
             var code = @"using System;
 class Class
@@ -1104,12 +1105,12 @@ void Method()
         }
     }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement8()
+        public async Task EmbeddedStatement8()
         {
             var code = @"using System;
 class Class
@@ -1130,12 +1131,12 @@ void Method()
         }
     }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement9()
+        public async Task EmbeddedStatement9()
         {
             var code = @"using System;
 class Class
@@ -1153,12 +1154,12 @@ void Method()
         if (true)
             int i = 10;";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void FieldlInitializer()
+        public async Task FieldlInitializer()
         {
             var code = @"using System;
 class Class
@@ -1172,12 +1173,12 @@ class Class
     string str = Console.Title;
 ";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void ArrayFieldlInitializer()
+        public async Task ArrayFieldlInitializer()
         {
             var code = @"using System;
 namespace NS
@@ -1195,12 +1196,12 @@ class Class
         string[] strArr = { ""1"", ""2"" };
 ";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void ExpressionValuedPropertyInitializer()
+        public async Task ExpressionValuedPropertyInitializer()
         {
             var code = @"using System;
 class Class
@@ -1214,12 +1215,12 @@ class Class
     public int Three => 1 + 2;
 ";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement10()
+        public async Task EmbeddedStatement10()
         {
             var code = @"using System;
 class Class
@@ -1239,12 +1240,12 @@ void Method()
             int i = 10;
     }";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement11()
+        public async Task EmbeddedStatement11()
         {
             var code = @"using System;
 class Class
@@ -1260,12 +1261,12 @@ void Method()
     {
         using (var resource = GetResource()) resource.Do();";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement12()
+        public async Task EmbeddedStatement12()
         {
             var code = @"using System;
 class Class
@@ -1283,12 +1284,12 @@ void Method()
         using (var resource = GetResource())
             resource.Do();";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement13()
+        public async Task EmbeddedStatement13()
         {
             var code = @"using System;
 class Class
@@ -1308,12 +1309,12 @@ void Method()
             resource.Do();
     }";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement14()
+        public async Task EmbeddedStatement14()
         {
             var code = @"using System;
 class Class
@@ -1329,12 +1330,12 @@ void Method()
     {
         do i = 10;";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement15()
+        public async Task EmbeddedStatement15()
         {
             var code = @"using System;
 class Class
@@ -1352,12 +1353,12 @@ void Method()
         do
             i = 10;";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement16()
+        public async Task EmbeddedStatement16()
         {
             var code = @"using System;
 class Class
@@ -1377,12 +1378,12 @@ void Method()
             i = 10;
     }";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void EmbeddedStatement17()
+        public async Task EmbeddedStatement17()
         {
             var code = @"using System;
 class Class
@@ -1404,12 +1405,12 @@ void Method()
         while (true);
     }";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void FollowPreviousElement1()
+        public async Task FollowPreviousElement1()
         {
             var code = @"using System;
 class Class
@@ -1423,12 +1424,12 @@ class Class
                     int i = 10;
     int i2 = 10;";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void FollowPreviousElement2()
+        public async Task FollowPreviousElement2()
         {
             var code = @"using System;
 class Class
@@ -1454,12 +1455,12 @@ void Method2()
     }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.CloseBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.CloseBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void FollowPreviousElement3()
+        public async Task FollowPreviousElement3()
         {
             var code = @"using System;
 class Class
@@ -1489,12 +1490,12 @@ void Method(int i)
     };
 }";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.CloseBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.CloseBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void FollowPreviousElement4()
+        public async Task FollowPreviousElement4()
         {
             var code = @"using System;
 class Class
@@ -1512,12 +1513,12 @@ void Method(int i)
                         int i = 10;
         int i2 = 10;";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void FollowPreviousElement5()
+        public async Task FollowPreviousElement5()
         {
             var code = @"using System;
 class Class
@@ -1537,12 +1538,12 @@ void Method(int i)
         if (true)
             i = 50;";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void FollowPreviousElement6()
+        public async Task FollowPreviousElement6()
         {
             var code = @"        using System;
         using System.Linq;$$";
@@ -1550,12 +1551,12 @@ public void FollowPreviousElement6()
             var expected = @"        using System;
 using System.Linq;";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void FollowPreviousElement7()
+        public async Task FollowPreviousElement7()
         {
             var code = @"            using System;
 
@@ -1577,12 +1578,12 @@ namespace NS2
 {
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.CloseBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.CloseBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void FollowPreviousElement8()
+        public async Task FollowPreviousElement8()
         {
             var code = @"using System;
 
@@ -1610,12 +1611,12 @@ class Class1
     }
 }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.CloseBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.CloseBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void IfStatement1()
+        public async Task IfStatement1()
         {
             var code = @"using System;
 
@@ -1637,12 +1638,12 @@ void Method()
         {
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void IfStatement2()
+        public async Task IfStatement2()
         {
             var code = @"using System;
 
@@ -1670,12 +1671,12 @@ void Method()
         {
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void IfStatement3()
+        public async Task IfStatement3()
         {
             var code = @"using System;
 
@@ -1703,12 +1704,12 @@ void Method()
         {
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void IfStatement4()
+        public async Task IfStatement4()
         {
             var code = @"using System;
 
@@ -1732,12 +1733,12 @@ void Method()
         else if (false)
             return;";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void TryStatement1()
+        public async Task TryStatement1()
         {
             var code = @"using System;
 
@@ -1759,12 +1760,12 @@ void Method()
         {
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void TryStatement2()
+        public async Task TryStatement2()
         {
             var code = @"using System;
 
@@ -1792,12 +1793,12 @@ void Method()
         {
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void TryStatement3()
+        public async Task TryStatement3()
         {
             var code = @"using System;
 
@@ -1831,12 +1832,12 @@ void Method()
         {
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void TryStatement4()
+        public async Task TryStatement4()
         {
             var code = @"using System;
 
@@ -1864,73 +1865,73 @@ void Method()
         {
         }";
 
-            AutoFormatOnCloseBrace(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnCloseBraceAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
         [WorkItem(537555)]
-        public void SingleLine()
+        public async Task SingleLine()
         {
             var code = @"class C { void M() { C.M(    );$$ } }";
 
             var expected = @"class C { void M() { C.M(); } }";
 
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void StringLiterals()
+        public async Task StringLiterals()
         {
             var code = @"class C { void M() { C.M(""Test {0}$$";
 
             var expected = string.Empty;
-            AutoFormatOnMarker(code, expected, SyntaxKind.StringLiteralToken, SyntaxKind.None);
+            await AutoFormatOnMarkerAsync(code, expected, SyntaxKind.StringLiteralToken, SyntaxKind.None);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void CharLiterals()
+        public async Task CharLiterals()
         {
             var code = @"class C { void M() { C.M('}$$";
 
             var expected = string.Empty;
-            AutoFormatOnMarker(code, expected, SyntaxKind.CharacterLiteralToken, SyntaxKind.None);
+            await AutoFormatOnMarkerAsync(code, expected, SyntaxKind.CharacterLiteralToken, SyntaxKind.None);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void CharLiterals1()
+        public async Task CharLiterals1()
         {
             var code = @"''';$$";
 
             var expected = string.Empty;
-            AutoFormatOnMarker(code, expected, SyntaxKind.EndOfFileToken, SyntaxKind.None);
+            await AutoFormatOnMarkerAsync(code, expected, SyntaxKind.EndOfFileToken, SyntaxKind.None);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Comments()
+        public async Task Comments()
         {
             var code = @"class C { void M() { // { }$$";
 
             var expected = string.Empty;
-            AutoFormatOnMarker(code, expected, SyntaxKind.OpenBraceToken, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnMarkerAsync(code, expected, SyntaxKind.OpenBraceToken, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void FirstLineInFile()
+        public async Task FirstLineInFile()
         {
             var code = @"using System;$$";
 
-            AutoFormatOnSemicolon(code, "using System;", SyntaxKind.UsingKeyword);
+            await AutoFormatOnSemicolonAsync(code, "using System;", SyntaxKind.UsingKeyword);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Label1()
+        public async Task Label1()
         {
             var code = @"class C
 {
@@ -1946,12 +1947,12 @@ void Method()
     L: int i = 20;
     }
 }";
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Label2()
+        public async Task Label2()
         {
             var code = @"class C
 {
@@ -1969,12 +1970,12 @@ void Method()
         int i = 20;
     }
 }";
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Label3()
+        public async Task Label3()
         {
             var code = @"class C
 {
@@ -1994,12 +1995,12 @@ void Method()
         int i = 20;
     }
 }";
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Label4()
+        public async Task Label4()
         {
             var code = @"class C
 {
@@ -2021,12 +2022,12 @@ void Method()
         int nextLine = 30;
     }
 }";
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.SemicolonToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.SemicolonToken);
         }
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Label6()
+        public async Task Label6()
         {
             var code = @"class C
 {
@@ -2046,13 +2047,13 @@ void Method()
         int nextLine = 30;
     }
 }";
-            AutoFormatOnSemicolon(code, expected, SyntaxKind.OpenBraceToken);
+            await AutoFormatOnSemicolonAsync(code, expected, SyntaxKind.OpenBraceToken);
         }
 
         [WorkItem(537776)]
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void DisappearedTokens()
+        public async Task DisappearedTokens()
         {
             var code = @"class Class1
 {
@@ -2067,7 +2068,7 @@ int foo()
         return 0;
         }
 }";
-            AutoFormatOnCloseBrace(
+            await AutoFormatOnCloseBraceAsync(
                 code,
                 expected,
                 SyntaxKind.ClassKeyword);
@@ -2076,7 +2077,7 @@ int foo()
         [WorkItem(537779)]
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void DisappearedTokens2()
+        public async Task DisappearedTokens2()
         {
             var code = @"class Class1
 {
@@ -2093,7 +2094,7 @@ void Foo()
         Object o=new Object);
     }
 }";
-            AutoFormatOnSemicolon(
+            await AutoFormatOnSemicolonAsync(
                 code,
                 expected,
                 SyntaxKind.SemicolonToken);
@@ -2102,13 +2103,13 @@ void Foo()
         [WorkItem(537793)]
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Delegate1()
+        public async Task Delegate1()
         {
             var code = @"delegate void MyDelegate(int a,int b);$$";
 
             var expected = @"delegate void MyDelegate(int a, int b);";
 
-            AutoFormatOnSemicolon(
+            await AutoFormatOnSemicolonAsync(
                 code,
                 expected,
                 SyntaxKind.DelegateKeyword);
@@ -2117,7 +2118,7 @@ public void Delegate1()
         [WorkItem(537827)]
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void DoubleInitializer()
+        public async Task DoubleInitializer()
         {
             var code = @"class C
 {
@@ -2135,7 +2136,7 @@ void Method()
     }
 }";
 
-            AutoFormatOnCloseBrace(
+            await AutoFormatOnCloseBraceAsync(
                 code,
                 expected,
                 SyntaxKind.OpenBraceToken);
@@ -2144,7 +2145,7 @@ void Method()
         [WorkItem(537825)]
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void MissingToken1()
+        public async Task MissingToken1()
         {
             var code = @"public class Class1
 {
@@ -2156,7 +2157,7 @@ public void MissingToken1()
     int a = 1};
 }";
 
-            AutoFormatOnCloseBrace(
+            await AutoFormatOnCloseBraceAsync(
                 code,
                 expected,
                 SyntaxKind.PublicKeyword);
@@ -2164,7 +2165,7 @@ public void MissingToken1()
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void ArrayInitializer1()
+        public async Task ArrayInitializer1()
         {
             var code = @"public class Class1
 {
@@ -2182,7 +2183,7 @@ public void ArrayInitializer1()
         }
 }";
 
-            AutoFormatOnCloseBrace(
+            await AutoFormatOnCloseBraceAsync(
                 code,
                 expected,
                 SyntaxKind.NewKeyword);
@@ -2190,7 +2191,7 @@ public void ArrayInitializer1()
 
         [WpfFact]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void ArrayInitializer2()
+        public async Task ArrayInitializer2()
         {
             var code = @"public class Class1
 {
@@ -2208,7 +2209,7 @@ public void ArrayInitializer2()
         };
 }";
 
-            AutoFormatOnSemicolon(
+            await AutoFormatOnSemicolonAsync(
                 code,
                 expected,
                 SyntaxKind.OpenBraceToken);
@@ -2217,7 +2218,7 @@ public void ArrayInitializer2()
         [WpfFact]
         [WorkItem(537825)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void MalformedCode()
+        public async Task MalformedCode()
         {
             var code = @"namespace ClassLibrary1
 {
@@ -2235,7 +2236,7 @@ public class Class1
     }
 }";
 
-            AutoFormatOnCloseBrace(
+            await AutoFormatOnCloseBraceAsync(
                 code,
                 expected,
                 SyntaxKind.OpenBraceToken);
@@ -2244,7 +2245,7 @@ public class Class1
         [WpfFact]
         [WorkItem(537804)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Colon_SwitchLabel()
+        public async Task Colon_SwitchLabel()
         {
             var code = @"namespace ClassLibrary1
 {
@@ -2274,7 +2275,7 @@ void Test()
     }
 }";
 
-            AutoFormatOnColon(
+            await AutoFormatOnColonAsync(
                 code,
                 expected,
                 SyntaxKind.OpenBraceToken);
@@ -2283,7 +2284,7 @@ void Test()
         [WpfFact]
         [WorkItem(584599)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Colon_SwitchLabel_Comment()
+        public async Task Colon_SwitchLabel_Comment()
         {
             var code = @"namespace ClassLibrary1
 {
@@ -2315,7 +2316,7 @@ void Test()
     }
 }";
 
-            AutoFormatOnColon(
+            await AutoFormatOnColonAsync(
                 code,
                 expected,
                 SyntaxKind.OpenBraceToken);
@@ -2324,7 +2325,7 @@ void Test()
         [WpfFact]
         [WorkItem(584599)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Colon_SwitchLabel_Comment2()
+        public async Task Colon_SwitchLabel_Comment2()
         {
             var code = @"namespace ClassLibrary1
 {
@@ -2358,7 +2359,7 @@ void Test()
     }
 }";
 
-            AutoFormatOnColon(
+            await AutoFormatOnColonAsync(
                 code,
                 expected,
                 SyntaxKind.ColonToken);
@@ -2367,7 +2368,7 @@ void Test()
         [WpfFact]
         [WorkItem(537804)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Colon_Label()
+        public async Task Colon_Label()
         {
             var code = @"namespace ClassLibrary1
 {
@@ -2391,7 +2392,7 @@ void Test()
     }
 }";
 
-            AutoFormatOnColon(
+            await AutoFormatOnColonAsync(
                 code,
                 expected,
                 SyntaxKind.None);
@@ -2400,7 +2401,7 @@ void Test()
         [WpfFact]
         [WorkItem(538793)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void Colon_Label2()
+        public async Task Colon_Label2()
         {
             var code = @"namespace ClassLibrary1
 {
@@ -2424,7 +2425,7 @@ void Test()
     }
 }";
 
-            AutoFormatOnSemicolon(
+            await AutoFormatOnSemicolonAsync(
                 code,
                 expected,
                 SyntaxKind.OpenBraceToken);
@@ -2433,7 +2434,7 @@ void Test()
         [WpfFact]
         [WorkItem(3186, "DevDiv_Projects/Roslyn")]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void SemicolonInElseIfStatement()
+        public async Task SemicolonInElseIfStatement()
         {
             var code = @"using System;
 using System.Collections.Generic;
@@ -2473,7 +2474,7 @@ static void Main(string[] args)
     }
 }";
 
-            AutoFormatOnSemicolon(
+            await AutoFormatOnSemicolonAsync(
                 code,
                 expected,
                 SyntaxKind.SemicolonToken);
@@ -2482,7 +2483,7 @@ static void Main(string[] args)
         [WpfFact]
         [WorkItem(538391)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void SemicolonInElseIfStatement2()
+        public async Task SemicolonInElseIfStatement2()
         {
             var code = @"public class Class1
 {
@@ -2508,7 +2509,7 @@ void Method()
     }
 }";
 
-            AutoFormatOnSemicolon(
+            await AutoFormatOnSemicolonAsync(
                 code,
                 expected,
                 SyntaxKind.SemicolonToken);
@@ -2517,7 +2518,7 @@ void Method()
         [WpfFact]
         [WorkItem(8385, "DevDiv_Projects/Roslyn")]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void NullCoalescingOperator()
+        public async Task NullCoalescingOperator()
         {
             var code = @"class C
 {
@@ -2535,7 +2536,7 @@ void M()
     }
 }";
 
-            AutoFormatOnSemicolon(
+            await AutoFormatOnSemicolonAsync(
                 code,
                 expected,
                 SyntaxKind.OpenBraceToken);
@@ -2544,7 +2545,7 @@ void M()
         [WpfFact]
         [WorkItem(541517)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void SwitchDefault()
+        public async Task SwitchDefault()
         {
             var code = @"using System;
 class Program
@@ -2580,7 +2581,7 @@ static void Main()
     }
 }";
 
-            AutoFormatOnColon(
+            await AutoFormatOnColonAsync(
                 code,
                 expected,
                 SyntaxKind.SemicolonToken);
@@ -2589,7 +2590,7 @@ static void Main()
         [WpfFact]
         [WorkItem(542538)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void MissingTokens1()
+        public async Task MissingTokens1()
         {
             var code = @"class Program
 {
@@ -2607,7 +2608,7 @@ static void Main(string[] args)
     }
 }";
 
-            AutoFormatOnMarker(
+            await AutoFormatOnMarkerAsync(
                 code,
                 expected,
                 SyntaxKind.ColonColonToken,
@@ -2617,13 +2618,13 @@ static void Main(string[] args)
         [WpfFact]
         [WorkItem(542538)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void MissingTokens2()
+        public async Task MissingTokens2()
         {
             var code = @"class C { void M() { M(() => { }$$ } }";
 
             var expected = @"class C { void M() { M(() => { } } }";
 
-            AutoFormatOnCloseBrace(
+            await AutoFormatOnCloseBraceAsync(
                 code,
                 expected,
                 SyntaxKind.EqualsGreaterThanToken);
@@ -2632,13 +2633,13 @@ public void MissingTokens2()
         [WpfFact]
         [WorkItem(542953)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void UsingAlias()
+        public async Task UsingAlias()
         {
             var code = @"using Alias=System;$$";
 
             var expected = @"using Alias = System;";
 
-            AutoFormatOnSemicolon(
+            await AutoFormatOnSemicolonAsync(
                 code,
                 expected,
                 SyntaxKind.UsingKeyword);
@@ -2647,7 +2648,7 @@ public void UsingAlias()
         [WpfFact]
         [WorkItem(542953)]
         [Trait(Traits.Feature, Traits.Features.SmartTokenFormatting)]
-        public void NoLineChangeWithSyntaxError()
+        public async Task NoLineChangeWithSyntaxError()
         {
             var code = @"struct Foo { public int member; }
 class Program{
@@ -2665,7 +2666,7 @@ void Main()
     }
 }";
 
-            AutoFormatOnSemicolon(
+            await AutoFormatOnSemicolonAsync(
                 code,
                 expected,
                 SyntaxKind.OpenBraceToken);
@@ -3055,24 +3056,24 @@ internal static void AutoFormatToken(string markup, string expected)
             return Tuple.Create(options, Formatter.GetDefaultFormattingRules(workspace, LanguageNames.CSharp));
         }
 
-        private void AutoFormatOnColon(string codeWithMarker, string expected, SyntaxKind startTokenKind)
+        private Task AutoFormatOnColonAsync(string codeWithMarker, string expected, SyntaxKind startTokenKind)
         {
-            AutoFormatOnMarker(codeWithMarker, expected, SyntaxKind.ColonToken, startTokenKind);
+            return AutoFormatOnMarkerAsync(codeWithMarker, expected, SyntaxKind.ColonToken, startTokenKind);
         }
 
-        private void AutoFormatOnSemicolon(string codeWithMarker, string expected, SyntaxKind startTokenKind)
+        private Task AutoFormatOnSemicolonAsync(string codeWithMarker, string expected, SyntaxKind startTokenKind)
         {
-            AutoFormatOnMarker(codeWithMarker, expected, SyntaxKind.SemicolonToken, startTokenKind);
+            return AutoFormatOnMarkerAsync(codeWithMarker, expected, SyntaxKind.SemicolonToken, startTokenKind);
         }
 
-        private void AutoFormatOnCloseBrace(string codeWithMarker, string expected, SyntaxKind startTokenKind)
+        private Task AutoFormatOnCloseBraceAsync(string codeWithMarker, string expected, SyntaxKind startTokenKind)
         {
-            AutoFormatOnMarker(codeWithMarker, expected, SyntaxKind.CloseBraceToken, startTokenKind);
+            return AutoFormatOnMarkerAsync(codeWithMarker, expected, SyntaxKind.CloseBraceToken, startTokenKind);
         }
 
-        private void AutoFormatOnMarker(string initialMarkup, string expected, SyntaxKind tokenKind, SyntaxKind startTokenKind)
+        private async Task AutoFormatOnMarkerAsync(string initialMarkup, string expected, SyntaxKind tokenKind, SyntaxKind startTokenKind)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(initialMarkup))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(initialMarkup))
             {
                 var tuple = GetService(workspace);
                 var testDocument = workspace.Documents.Single();
diff --git a/src/EditorFeatures/CSharpTest/Squiggles/ErrorSquiggleProducerTests.cs b/src/EditorFeatures/CSharpTest/Squiggles/ErrorSquiggleProducerTests.cs
index 892b008b281ff8db64b31a14f23f2b530abb2afd..e8b56e70ff7e5839abca1135b43d894277fede1c 100644
--- a/src/EditorFeatures/CSharpTest/Squiggles/ErrorSquiggleProducerTests.cs
+++ b/src/EditorFeatures/CSharpTest/Squiggles/ErrorSquiggleProducerTests.cs
@@ -156,7 +156,7 @@ public async Task SemanticErrorReported()
         [WpfFact, Trait(Traits.Feature, Traits.Features.ErrorSquiggles)]
         public async Task TestNoErrorsAfterDocumentRemoved()
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines("class"))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync("class"))
             using (var wrapper = new DiagnosticTaggerWrapper(workspace))
             {
                 var tagger = wrapper.TaggerProvider.CreateTagger<IErrorTag>(workspace.Documents.First().GetTextBuffer());
@@ -186,7 +186,7 @@ public async Task TestNoErrorsAfterDocumentRemoved()
         [WpfFact, Trait(Traits.Feature, Traits.Features.ErrorSquiggles)]
         public async Task TestNoErrorsAfterProjectRemoved()
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines("class"))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync("class"))
             using (var wrapper = new DiagnosticTaggerWrapper(workspace))
             {
                 var tagger = wrapper.TaggerProvider.CreateTagger<IErrorTag>(workspace.Documents.First().GetTextBuffer());
diff --git a/src/EditorFeatures/CSharpTest/TodoComment/TodoCommentTests.cs b/src/EditorFeatures/CSharpTest/TodoComment/TodoCommentTests.cs
index 92d0a767f9fb398144eff2459d9898b44e456805..38562916b349e756af0a0eb1642ce770d1fbb9cf 100644
--- a/src/EditorFeatures/CSharpTest/TodoComment/TodoCommentTests.cs
+++ b/src/EditorFeatures/CSharpTest/TodoComment/TodoCommentTests.cs
@@ -2,6 +2,7 @@
 
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Implementation.TodoComments;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.SolutionCrawler;
@@ -15,119 +16,119 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.TodoComment
     public class TodoCommentTests
     {
         [WpfFact]
-        public void SingleLineTodoComment_Colon()
+        public async Task SingleLineTodoComment_Colon()
         {
             var code = @"// [|TODO:test|]";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SingleLineTodoComment_Space()
+        public async Task SingleLineTodoComment_Space()
         {
             var code = @"// [|TODO test|]";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SingleLineTodoComment_Underscore()
+        public async Task SingleLineTodoComment_Underscore()
         {
             var code = @"// TODO_test";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SingleLineTodoComment_Number()
+        public async Task SingleLineTodoComment_Number()
         {
             var code = @"// TODO1 test";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SingleLineTodoComment_Quote()
+        public async Task SingleLineTodoComment_Quote()
         {
             var code = @"// ""TODO test""";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SingleLineTodoComment_Middle()
+        public async Task SingleLineTodoComment_Middle()
         {
             var code = @"// Hello TODO test";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SingleLineTodoComment_Document()
+        public async Task SingleLineTodoComment_Document()
         {
             var code = @"///    [|TODO test|]";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SingleLineTodoComment_Preprocessor1()
+        public async Task SingleLineTodoComment_Preprocessor1()
         {
             var code = @"#if DEBUG // [|TODO test|]";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SingleLineTodoComment_Preprocessor2()
+        public async Task SingleLineTodoComment_Preprocessor2()
         {
             var code = @"#if DEBUG ///    [|TODO test|]";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SingleLineTodoComment_Region()
+        public async Task SingleLineTodoComment_Region()
         {
             var code = @"#region // TODO test";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SingleLineTodoComment_EndRegion()
+        public async Task SingleLineTodoComment_EndRegion()
         {
             var code = @"#endregion // [|TODO test|]";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SingleLineTodoComment_TrailingSpan()
+        public async Task SingleLineTodoComment_TrailingSpan()
         {
             var code = @"// [|TODO test                        |]";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void MultilineTodoComment_Singleline()
+        public async Task MultilineTodoComment_Singleline()
         {
             var code = @"/* [|TODO: hello    |]*/";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void MultilineTodoComment_Singleline_Document()
+        public async Task MultilineTodoComment_Singleline_Document()
         {
             var code = @"/** [|TODO: hello    |]*/";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void MultilineTodoComment_Multiline()
+        public async Task MultilineTodoComment_Multiline()
         {
             var code = @"
 /* [|TODO: hello    |]
@@ -136,11 +137,11 @@ public void MultilineTodoComment_Multiline()
     * [|TODO: hello    |]
     [|TODO: hello    |]*/";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void MultilineTodoComment_Multiline_DocComment()
+        public async Task MultilineTodoComment_Multiline_DocComment()
         {
             var code = @"
 /** [|TODO: hello    |]
@@ -149,11 +150,11 @@ public void MultilineTodoComment_Multiline_DocComment()
     * [|TODO: hello    |]
     [|TODO: hello    |]*/";
 
-            Test(code);
+            await TestAsync(code);
         }
 
         [WpfFact]
-        public void SinglelineDocumentComment_Multiline()
+        public async Task SinglelineDocumentComment_Multiline()
         {
             var code = @"
         /// <summary>
@@ -161,12 +162,12 @@ public void SinglelineDocumentComment_Multiline()
         /// </summary>
         ///         [|UNDONE: test2             |]";
 
-            Test(code);
+            await TestAsync(code);
         }
 
-        private static void Test(string codeWithMarker)
+        private static async Task TestAsync(string codeWithMarker)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(codeWithMarker))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(codeWithMarker))
             {
                 var commentTokens = new TodoCommentTokens();
                 var provider = new TodoCommentIncrementalAnalyzerProvider(commentTokens);
diff --git a/src/EditorFeatures/Test/BraceMatching/AbstractBraceMatcherTests.cs b/src/EditorFeatures/Test/BraceMatching/AbstractBraceMatcherTests.cs
index e61e1383be2203017e4f865e4a966db7cd036235..fe81306e57b0a471ff4aed5d606df86120aeb41b 100644
--- a/src/EditorFeatures/Test/BraceMatching/AbstractBraceMatcherTests.cs
+++ b/src/EditorFeatures/Test/BraceMatching/AbstractBraceMatcherTests.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
@@ -20,11 +21,11 @@ private Document GetDocument(TestWorkspace workspace)
             return workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id);
         }
 
-        protected abstract TestWorkspace CreateWorkspaceFromCode(string code);
+        protected abstract Task<TestWorkspace> CreateWorkspaceFromCodeAsync(string code);
 
-        protected void Test(string markup, string expectedCode)
+        protected async Task TestAsync(string markup, string expectedCode)
         {
-            using (var workspace = CreateWorkspaceFromCode(markup))
+            using (var workspace = await CreateWorkspaceFromCodeAsync(markup))
             {
                 var position = workspace.Documents.Single().CursorPosition.Value;
                 var document = GetDocument(workspace);
diff --git a/src/EditorFeatures/Test/DocumentationComments/AbstractDocumentationCommentTests.cs b/src/EditorFeatures/Test/DocumentationComments/AbstractDocumentationCommentTests.cs
index 4423e6e9886a0c20a3828c6dae0b78b85380ef2a..c627d1b70599f3b6d8c9bddf1e5d107f6bcc3548 100644
--- a/src/EditorFeatures/Test/DocumentationComments/AbstractDocumentationCommentTests.cs
+++ b/src/EditorFeatures/Test/DocumentationComments/AbstractDocumentationCommentTests.cs
@@ -2,6 +2,7 @@
 
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Commands;
 using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
@@ -22,11 +23,11 @@ public abstract class AbstractDocumentationCommentTests
         protected abstract char DocumentationCommentCharacter { get; }
 
         internal abstract ICommandHandler CreateCommandHandler(IWaitIndicator waitIndicator, ITextUndoHistoryRegistry undoHistoryRegistry, IEditorOperationsFactoryService editorOperationsFactoryService, IAsyncCompletionService completionService);
-        protected abstract TestWorkspace CreateTestWorkspace(string code);
+        protected abstract Task<TestWorkspace> CreateTestWorkspaceAsync(string code);
 
-        protected void VerifyTypingCharacter(string initialMarkup, string expectedMarkup, bool useTabs = false, bool autoGenerateXmlDocComments = true)
+        protected async Task VerifyTypingCharacterAsync(string initialMarkup, string expectedMarkup, bool useTabs = false, bool autoGenerateXmlDocComments = true)
         {
-            Verify(initialMarkup, expectedMarkup, useTabs, autoGenerateXmlDocComments,
+            await VerifyAsync(initialMarkup, expectedMarkup, useTabs, autoGenerateXmlDocComments,
                 execute: (view, undoHistoryRegistry, editorOperationsFactoryService, completionService) =>
                 {
                     var commandHandler = CreateCommandHandler(TestWaitIndicator.Default, undoHistoryRegistry, editorOperationsFactoryService, completionService) as ICommandHandler<TypeCharCommandArgs>;
@@ -38,9 +39,9 @@ protected void VerifyTypingCharacter(string initialMarkup, string expectedMarkup
                 });
         }
 
-        protected void VerifyPressingEnter(string initialMarkup, string expectedMarkup, bool useTabs = false, bool autoGenerateXmlDocComments = true)
+        protected async Task VerifyPressingEnterAsync(string initialMarkup, string expectedMarkup, bool useTabs = false, bool autoGenerateXmlDocComments = true)
         {
-            Verify(initialMarkup, expectedMarkup, useTabs, autoGenerateXmlDocComments,
+            await VerifyAsync(initialMarkup, expectedMarkup, useTabs, autoGenerateXmlDocComments,
                 execute: (view, undoHistoryRegistry, editorOperationsFactoryService, completionService) =>
                 {
                     var commandHandler = CreateCommandHandler(TestWaitIndicator.Default, undoHistoryRegistry, editorOperationsFactoryService, completionService) as ICommandHandler<ReturnKeyCommandArgs>;
@@ -52,9 +53,9 @@ protected void VerifyPressingEnter(string initialMarkup, string expectedMarkup,
                 });
         }
 
-        protected void VerifyInsertCommentCommand(string initialMarkup, string expectedMarkup, bool useTabs = false, bool autoGenerateXmlDocComments = true)
+        protected async Task VerifyInsertCommentCommandAsync(string initialMarkup, string expectedMarkup, bool useTabs = false, bool autoGenerateXmlDocComments = true)
         {
-            Verify(initialMarkup, expectedMarkup, useTabs, autoGenerateXmlDocComments,
+            await VerifyAsync(initialMarkup, expectedMarkup, useTabs, autoGenerateXmlDocComments,
                 execute: (view, undoHistoryRegistry, editorOperationsFactoryService, completionService) =>
                 {
                     var commandHandler = CreateCommandHandler(TestWaitIndicator.Default, undoHistoryRegistry, editorOperationsFactoryService, completionService) as ICommandHandler<InsertCommentCommandArgs>;
@@ -66,9 +67,9 @@ protected void VerifyInsertCommentCommand(string initialMarkup, string expectedM
                 });
         }
 
-        protected void VerifyOpenLineAbove(string initialMarkup, string expectedMarkup, bool useTabs = false, bool autoGenerateXmlDocComments = true)
+        protected async Task VerifyOpenLineAboveAsync(string initialMarkup, string expectedMarkup, bool useTabs = false, bool autoGenerateXmlDocComments = true)
         {
-            Verify(initialMarkup, expectedMarkup, useTabs, autoGenerateXmlDocComments,
+            await VerifyAsync(initialMarkup, expectedMarkup, useTabs, autoGenerateXmlDocComments,
                 execute: (view, undoHistoryRegistry, editorOperationsFactoryService, completionService) =>
                 {
                     var commandHandler = CreateCommandHandler(TestWaitIndicator.Default, undoHistoryRegistry, editorOperationsFactoryService, completionService) as ICommandHandler<OpenLineAboveCommandArgs>;
@@ -84,9 +85,9 @@ protected void VerifyOpenLineAbove(string initialMarkup, string expectedMarkup,
                 });
         }
 
-        protected void VerifyOpenLineBelow(string initialMarkup, string expectedMarkup, bool useTabs = false, bool autoGenerateXmlDocComments = true)
+        protected async Task VerifyOpenLineBelowAsync(string initialMarkup, string expectedMarkup, bool useTabs = false, bool autoGenerateXmlDocComments = true)
         {
-            Verify(initialMarkup, expectedMarkup, useTabs, autoGenerateXmlDocComments,
+            await VerifyAsync(initialMarkup, expectedMarkup, useTabs, autoGenerateXmlDocComments,
                 execute: (view, undoHistoryRegistry, editorOperationsFactoryService, completionService) =>
                 {
                     var commandHandler = CreateCommandHandler(TestWaitIndicator.Default, undoHistoryRegistry, editorOperationsFactoryService, completionService) as ICommandHandler<OpenLineBelowCommandArgs>;
@@ -112,10 +113,10 @@ private Action CreateInsertTextHandler(ITextView textView, string text)
             };
         }
 
-        private void Verify(string initialMarkup, string expectedMarkup, bool useTabs, bool autoGenerateXmlDocComments,
+        private async Task VerifyAsync(string initialMarkup, string expectedMarkup, bool useTabs, bool autoGenerateXmlDocComments,
             Action<IWpfTextView, ITextUndoHistoryRegistry, IEditorOperationsFactoryService, IAsyncCompletionService> execute)
         {
-            using (var workspace = CreateTestWorkspace(initialMarkup))
+            using (var workspace = await CreateTestWorkspaceAsync(initialMarkup))
             {
                 var testDocument = workspace.Documents.Single();
 
diff --git a/src/EditorFeatures/Test/DocumentationComments/AbstractXmlTagCompletionTests.cs b/src/EditorFeatures/Test/DocumentationComments/AbstractXmlTagCompletionTests.cs
index a7ca0a04c8902200d8a15744df07acfde406dadd..8dc709858b0e844ef0a21abee0817880c212cdcb 100644
--- a/src/EditorFeatures/Test/DocumentationComments/AbstractXmlTagCompletionTests.cs
+++ b/src/EditorFeatures/Test/DocumentationComments/AbstractXmlTagCompletionTests.cs
@@ -2,6 +2,7 @@
 
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Commands;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.VisualStudio.Text;
@@ -15,11 +16,11 @@ namespace Microsoft.CodeAnalysis.Editor.UnitTests.DocumentationComments
     public abstract class AbstractXmlTagCompletionTests
     {
         internal abstract ICommandHandler<TypeCharCommandArgs> CreateCommandHandler(ITextUndoHistoryRegistry undoHistory);
-        protected abstract TestWorkspace CreateTestWorkspace(string initialMarkup);
+        protected abstract Task<TestWorkspace> CreateTestWorkspaceAsync(string initialMarkup);
 
-        public void Verify(string initialMarkup, string expectedMarkup, char typeChar)
+        public async Task VerifyAsync(string initialMarkup, string expectedMarkup, char typeChar)
         {
-            using (var workspace = CreateTestWorkspace(initialMarkup))
+            using (var workspace = await CreateTestWorkspaceAsync(initialMarkup))
             {
                 var testDocument = workspace.Documents.Single();
                 var view = testDocument.GetTextView();
diff --git a/src/EditorFeatures/Test/FindReferences/FindReferencesCommandHandlerTests.cs b/src/EditorFeatures/Test/FindReferences/FindReferencesCommandHandlerTests.cs
index 2027d82e94ba89d6a9b8051dcb64926573d3443a..1a2f6c9ae902b3057b522a9a34aa6283871109c0 100644
--- a/src/EditorFeatures/Test/FindReferences/FindReferencesCommandHandlerTests.cs
+++ b/src/EditorFeatures/Test/FindReferences/FindReferencesCommandHandlerTests.cs
@@ -2,6 +2,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Commands;
 using Microsoft.CodeAnalysis.Editor.Implementation.FindReferences;
 using Microsoft.CodeAnalysis.Editor.Navigation;
@@ -20,9 +21,9 @@ namespace Microsoft.CodeAnalysis.Editor.UnitTests.FindReferences
     public class FindReferencesCommandHandlerTests
     {
         [WpfFact, Trait(Traits.Feature, Traits.Features.FindReferences)]
-        public void TestFindReferencesSynchronousCall()
+        public async Task TestFindReferencesSynchronousCall()
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines("class C { C() { new C(); } }"))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync("class C { C() { new C(); } }"))
             {
                 var findReferencesPresenter = new MockReferencedSymbolsPresenter();
 
diff --git a/src/EditorFeatures/Test/Preview/PreviewWorkspaceTests.cs b/src/EditorFeatures/Test/Preview/PreviewWorkspaceTests.cs
index 35466ce655019eb946210444a1af8751800128e4..62b3002a1592a4392199e87a6939781a4a3a1e64 100644
--- a/src/EditorFeatures/Test/Preview/PreviewWorkspaceTests.cs
+++ b/src/EditorFeatures/Test/Preview/PreviewWorkspaceTests.cs
@@ -183,7 +183,7 @@ public void TestPreviewDiagnostic()
         [WpfFact]
         public async Task TestPreviewDiagnosticTagger()
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines("class { }"))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync("class { }"))
             using (var previewWorkspace = new PreviewWorkspace(workspace.CurrentSolution))
             {
                 //// preview workspace and owner of the solution now share solution and its underlying text buffer
@@ -200,7 +200,7 @@ public async Task TestPreviewDiagnosticTagger()
         [WpfFact]
         public async Task TestPreviewDiagnosticTaggerInPreviewPane()
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines("class { }"))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync("class { }"))
             {
                 // set up listener to wait until diagnostic finish running
                 var diagnosticService = workspace.ExportProvider.GetExportedValue<IDiagnosticService>() as DiagnosticService;
diff --git a/src/EditorFeatures/Test/TextEditor/TryGetDocumentTests.cs b/src/EditorFeatures/Test/TextEditor/TryGetDocumentTests.cs
index fbf5fe47f4571a4aba3219971e8303ace72b1588..fd6bb3d60a4c6103a256e308db0b31fbc4290005 100644
--- a/src/EditorFeatures/Test/TextEditor/TryGetDocumentTests.cs
+++ b/src/EditorFeatures/Test/TextEditor/TryGetDocumentTests.cs
@@ -2,6 +2,7 @@
 
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Text;
@@ -14,11 +15,11 @@ public class TryGetDocumentTests
     {
         [WpfFact]
         [WorkItem(624315)]
-        public void MultipleTextChangesTest()
+        public async Task MultipleTextChangesTest()
         {
             var code = @"class C
 ";
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(code))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code))
             {
                 var hostDocument = workspace.Documents.First();
                 var document = workspace.CurrentSolution.GetDocument(workspace.GetDocumentId(hostDocument));
@@ -45,10 +46,10 @@ public void MultipleTextChangesTest()
         }
 
         [WpfFact]
-        public void EmptyTextChanges()
+        public async Task EmptyTextChanges()
         {
             var code = @"class C";
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(code))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code))
             {
                 var hostDocument = workspace.Documents.First();
                 var document = workspace.CurrentSolution.GetDocument(workspace.GetDocumentId(hostDocument));
diff --git a/src/EditorFeatures/Test/Utilities/SymbolEquivalenceComparerTests.cs b/src/EditorFeatures/Test/Utilities/SymbolEquivalenceComparerTests.cs
index addc8775d48907ffe5ee268c5601ad48b5dfecf9..f0bf380603e0b39db7fc3814ac026937b2a6c55d 100644
--- a/src/EditorFeatures/Test/Utilities/SymbolEquivalenceComparerTests.cs
+++ b/src/EditorFeatures/Test/Utilities/SymbolEquivalenceComparerTests.cs
@@ -5,6 +5,7 @@
 using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Shared.Utilities;
 using Microsoft.CodeAnalysis.Test.Utilities;
@@ -24,7 +25,7 @@ public class SymbolEquivalenceComparerTests
             WithStrongNameProvider(new SigningTestHelpers.VirtualizedStrongNameProvider(ImmutableArray.Create<string>()));
 
         [WpfFact]
-        public void TestArraysAreEquivalent()
+        public async Task TestArraysAreEquivalent()
         {
             var csharpCode =
 @"class C
@@ -44,7 +45,7 @@ public void TestArraysAreEquivalent()
     System.Int32 int32Field2;
 }";
 
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode))
             {
                 var type = (ITypeSymbol)workspace.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("C").Single();
 
@@ -95,7 +96,7 @@ public void TestArraysAreEquivalent()
         }
 
         [WpfFact]
-        public void TestArraysInDifferentLanguagesAreEquivalent()
+        public async Task TestArraysInDifferentLanguagesAreEquivalent()
         {
             var csharpCode =
 @"class C
@@ -117,7 +118,7 @@ public void TestArraysInDifferentLanguagesAreEquivalent()
     dim int32Field1 as System.Int32
 end class";
 
-            using (var csharpWorkspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode))
+            using (var csharpWorkspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode))
             using (var vbWorkspace = VisualBasicWorkspaceFactory.CreateWorkspaceFromLines(vbCode))
             {
                 var csharpType = (ITypeSymbol)csharpWorkspace.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("C").Single();
@@ -162,7 +163,7 @@ public void TestArraysInDifferentLanguagesAreEquivalent()
         }
 
         [WpfFact]
-        public void TestFields()
+        public async Task TestFields()
         {
             var csharpCode1 =
 @"class Type1
@@ -189,8 +190,8 @@ class Type2
     bool field3;
     string field2;
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type2_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type2").Single();
@@ -218,7 +219,7 @@ class Type2
 
         [WorkItem(538124)]
         [WpfFact]
-        public void TestFieldsAcrossLanguages()
+        public async Task TestFieldsAcrossLanguages()
         {
             var csharpCode1 =
 @"class Type1
@@ -243,7 +244,7 @@ class Type2
     dim field3 as Boolean;
     dim field2 as String;
 end class";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
             using (var workspace2 = VisualBasicWorkspaceFactory.CreateWorkspaceFromLines(vbCode1))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -268,7 +269,7 @@ class Type2
         }
 
         [WpfFact]
-        public void TestFieldsInGenericTypes()
+        public async Task TestFieldsInGenericTypes()
         {
             var code =
 @"class C<T>
@@ -285,7 +286,7 @@ class D
 }
 ";
 
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(code))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code))
             {
                 var typeC = workspace.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("C").Single();
                 var typeD = workspace.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("D").Single();
@@ -317,7 +318,7 @@ class D
         }
 
         [WpfFact]
-        public void TestMethodsWithDifferentReturnTypeNotEquivalent()
+        public async Task TestMethodsWithDifferentReturnTypeNotEquivalent()
         {
             var csharpCode1 =
 @"class Type1
@@ -330,8 +331,8 @@ public void TestMethodsWithDifferentReturnTypeNotEquivalent()
 {
     int Foo() {}
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -344,7 +345,7 @@ public void TestMethodsWithDifferentReturnTypeNotEquivalent()
         }
 
         [WpfFact]
-        public void TestMethodsWithDifferentNamesAreNotEquivalent()
+        public async Task TestMethodsWithDifferentNamesAreNotEquivalent()
         {
             var csharpCode1 =
 @"class Type1
@@ -357,8 +358,8 @@ public void TestMethodsWithDifferentNamesAreNotEquivalent()
 {
     void Foo1() {}
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -371,7 +372,7 @@ public void TestMethodsWithDifferentNamesAreNotEquivalent()
         }
 
         [WpfFact]
-        public void TestMethodsWithDifferentAritiesAreNotEquivalent()
+        public async Task TestMethodsWithDifferentAritiesAreNotEquivalent()
         {
             var csharpCode1 =
 @"class Type1
@@ -384,8 +385,8 @@ public void TestMethodsWithDifferentAritiesAreNotEquivalent()
 {
     void Foo<T>() {}
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -398,7 +399,7 @@ public void TestMethodsWithDifferentAritiesAreNotEquivalent()
         }
 
         [WpfFact]
-        public void TestMethodsWithDifferentParametersAreNotEquivalent()
+        public async Task TestMethodsWithDifferentParametersAreNotEquivalent()
         {
             var csharpCode1 =
 @"class Type1
@@ -411,8 +412,8 @@ public void TestMethodsWithDifferentParametersAreNotEquivalent()
 {
     void Foo(int a) {}
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -425,7 +426,7 @@ public void TestMethodsWithDifferentParametersAreNotEquivalent()
         }
 
         [WpfFact]
-        public void TestMethodsWithDifferentTypeParameters()
+        public async Task TestMethodsWithDifferentTypeParameters()
         {
             var csharpCode1 =
 @"class Type1
@@ -438,8 +439,8 @@ public void TestMethodsWithDifferentTypeParameters()
 {
     void Foo<B>(B a) {}
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -454,7 +455,7 @@ public void TestMethodsWithDifferentTypeParameters()
         }
 
         [WpfFact]
-        public void TestMethodsWithSameParameters()
+        public async Task TestMethodsWithSameParameters()
         {
             var csharpCode1 =
 @"class Type1
@@ -467,8 +468,8 @@ public void TestMethodsWithSameParameters()
 {
     void Foo(int a) {}
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -483,7 +484,7 @@ public void TestMethodsWithSameParameters()
         }
 
         [WpfFact]
-        public void TestMethodsWithDifferentParameterNames()
+        public async Task TestMethodsWithDifferentParameterNames()
         {
             var csharpCode1 =
 @"class Type1
@@ -496,8 +497,8 @@ public void TestMethodsWithDifferentParameterNames()
 {
     void Foo(int b) {}
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -512,7 +513,7 @@ public void TestMethodsWithDifferentParameterNames()
         }
 
         [WpfFact]
-        public void TestMethodsAreEquivalentOutToRef()
+        public async Task TestMethodsAreEquivalentOutToRef()
         {
             var csharpCode1 =
 @"class Type1
@@ -525,8 +526,8 @@ public void TestMethodsAreEquivalentOutToRef()
 {
     void Foo(ref int a) {}
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -539,7 +540,7 @@ public void TestMethodsAreEquivalentOutToRef()
         }
 
         [WpfFact]
-        public void TestMethodsNotEquivalentRemoveOut()
+        public async Task TestMethodsNotEquivalentRemoveOut()
         {
             var csharpCode1 =
 @"class Type1
@@ -552,8 +553,8 @@ public void TestMethodsNotEquivalentRemoveOut()
 {
     void Foo(int a) {}
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -566,7 +567,7 @@ public void TestMethodsNotEquivalentRemoveOut()
         }
 
         [WpfFact]
-        public void TestMethodsAreEquivalentIgnoreParams()
+        public async Task TestMethodsAreEquivalentIgnoreParams()
         {
             var csharpCode1 =
 @"class Type1
@@ -579,8 +580,8 @@ public void TestMethodsAreEquivalentIgnoreParams()
 {
     void Foo(int[] a) {}
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -595,7 +596,7 @@ public void TestMethodsAreEquivalentIgnoreParams()
         }
 
         [WpfFact]
-        public void TestMethodsNotEquivalentDifferentParameterTypes()
+        public async Task TestMethodsNotEquivalentDifferentParameterTypes()
         {
             var csharpCode1 =
 @"class Type1
@@ -608,8 +609,8 @@ public void TestMethodsNotEquivalentDifferentParameterTypes()
 {
     void Foo(string[] a) {}
 }";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -622,7 +623,7 @@ public void TestMethodsNotEquivalentDifferentParameterTypes()
         }
 
         [WpfFact]
-        public void TestMethodsAcrossLanguages()
+        public async Task TestMethodsAcrossLanguages()
         {
             var csharpCode1 =
 @"
@@ -644,7 +645,7 @@ end function
     sub Quux()
     end sub
 end class";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
             using (var workspace2 = VisualBasicWorkspaceFactory.CreateWorkspaceFromLines(vbCode1))
             {
                 var csharpType1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -669,7 +670,7 @@ end sub
         }
 
         [WpfFact]
-        public void TestMethodsInGenericTypesAcrossLanguages()
+        public async Task TestMethodsInGenericTypesAcrossLanguages()
         {
             var csharpCode1 =
 @"
@@ -691,7 +692,7 @@ end function
     sub Bar(x as Object)
     end sub
 end class";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
             using (var workspace2 = VisualBasicWorkspaceFactory.CreateWorkspaceFromLines(vbCode1))
             {
                 var csharpType1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -716,7 +717,7 @@ end sub
         }
 
         [WpfFact]
-        public void TestObjectAndDynamicAreNotEqualNormally()
+        public async Task TestObjectAndDynamicAreNotEqualNormally()
         {
             var csharpCode1 =
 @"class Type1
@@ -725,7 +726,7 @@ public void TestObjectAndDynamicAreNotEqualNormally()
     dynamic field2;
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
 
@@ -738,7 +739,7 @@ public void TestObjectAndDynamicAreNotEqualNormally()
         }
 
         [WpfFact]
-        public void TestObjectAndDynamicAreEqualInSignatures()
+        public async Task TestObjectAndDynamicAreEqualInSignatures()
         {
             var csharpCode1 =
 @"class Type1
@@ -752,8 +753,8 @@ public void TestObjectAndDynamicAreEqualInSignatures()
     void Foo(dynamic o1) { }
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -769,7 +770,7 @@ public void TestObjectAndDynamicAreEqualInSignatures()
         }
 
         [WpfFact]
-        public void TestUnequalGenericsInSignatures()
+        public async Task TestUnequalGenericsInSignatures()
         {
             var csharpCode1 =
 @"
@@ -789,8 +790,8 @@ class Type1
     void Foo(IList<string> o1) { }
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -804,7 +805,7 @@ class Type1
         }
 
         [WpfFact]
-        public void TestGenericsWithDynamicAndObjectInSignatures()
+        public async Task TestGenericsWithDynamicAndObjectInSignatures()
         {
             var csharpCode1 =
 @"
@@ -824,8 +825,8 @@ class Type1
     void Foo(IList<dynamic> o1) { }
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -841,7 +842,7 @@ class Type1
         }
 
         [WpfFact]
-        public void TestDynamicAndUnrelatedTypeInSignatures()
+        public async Task TestDynamicAndUnrelatedTypeInSignatures()
         {
             var csharpCode1 =
 @"
@@ -861,8 +862,8 @@ class Type1
     void Foo(string o1) { }
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -876,7 +877,7 @@ class Type1
         }
 
         [WpfFact]
-        public void TestNamespaces()
+        public async Task TestNamespaces()
         {
             var csharpCode1 =
 @"namespace Outer
@@ -894,8 +895,8 @@ class Type
 }
 ";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
             {
                 var outer1 = (INamespaceSymbol)workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetMembers("Outer").Single();
                 var outer2 = (INamespaceSymbol)workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetMembers("Outer").Single();
@@ -949,7 +950,7 @@ class Type
         }
 
         [WpfFact]
-        public void TestNamedTypesEquivalent()
+        public async Task TestNamedTypesEquivalent()
         {
             var csharpCode1 =
 @"
@@ -973,8 +974,8 @@ class Type2<Y>
 {
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -997,7 +998,7 @@ class Type2<Y>
         }
 
         [WpfFact]
-        public void TestNamedTypesDifferentIfNameChanges()
+        public async Task TestNamedTypesDifferentIfNameChanges()
         {
             var csharpCode1 =
 @"
@@ -1012,8 +1013,8 @@ class Type2
   void Foo();
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type2").Single();
@@ -1024,7 +1025,7 @@ class Type2
         }
 
         [WpfFact]
-        public void TestNamedTypesDifferentIfTypeKindChanges()
+        public async Task TestNamedTypesDifferentIfTypeKindChanges()
         {
             var csharpCode1 =
 @"
@@ -1039,8 +1040,8 @@ class Type1
   void Foo();
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -1051,7 +1052,7 @@ class Type1
         }
 
         [WpfFact]
-        public void TestNamedTypesDifferentIfArityChanges()
+        public async Task TestNamedTypesDifferentIfArityChanges()
         {
             var csharpCode1 =
 @"
@@ -1066,8 +1067,8 @@ class Type1<T>
   void Foo();
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -1078,7 +1079,7 @@ class Type1<T>
         }
 
         [WpfFact]
-        public void TestNamedTypesDifferentIfContainerDifferent()
+        public async Task TestNamedTypesDifferentIfContainerDifferent()
         {
             var csharpCode1 =
 @"
@@ -1099,8 +1100,8 @@ class Type1
     }
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var outer = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Outer").Single();
                 var other = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Other").Single();
@@ -1113,7 +1114,7 @@ class Type1
         }
 
         [WpfFact]
-        public void TestAliasedTypes1()
+        public async Task TestAliasedTypes1()
         {
             var csharpCode1 =
 @"
@@ -1131,8 +1132,8 @@ class Type1
     void Foo(int o1) { }
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("Type1").Single();
@@ -1149,7 +1150,7 @@ class Type1
 
         [WorkItem(599, "https://github.com/dotnet/roslyn/issues/599")]
         [WpfFact]
-        public void TestRefVersusOut()
+        public async Task TestRefVersusOut()
         {
             var csharpCode1 =
 @"
@@ -1165,8 +1166,8 @@ class C
     void M(ref int i) { }
 }";
 
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode1))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(csharpCode2))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode1))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(csharpCode2))
             {
                 var type1_v1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("C").Single();
                 var type1_v2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result.GlobalNamespace.GetTypeMembers("C").Single();
@@ -1189,7 +1190,7 @@ class C
         }
 
         [WpfFact]
-        public void TestCSharpReducedExtensionMethodsAreEquivalent()
+        public async Task TestCSharpReducedExtensionMethodsAreEquivalent()
         {
             var code = @"
 class Zed {}
@@ -1240,8 +1241,8 @@ void GenericThisAndOther()
     } 
 }
 ";
-            using (var workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(code))
-            using (var workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(code))
+            using (var workspace1 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code))
+            using (var workspace2 = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code))
             {
                 var comp1 = workspace1.CurrentSolution.Projects.Single().GetCompilationAsync().Result;
                 var comp2 = workspace2.CurrentSolution.Projects.Single().GetCompilationAsync().Result;
diff --git a/src/EditorFeatures/Test/Workspaces/CSharpWorkspaceFactory.cs b/src/EditorFeatures/Test/Workspaces/CSharpWorkspaceFactory.cs
index b9f68820a253097ae9f8acd8acb5f25971f946dd..b93a6ee8f81400aef2e1c3fdbca89bf5986f8eb1 100644
--- a/src/EditorFeatures/Test/Workspaces/CSharpWorkspaceFactory.cs
+++ b/src/EditorFeatures/Test/Workspaces/CSharpWorkspaceFactory.cs
@@ -15,11 +15,6 @@ public partial class CSharpWorkspaceFactory : TestWorkspaceFactory
         /// Creates a single buffer in a workspace.
         /// </summary>
         /// <param name="lines">Lines of text, the buffer contents</param>
-        public static TestWorkspace CreateWorkspaceFromLines(params string[] lines)
-        {
-            return CreateWorkspaceFromLinesAsync(lines).WaitAndGetResult(CancellationToken.None);
-        } 
-
         public static Task<TestWorkspace> CreateWorkspaceFromLinesAsync(params string[] lines)
         {
             return CreateWorkspaceFromLinesAsync(lines, parseOptions: null, compilationOptions: null, exportProvider: null);
diff --git a/src/EditorFeatures/VisualBasicTest/BraceMatching/VisualBasicBraceMatcherTests.vb b/src/EditorFeatures/VisualBasicTest/BraceMatching/VisualBasicBraceMatcherTests.vb
index 22c785801d3561ba4abe58372bc107850ed69a1a..d5f57190932f2205ac85ae56bf53b060b443e23b 100644
--- a/src/EditorFeatures/VisualBasicTest/BraceMatching/VisualBasicBraceMatcherTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/BraceMatching/VisualBasicBraceMatcherTests.vb
@@ -1,5 +1,6 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+Imports System.Threading.Tasks
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.BraceMatching
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 
@@ -7,367 +8,366 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.BraceMatching
     Public Class VisualBasicBraceMatcherTests
         Inherits AbstractBraceMatcherTests
 
-        Protected Overrides Function CreateWorkspaceFromCode(code As String) As TestWorkspace
-            Return VisualBasicWorkspaceFactory.CreateWorkspaceFromLines(code)
+        Protected Overrides Function CreateWorkspaceFromCodeAsync(code As String) As Task(Of TestWorkspace)
+            Return VisualBasicWorkspaceFactory.CreateWorkspaceFromLinesAsync(code)
         End Function
 
-        Private Sub TestInClass(code As String, expectedCode As String)
-            Test(
+        Private Async Function TestInClassAsync(code As String, expectedCode As String) As Task
+            Await TestAsync(
                 "Class C" & vbCrLf & code & vbCrLf & "End Class",
                 "Class C" & vbCrLf & expectedCode & vbCrLf & "End Class")
-        End Sub
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestEmptyFile()
+        Public Async Function TestEmptyFile() As Task
             Dim code = "$$"
             Dim expected = ""
 
-            Test(code, expected)
-        End Sub
+            Await TestAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAtFirstPositionInFile()
+        Public Async Function TestAtFirstPositionInFile() As Task
             Dim code = "$$Class C" & vbCrLf & vbCrLf & "End Class"
             Dim expected = "Class C" & vbCrLf & vbCrLf & "End Class"
 
-            Test(code, expected)
-        End Sub
+            Await TestAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAtLastPositionInFile()
+        Public Async Function TestAtLastPositionInFile() As Task
             Dim code = "Class C" & vbCrLf & vbCrLf & "End Class$$"
             Dim expected = "Class C" & vbCrLf & vbCrLf & "End Class"
 
-            Test(code, expected)
-        End Sub
+            Await TestAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestCurlyBrace1()
+        Public Async Function TestCurlyBrace1() As Task
             Dim code = "Dim l As New List(Of Integer) From $${}"
             Dim expected = "Dim l As New List(Of Integer) From {[|}|]"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestCurlyBrace2()
+        Public Async Function TestCurlyBrace2() As Task
             Dim code = "Dim l As New List(Of Integer) From {$$}"
             Dim expected = "Dim l As New List(Of Integer) From {[|}|]"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestCurlyBrace3()
+        Public Async Function TestCurlyBrace3() As Task
             Dim code = "Dim l As New List(Of Integer) From {$$ }"
             Dim expected = "Dim l As New List(Of Integer) From { [|}|]"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestCurlyBrace4()
+        Public Async Function TestCurlyBrace4() As Task
             Dim code = "Dim l As New List(Of Integer) From { $$}"
             Dim expected = "Dim l As New List(Of Integer) From [|{|] }"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestCurlyBrace5()
+        Public Async Function TestCurlyBrace5() As Task
             Dim code = "Dim l As New List(Of Integer) From { }$$"
             Dim expected = "Dim l As New List(Of Integer) From [|{|] }"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestCurlyBrace6()
+        Public Async Function TestCurlyBrace6() As Task
             Dim code = "Dim l As New List(Of Integer) From {}$$"
             Dim expected = "Dim l As New List(Of Integer) From [|{|]}"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestNestedParen1()
+        Public Async Function TestNestedParen1() As Task
             Dim code = "Dim l As New List$$(Of Func(Of Integer))"
             Dim expected = "Dim l As New List(Of Func(Of Integer)[|)|]"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestNestedParen2()
+        Public Async Function TestNestedParen2() As Task
             Dim code = "Dim l As New List($$Of Func(Of Integer))"
             Dim expected = "Dim l As New List(Of Func(Of Integer)[|)|]"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestNestedParen3()
+        Public Async Function TestNestedParen3() As Task
             Dim code = "Dim l As New List(Of Func$$(Of Integer))"
             Dim expected = "Dim l As New List(Of Func(Of Integer[|)|])"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestNestedParen4()
+        Public Async Function TestNestedParen4() As Task
             Dim code = "Dim l As New List(Of Func($$Of Integer))"
             Dim expected = "Dim l As New List(Of Func(Of Integer[|)|])"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestNestedParen5()
+        Public Async Function TestNestedParen5() As Task
             Dim code = "Dim l As New List(Of Func(Of Integer$$))"
             Dim expected = "Dim l As New List(Of Func[|(|]Of Integer))"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestNestedParen6()
+        Public Async Function TestNestedParen6() As Task
             Dim code = "Dim l As New List(Of Func(Of Integer)$$)"
             Dim expected = "Dim l As New List(Of Func[|(|]Of Integer))"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestNestedParen7()
+        Public Async Function TestNestedParen7() As Task
             Dim code = "Dim l As New List(Of Func(Of Integer)$$ )"
             Dim expected = "Dim l As New List(Of Func[|(|]Of Integer) )"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestNestedParen8()
+        Public Async Function TestNestedParen8() As Task
             Dim code = "Dim l As New List(Of Func(Of Integer) $$)"
             Dim expected = "Dim l As New List[|(|]Of Func(Of Integer) )"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestNestedParen9()
+        Public Async Function TestNestedParen9() As Task
             Dim code = "Dim l As New List(Of Func(Of Integer) )$$"
             Dim expected = "Dim l As New List[|(|]Of Func(Of Integer) )"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestNestedParen10()
+        Public Async Function TestNestedParen10() As Task
             Dim code = "Dim l As New List(Of Func(Of Integer))$$"
             Dim expected = "Dim l As New List[|(|]Of Func(Of Integer))"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket1()
+        Public Async Function TestAngleBracket1() As Task
             Dim code = "$$<Foo()> Dim i As Integer"
             Dim expected = "<Foo()[|>|] Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket2()
+        Public Async Function TestAngleBracket2() As Task
             Dim code = "<$$Foo()> Dim i As Integer"
             Dim expected = "<Foo()[|>|] Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket3()
+        Public Async Function TestAngleBracket3() As Task
             Dim code = "<Foo$$()> Dim i As Integer"
             Dim expected = "<Foo([|)|]> Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket4()
+        Public Async Function TestAngleBracket4() As Task
             Dim code = "<Foo($$)> Dim i As Integer"
             Dim expected = "<Foo([|)|]> Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket5()
+        Public Async Function TestAngleBracket5() As Task
             Dim code = "<Foo($$ )> Dim i As Integer"
             Dim expected = "<Foo( [|)|]> Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket6()
+        Public Async Function TestAngleBracket6() As Task
             Dim code = "<Foo( $$)> Dim i As Integer"
             Dim expected = "<Foo[|(|] )> Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket7()
+        Public Async Function TestAngleBracket7() As Task
             Dim code = "<Foo( )$$> Dim i As Integer"
             Dim expected = "<Foo[|(|] )> Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket8()
+        Public Async Function TestAngleBracket8() As Task
             Dim code = "<Foo()$$> Dim i As Integer"
             Dim expected = "<Foo[|(|])> Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket9()
+        Public Async Function TestAngleBracket9() As Task
             Dim code = "<Foo()$$ > Dim i As Integer"
             Dim expected = "<Foo[|(|]) > Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket10()
+        Public Async Function TestAngleBracket10() As Task
             Dim code = "<Foo() $$> Dim i As Integer"
             Dim expected = "[|<|]Foo() > Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket11()
+        Public Async Function TestAngleBracket11() As Task
             Dim code = "<Foo() >$$ Dim i As Integer"
             Dim expected = "[|<|]Foo() > Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestAngleBracket12()
+        Public Async Function TestAngleBracket12() As Task
             Dim code = "<Foo()>$$ Dim i As Integer"
             Dim expected = "[|<|]Foo()> Dim i As Integer"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestString1()
+        Public Async Function TestString1() As Task
             Dim code = "Dim s As String = $$""Foo"""
             Dim expected = "Dim s As String = ""Foo[|""|]"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestString2()
+        Public Async Function TestString2() As Task
             Dim code = "Dim s As String = ""$$Foo"""
             Dim expected = "Dim s As String = ""Foo[|""|]"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestString3()
+        Public Async Function TestString3() As Task
             Dim code = "Dim s As String = ""Foo$$"""
             Dim expected = "Dim s As String = [|""|]Foo"""
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestString4()
+        Public Async Function TestString4() As Task
             Dim code = "Dim s As String = ""Foo""$$"
             Dim expected = "Dim s As String = [|""|]Foo"""
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestString5()
+        Public Async Function TestString5() As Task
             Dim code = "Dim s As String = ""Foo$$"
             Dim expected = "Dim s As String = ""Foo"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestInterpolatedString1()
+        Public Async Function TestInterpolatedString1() As Task
             Dim code = "Dim s = $$[||]$""Foo"""
             Dim expected = "Dim s = $""Foo[|""|]"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestInterpolatedString2()
+        Public Async Function TestInterpolatedString2() As Task
             Dim code = "Dim s = $""$$Foo"""
             Dim expected = "Dim s = $""Foo[|""|]"
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestInterpolatedString3()
+        Public Async Function TestInterpolatedString3() As Task
             Dim code = "Dim s = $""Foo$$"""
             Dim expected = "Dim s = [|$""|]Foo"""
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestInterpolatedString4()
+        Public Async Function TestInterpolatedString4() As Task
             Dim code = "Dim s = $""Foo""$$"
             Dim expected = "Dim s = [|$""|]Foo"""
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestInterpolatedString5()
+        Public Async Function TestInterpolatedString5() As Task
             Dim code = "Dim s = $"" $${x} """
             Dim expected = "Dim s = $"" {x[|}|] """
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestInterpolatedString6()
+        Public Async Function TestInterpolatedString6() As Task
             Dim code = "Dim s = $"" {$$x} """
             Dim expected = "Dim s = $"" {x[|}|] """
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestInterpolatedString7()
+        Public Async Function TestInterpolatedString7() As Task
             Dim code = "Dim s = $"" {x$$} """
             Dim expected = "Dim s = $"" [|{|]x} """
 
-            TestInClass(code, expected)
-        End Sub
+            Await TestInClassAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.BraceMatching)>
-        Public Sub TestInterpolatedString8()
+        Public Async Function TestInterpolatedString8() As Task
             Dim code = "Dim s = $"" {x}$$ """
             Dim expected = "Dim s = $"" [|{|]x} """
 
-            TestInClass(code, expected)
-        End Sub
-
+            Await TestInClassAsync(code, expected)
+        End Function
     End Class
-End Namespace
+End Namespace
\ No newline at end of file
diff --git a/src/EditorFeatures/VisualBasicTest/DocumentationComments/DocumentationCommentTests.vb b/src/EditorFeatures/VisualBasicTest/DocumentationComments/DocumentationCommentTests.vb
index afc749e445fcedd8c6cbb5354e5a6b77eede65e0..76a7ae0d49569702d8404e2f9dd42cbfb57307b5 100644
--- a/src/EditorFeatures/VisualBasicTest/DocumentationComments/DocumentationCommentTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/DocumentationComments/DocumentationCommentTests.vb
@@ -1,5 +1,6 @@
 ' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+Imports System.Threading.Tasks
 Imports Microsoft.CodeAnalysis.Editor.Host
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.DocumentationComments
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
@@ -11,7 +12,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.DocumentationComme
         Inherits AbstractDocumentationCommentTests
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_Class_AutoGenerateXmlDocCommentsOff()
+        Public Async Function TestTypingCharacter_Class_AutoGenerateXmlDocCommentsOff() As Task
             Const code = "
 ''$$
 Class C
@@ -22,11 +23,11 @@ End Class
 Class C
 End Class
 "
-            VerifyTypingCharacter(code, expected, autoGenerateXmlDocComments:=False)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected, autoGenerateXmlDocComments:=False)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_Class()
+        Public Async Function TestTypingCharacter_Class() As Task
             Const code = "
 ''$$
 Class C
@@ -39,11 +40,11 @@ End Class
 Class C
 End Class
 "
-            VerifyTypingCharacter(code, expected)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_Method()
+        Public Async Function TestTypingCharacter_Method() As Task
             Const code = "
 Class C
     ''$$
@@ -66,12 +67,12 @@ Class C
     End Function
 End Class
 "
-            VerifyTypingCharacter(code, expected)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected)
+        End Function
 
         <WorkItem(538715)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_NoReturnType()
+        Public Async Function TestTypingCharacter_NoReturnType() As Task
             Const code = "
 Class C
    ''$$
@@ -89,11 +90,11 @@ Class C
    End Function
 End Class
 "
-            VerifyTypingCharacter(code, expected)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_NotWhenDocCommentExists1()
+        Public Async Function TestTypingCharacter_NotWhenDocCommentExists1() As Task
             Const code = "
 ''$$
 ''' <summary></summary>
@@ -106,11 +107,11 @@ End Class
 Class C
 End Class
 "
-            VerifyTypingCharacter(code, expected)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_NotWhenDocCommentExists2()
+        Public Async Function TestTypingCharacter_NotWhenDocCommentExists2() As Task
             Const code = "
 Class C
     ''$$
@@ -129,12 +130,12 @@ Class C
     End Function
 End Class
 "
-            VerifyTypingCharacter(code, expected)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected)
+        End Function
 
         <WorkItem(537506)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_NotAfterClassName()
+        Public Async Function TestTypingCharacter_NotAfterClassName() As Task
             Const code = "
 Class C''$$
 End Class
@@ -143,12 +144,12 @@ End Class
 Class C'''$$
 End Class
 "
-            VerifyTypingCharacter(code, expected)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected)
+        End Function
 
         <WorkItem(537508)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_NotInsideClass()
+        Public Async Function TestTypingCharacter_NotInsideClass() As Task
             Const code = "
 Class C
     ''$$
@@ -159,12 +160,12 @@ Class C
     '''$$
 End Class
 "
-            VerifyTypingCharacter(code, expected)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected)
+        End Function
 
         <WorkItem(537510)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_NotAfterConstructorName()
+        Public Async Function TestTypingCharacter_NotAfterConstructorName() As Task
             Const code = "
 Class C
     Sub New() ''$$
@@ -175,12 +176,12 @@ Class C
     Sub New() '''$$
 End Class
 "
-            VerifyTypingCharacter(code, expected)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected)
+        End Function
 
         <WorkItem(537511)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_NotInsideConstructor()
+        Public Async Function TestTypingCharacter_NotInsideConstructor() As Task
             Const code = "
 Class C
     Sub New()
@@ -195,12 +196,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyTypingCharacter(code, expected)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected)
+        End Function
 
         <WorkItem(537512)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_NotInsideMethodBody()
+        Public Async Function TestTypingCharacter_NotInsideMethodBody() As Task
             Const code = "
 Class C
     Sub Foo()
@@ -215,12 +216,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyTypingCharacter(code, expected)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected)
+        End Function
 
         <WorkItem(540004)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TypingCharacter_NoReturnsOnWriteOnlyProperty()
+        Public Async Function TestTypingCharacter_NoReturnsOnWriteOnlyProperty() As Task
             Const code = "
 Class C
     ''$$
@@ -241,11 +242,11 @@ Class C
     End Property
 End Class
 "
-            VerifyTypingCharacter(code, expected)
-        End Sub
+            Await VerifyTypingCharacterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Class1()
+        Public Async Function TestPressingEnter_Class1() As Task
             Const code = "
 '''$$
 Class C
@@ -258,11 +259,11 @@ End Class
 Class C
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Class1_AutoGenerateXmlDocCommentsOff()
+        Public Async Function TestPressingEnter_Class1_AutoGenerateXmlDocCommentsOff() As Task
             Const code = "
 '''$$
 Class C
@@ -274,11 +275,11 @@ $$
 Class C
 End Class
 "
-            VerifyPressingEnter(code, expected, autoGenerateXmlDocComments:=False)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected, autoGenerateXmlDocComments:=False)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Class2()
+        Public Async Function TestPressingEnter_Class2() As Task
             Const code = "
 '''$$Class C
 End Class
@@ -290,11 +291,11 @@ End Class
 Class C
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Class3()
+        Public Async Function TestPressingEnter_Class3() As Task
             Const code = "
 '''$$<Foo()> Class C
 End Class
@@ -306,12 +307,12 @@ End Class
 <Foo()> Class C
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(538717)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Module()
+        Public Async Function TestPressingEnter_Module() As Task
             Const code = "
 '''$$Module M
    Dim x As Integer
@@ -325,11 +326,11 @@ Module M
     Dim x As Integer
 End Module
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Method1()
+        Public Async Function TestPressingEnter_Method1() As Task
             Const code = "
 Class C
     '''$$
@@ -351,11 +352,11 @@ Class C
     End Function
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Method2()
+        Public Async Function TestPressingEnter_Method2() As Task
             Const code = "
 Class C
     '''$$Function M(Of T)(foo As Integer) As Integer
@@ -376,11 +377,11 @@ Class C
     End Function
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_InsertApostrophes1()
+        Public Async Function TestPressingEnter_InsertApostrophes1() As Task
             Const code = "
 '''$$
 ''' <summary></summary>
@@ -394,11 +395,11 @@ End Class
 Class C
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_InsertApostrophes2()
+        Public Async Function TestPressingEnter_InsertApostrophes2() As Task
             Const code = "
 ''' <summary>
 ''' $$
@@ -414,11 +415,11 @@ End Class
 Class C
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_InsertApostrophes3()
+        Public Async Function TestPressingEnter_InsertApostrophes3() As Task
             Const code = "
 ''' <summary>$$</summary>
 Class C
@@ -430,11 +431,11 @@ End Class
 Class C
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_InsertApostrophes4()
+        Public Async Function TestPressingEnter_InsertApostrophes4() As Task
             Const code = "
     '''$$
     ''' <summary></summary>
@@ -448,11 +449,11 @@ End Class
     Class C
     End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_InsertApostrophes5()
+        Public Async Function TestPressingEnter_InsertApostrophes5() As Task
             Const code = "
     ''' <summary>
     ''' $$
@@ -468,11 +469,11 @@ End Class
     Class C
     End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_InsertApostrophes6()
+        Public Async Function TestPressingEnter_InsertApostrophes6() As Task
             Const code = "
     ''' <summary>$$</summary>
     Class C
@@ -484,11 +485,11 @@ End Class
     Class C
     End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_InsertApostrophes7()
+        Public Async Function TestPressingEnter_InsertApostrophes7() As Task
             Const code = "
 Class C
     '''$$
@@ -508,12 +509,12 @@ Class C
     End Function
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(540017)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_InsertApostrophes8()
+        Public Async Function TestPressingEnter_InsertApostrophes8() As Task
             Const code = "
 ''' <summary></summary>$$
 Class C
@@ -525,12 +526,12 @@ End Class
 Class C
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(4817, "https://github.com/dotnet/roslyn/issues/4817")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_InsertApostrophes9_AutoGenerateXmlDocCommentsOff()
+        Public Async Function TestPressingEnter_InsertApostrophes9_AutoGenerateXmlDocCommentsOff() As Task
             Const code = "
 ''' <summary></summary>$$
 Class C
@@ -542,12 +543,12 @@ End Class
 Class C
 End Class
 "
-            VerifyPressingEnter(code, expected, autoGenerateXmlDocComments:=False)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected, autoGenerateXmlDocComments:=False)
+        End Function
 
         <WorkItem(540017)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_DontInsertApostrophes1()
+        Public Async Function TestPressingEnter_DontInsertApostrophes1() As Task
             Const code = "
 ''' <summary></summary>
 ''' $$
@@ -561,11 +562,11 @@ $$
 Class C
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_NotInsideConstructor()
+        Public Async Function TestPressingEnter_NotInsideConstructor() As Task
             Const code = "
 Class C
     Sub New()
@@ -581,12 +582,12 @@ $$
     End Sub
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(537534)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_NotInsideMethodBody()
+        Public Async Function TestPressingEnter_NotInsideMethodBody() As Task
             Const code = "
 Class C
     Sub Foo()
@@ -602,19 +603,19 @@ $$
     End Sub
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(537550)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_NotBeforeDocComment()
+        Public Async Function TestPressingEnter_NotBeforeDocComment() As Task
             Const code = "
     Class c1
 $$''' <summary>
         ''' 
         ''' </summary>
         ''' <returns></returns>
-        Public Sub Foo()
+Public Async Function TestFoo() As Task
             Dim x = 1
         End Sub
     End Class
@@ -626,17 +627,17 @@ $$''' <summary>
         ''' 
         ''' </summary>
         ''' <returns></returns>
-        Public Sub Foo()
+Public Async Function TestFoo() As Task
             Dim x = 1
         End Sub
     End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(2091, "https://github.com/dotnet/roslyn/issues/2091")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_InTextBeforeSpace()
+        Public Async Function TestPressingEnter_InTextBeforeSpace() As Task
             Const code = "
 Class C
     ''' <summary>
@@ -656,12 +657,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(2108, "https://github.com/dotnet/roslyn/issues/2108")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Indentation1()
+        Public Async Function TestPressingEnter_Indentation1() As Task
             Const code = "
 Class C
     ''' <summary>
@@ -681,12 +682,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(2108, "https://github.com/dotnet/roslyn/issues/2108")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Indentation2()
+        Public Async Function TestPressingEnter_Indentation2() As Task
             Const code = "
 Class C
     ''' <summary>
@@ -706,12 +707,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(2108, "https://github.com/dotnet/roslyn/issues/2108")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Indentation3()
+        Public Async Function TestPressingEnter_Indentation3() As Task
             Const code = "
 Class C
     ''' <summary>
@@ -731,12 +732,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(2108, "https://github.com/dotnet/roslyn/issues/2108")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Indentation4()
+        Public Async Function TestPressingEnter_Indentation4() As Task
             Const code = "
 Class C
     ''' <summary>
@@ -756,12 +757,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(2108, "https://github.com/dotnet/roslyn/issues/2108")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Indentation5_UseTabs()
+        Public Async Function TestPressingEnter_Indentation5_UseTabs() As Task
             Const code = "
 Class C
     ''' <summary>
@@ -781,12 +782,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyPressingEnter(code, expected, useTabs:=True)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected, useTabs:=True)
+        End Function
 
         <WorkItem(5486, "https://github.com/dotnet/roslyn/issues/5486")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Selection1()
+        Public Async Function TestPressingEnter_Selection1() As Task
             Const code = "
 ''' <summary>
 ''' Hello [|World|]$$!
@@ -802,12 +803,12 @@ End Class
 Class C
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WorkItem(5486, "https://github.com/dotnet/roslyn/issues/5486")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub PressingEnter_Selection2()
+        Public Async Function TestPressingEnter_Selection2() As Task
             Const code = "
 ''' <summary>
 ''' Hello $$[|World|]!
@@ -823,11 +824,11 @@ End Class
 Class C
 End Class
 "
-            VerifyPressingEnter(code, expected)
-        End Sub
+            Await VerifyPressingEnterAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub Command_Class()
+        Public Async Function TestCommand_Class() As Task
             Const code = "
 Class C
     $$
@@ -841,12 +842,12 @@ Class C
 
 End Class
 "
-            VerifyInsertCommentCommand(code, expected)
-        End Sub
+            Await VerifyInsertCommentCommandAsync(code, expected)
+        End Function
 
         <WorkItem(4817, "https://github.com/dotnet/roslyn/issues/4817")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub Command_Class_AutoGenerateXmlDocCommentsOff()
+        Public Async Function TestCommand_Class_AutoGenerateXmlDocCommentsOff() As Task
             Const code = "
 Class C
     $$
@@ -860,11 +861,11 @@ Class C
 
 End Class
 "
-            VerifyInsertCommentCommand(code, expected, autoGenerateXmlDocComments:=False)
-        End Sub
+            Await VerifyInsertCommentCommandAsync(code, expected, autoGenerateXmlDocComments:=False)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub Command_Class_NotIfCommentExists()
+        Public Async Function TestCommand_Class_NotIfCommentExists() As Task
             Const code = "
 ''' <summary></summary>
 Class C
@@ -877,12 +878,12 @@ Class C
     $$
 End Class
 "
-            VerifyInsertCommentCommand(code, expected)
-        End Sub
+            Await VerifyInsertCommentCommandAsync(code, expected)
+        End Function
 
         <WorkItem(538715)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub Command_Method1()
+        Public Async Function TestCommand_Method1() As Task
             Const code = "
 Class C
     Function F()$$
@@ -899,11 +900,11 @@ Class C
     End Function
 End Class
 "
-            VerifyInsertCommentCommand(code, expected)
-        End Sub
+            Await VerifyInsertCommentCommandAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub Command_Method2()
+        Public Async Function TestCommand_Method2() As Task
             Const code = "
 Class C
     Function M(Of T)(foo As Integer) As Integer
@@ -924,11 +925,11 @@ Class C
     End Function
 End Class
 "
-            VerifyInsertCommentCommand(code, expected)
-        End Sub
+            Await VerifyInsertCommentCommandAsync(code, expected)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub Command_Method_NotIfCommentExists()
+        Public Async Function TestCommand_Method_NotIfCommentExists() As Task
             Const code = "
 Class C
     ''' <summary></summary>
@@ -945,12 +946,12 @@ Class C
     End Function
 End Class
 "
-            VerifyInsertCommentCommand(code, expected)
-        End Sub
+            Await VerifyInsertCommentCommandAsync(code, expected)
+        End Function
 
         <WorkItem(538482)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub Command_FirstModuleOnLine()
+        Public Async Function TestCommand_FirstModuleOnLine() As Task
             Const code = "
 $$Module M : End Module : Module N : End Module
 "
@@ -961,21 +962,21 @@ $$Module M : End Module : Module N : End Module
 ''' </summary>
 Module M : End Module : Module N : End Module
 "
-            VerifyInsertCommentCommand(code, expected)
-        End Sub
+            Await VerifyInsertCommentCommandAsync(code, expected)
+        End Function
 
         <WorkItem(538482)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub Command_NotOnSecondModuleOnLine()
+        Public Async Function TestCommand_NotOnSecondModuleOnLine() As Task
             Const code = "Module M : End Module : $$Module N : End Module"
             Const expected = "Module M : End Module : $$Module N : End Module"
 
-            VerifyInsertCommentCommand(code, expected)
-        End Sub
+            Await VerifyInsertCommentCommandAsync(code, expected)
+        End Function
 
         <WorkItem(538482)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub Command_FirstPropertyOnLine()
+        Public Async Function TestCommand_FirstPropertyOnLine() As Task
             Const code = "
 Module M
     Property $$i As Integer : Property j As Integer
@@ -990,12 +991,12 @@ Module M
     Property i As Integer : Property j As Integer
 End Module
 "
-            VerifyInsertCommentCommand(code, expected)
-        End Sub
+            Await VerifyInsertCommentCommandAsync(code, expected)
+        End Function
 
         <WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TestOpenLineAbove1()
+        Public Async Function TestOpenLineAbove1() As Task
             Const code = "
 Class C
     ''' <summary>
@@ -1015,12 +1016,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyOpenLineAbove(code, expected)
-        End Sub
+            Await VerifyOpenLineAboveAsync(code, expected)
+        End Function
 
         <WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TestOpenLineAbove2()
+        Public Async Function TestOpenLineAbove2() As Task
             Const code = "
 Class C
     ''' <summary>
@@ -1040,12 +1041,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyOpenLineAbove(code, expected)
-        End Sub
+            Await VerifyOpenLineAboveAsync(code, expected)
+        End Function
 
         <WorkItem(538482)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub Command_NotOnSecondPropertyOnLine()
+        Public Sub TestCommand_NotOnSecondPropertyOnLine()
             Dim code =
                 StringFromLines("Module M",
                                 "    Property i As Integer : Property $$j As Integer",
@@ -1054,7 +1055,7 @@ End Class
 
         <WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TestOpenLineAbove3()
+        Public Async Function TestOpenLineAbove3() As Task
             Const code = "
 Class C
     ''' $$<summary>
@@ -1076,12 +1077,12 @@ $$
     End Sub
 End Class
 "
-            VerifyOpenLineAbove(code, expected)
-        End Sub
+            Await VerifyOpenLineAboveAsync(code, expected)
+        End Function
 
         <WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TestOpenLineAbove4_Tabs()
+        Public Async Function TestOpenLineAbove4_Tabs() As Task
             Const code = "
 Class C
 		  ''' <summary>
@@ -1101,12 +1102,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyOpenLineAbove(code, expected, useTabs:=True)
-        End Sub
+            Await VerifyOpenLineAboveAsync(code, expected, useTabs:=True)
+        End Function
 
         <WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TestOpenLineBelow1()
+        Public Async Function TestOpenLineBelow1() As Task
             Const code = "
 Class C
     ''' <summary>
@@ -1126,12 +1127,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyOpenLineBelow(code, expected)
-        End Sub
+            Await VerifyOpenLineBelowAsync(code, expected)
+        End Function
 
         <WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TestOpenLineBelow2()
+        Public Async Function TestOpenLineBelow2() As Task
             Const code = "
 Class C
     ''' <summary>
@@ -1151,12 +1152,12 @@ Class C
     End Sub
 End Class
 "
-            VerifyOpenLineBelow(code, expected)
-        End Sub
+            Await VerifyOpenLineBelowAsync(code, expected)
+        End Function
 
         <WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TestOpenLineBelow3()
+        Public Async Function TestOpenLineBelow3() As Task
             Const code = "
 ''' <summary>
 ''' stuff
@@ -1166,12 +1167,12 @@ End Class
 ''' stuff
 ''' </summary>
 ''' $$"
-            VerifyOpenLineBelow(code, expected)
-        End Sub
+            Await VerifyOpenLineBelowAsync(code, expected)
+        End Function
 
         <WorkItem(2090, "https://github.com/dotnet/roslyn/issues/2090")>
         <WpfFact, Trait(Traits.Feature, Traits.Features.DocumentationComments)>
-        Public Sub TestOpenLineBelow4_Tabs()
+        Public Async Function TestOpenLineBelow4_Tabs() As Task
             Const code = "
 Class C
     ''' <summary>
@@ -1191,8 +1192,8 @@ Class C
     End Sub
 End Class
 "
-            VerifyOpenLineBelow(code, expected, useTabs:=True)
-        End Sub
+            Await VerifyOpenLineBelowAsync(code, expected, useTabs:=True)
+        End Function
 
         Friend Overrides Function CreateCommandHandler(
             waitIndicator As IWaitIndicator,
@@ -1203,8 +1204,8 @@ End Class
             Return New DocumentationCommentCommandHandler(waitIndicator, undoHistoryRegistry, editorOperationsFactoryService, completionService)
         End Function
 
-        Protected Overrides Function CreateTestWorkspace(code As String) As TestWorkspace
-            Return VisualBasicWorkspaceFactory.CreateWorkspaceFromLines(code)
+        Protected Overrides Function CreateTestWorkspaceAsync(code As String) As Task(Of TestWorkspace)
+            Return VisualBasicWorkspaceFactory.CreateWorkspaceFromLinesAsync(code)
         End Function
 
         Protected Overrides ReadOnly Property DocumentationCommentCharacter As Char
diff --git a/src/EditorFeatures/VisualBasicTest/DocumentationComments/XmlTagCompletionTests.vb b/src/EditorFeatures/VisualBasicTest/DocumentationComments/XmlTagCompletionTests.vb
index 0ac85aa4542d63b7a10d48a638260bd18aa7c9f6..8246c94aa3764b0648b391b6c72373a5c2918650 100644
--- a/src/EditorFeatures/VisualBasicTest/DocumentationComments/XmlTagCompletionTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/DocumentationComments/XmlTagCompletionTests.vb
@@ -6,6 +6,7 @@ Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.Editor.VisualBasic.DocumentationComments
 Imports Microsoft.VisualStudio.Text.Operations
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Utilities
+Imports System.Threading.Tasks
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.DocumentationComments
     Public Class XmlTagCompletionTests
@@ -15,12 +16,12 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.DocumentationComme
             Return New XmlTagCompletionCommandHandler(undoHistory, TestWaitIndicator.Default)
         End Function
 
-        Protected Overrides Function CreateTestWorkspace(initialMarkup As String) As TestWorkspace
-            Return VisualBasicWorkspaceFactory.CreateWorkspaceFromLines(initialMarkup)
+        Protected Overrides Function CreateTestWorkspaceAsync(initialMarkup As String) As Threading.Tasks.Task(Of TestWorkspace)
+            Return VisualBasicWorkspaceFactory.CreateWorkspaceFromLinesAsync(initialMarkup)
         End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)>
-        Public Sub SimpleTagCompletion()
+        Public Async Function TestSimpleTagCompletion() As Task
 
             Dim text = <File><![CDATA[
 ''' <foo$$
@@ -32,11 +33,11 @@ End Class]]></File>
 Class C 
 End Class]]></File>
 
-            Verify(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
-        End Sub
+            Await VerifyAsync(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)>
-        Public Sub NestedTagCompletion()
+        Public Async Function TestNestedTagCompletion() As Task
 
             Dim text = <File><![CDATA[
 ''' <summary>
@@ -52,11 +53,11 @@ End Class]]></File>
 Class C 
 End Class]]></File>
 
-            Verify(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
-        End Sub
+            Await VerifyAsync(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)>
-        Public Sub CompleteBeforeIncompleteTag()
+        Public Async Function TestCompleteBeforeIncompleteTag() As Task
 
             Dim text = <File><![CDATA[
 ''' <foo$$
@@ -70,11 +71,11 @@ End Class]]></File>
 Class C 
 End Class]]></File>
 
-            Verify(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
-        End Sub
+            Await VerifyAsync(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)>
-        Public Sub NotEmptyElement()
+        Public Async Function TestNotEmptyElement() As Task
 
             Dim text = <File><![CDATA[
 ''' <$$
@@ -86,11 +87,11 @@ End Class]]></File>
 Class C 
 End Class]]></File>
 
-            Verify(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
-        End Sub
+            Await VerifyAsync(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)>
-        Public Sub NotAlreadyCompleteTag()
+        Public Async Function TestNotAlreadyCompleteTag() As Task
 
             Dim text = <File><![CDATA[
 ''' <foo$$</foo>
@@ -102,11 +103,11 @@ End Class]]></File>
 Class C 
 End Class]]></File>
 
-            Verify(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
-        End Sub
+            Await VerifyAsync(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)>
-        Public Sub NotAlreadyCompleteTag2()
+        Public Async Function TestNotAlreadyCompleteTag2() As Task
 
             Dim text = <File><![CDATA[
 ''' <foo$$
@@ -122,11 +123,11 @@ End Class]]></File>
 Class C 
 End Class]]></File>
 
-            Verify(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
-        End Sub
+            Await VerifyAsync(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
+        End Function
 
         <WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)>
-        Public Sub NotOutsideDocComment()
+        Public Async Function TestNotOutsideDocComment() As Task
 
             Dim text = <File><![CDATA[
 Class C
@@ -138,12 +139,12 @@ Class C
     DIm z = <foo>$$
 End Class]]></File>
 
-            Verify(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
-        End Sub
+            Await VerifyAsync(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), ">"c)
+        End Function
 
         <WorkItem(638235)>
         <WpfFact, Trait(Traits.Feature, Traits.Features.XmlTagCompletion)>
-        Public Sub NotCloseClosedTag()
+        Public Async Function TestNotCloseClosedTag() As Task
             Dim text = <File><![CDATA[
 ''' <summary>
 ''' <$$
@@ -158,8 +159,7 @@ End Class]]></File>
 Class C 
 End Class]]></File>
 
-            Verify(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), "/"c)
-        End Sub
+            Await VerifyAsync(text.ConvertTestSourceTag(), expected.ConvertTestSourceTag(), "/"c)
+        End Function
     End Class
-End Namespace
-
+End Namespace
\ No newline at end of file
diff --git a/src/VisualStudio/CSharp/Test/Debugging/DataTipInfoGetterTests.cs b/src/VisualStudio/CSharp/Test/Debugging/DataTipInfoGetterTests.cs
index 1e9791f3ed1237226725c6665bb02c97355543fd..568ebc592073271825ecc62f87ab3f12fcf01076 100644
--- a/src/VisualStudio/CSharp/Test/Debugging/DataTipInfoGetterTests.cs
+++ b/src/VisualStudio/CSharp/Test/Debugging/DataTipInfoGetterTests.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Text;
@@ -15,9 +16,9 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Debugging
 {
     public class DataTipInfoGetterTests
     {
-        private void Test(string markup, string expectedText = null)
+        private async Task TestAsync(string markup, string expectedText = null)
         {
-            TestSpanGetter(markup, (document, position, expectedSpan) =>
+            await TestSpanGetterAsync(markup, (document, position, expectedSpan) =>
             {
                 var result = DataTipInfoGetter.GetInfoAsync(document, position, CancellationToken.None).WaitAndGetResult(CancellationToken.None);
 
@@ -26,18 +27,18 @@ private void Test(string markup, string expectedText = null)
             });
         }
 
-        private void TestNoDataTip(string markup)
+        private async Task TestNoDataTipAsync(string markup)
         {
-            TestSpanGetter(markup, (document, position, expectedSpan) =>
+            await TestSpanGetterAsync(markup, (document, position, expectedSpan) =>
             {
                 var result = DataTipInfoGetter.GetInfoAsync(document, position, CancellationToken.None).WaitAndGetResult(CancellationToken.None);
                 Assert.True(result.IsDefault);
             });
         }
 
-        private void TestSpanGetter(string markup, Action<Document, int, TextSpan?> continuation)
+        private async Task TestSpanGetterAsync(string markup, Action<Document, int, TextSpan?> continuation)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(markup))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(markup))
             {
                 var testHostDocument = workspace.Documents.Single();
                 var position = testHostDocument.CursorPosition.Value;
@@ -53,19 +54,19 @@ private void TestSpanGetter(string markup, Action<Document, int, TextSpan?> cont
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestCSharpLanguageDebugInfoGetDataTipSpanAndText()
+        public async Task TestCSharpLanguageDebugInfoGetDataTipSpanAndText()
         {
-            Test("class [|C$$|] { }");
-            Test("struct [|C$$|] { }");
-            Test("interface [|C$$|] { }");
-            Test("enum [|C$$|] { }");
-            Test("delegate void [|C$$|] ();"); // Without the space, that position is actually on the open paren.
+            await TestAsync("class [|C$$|] { }");
+            await TestAsync("struct [|C$$|] { }");
+            await TestAsync("interface [|C$$|] { }");
+            await TestAsync("enum [|C$$|] { }");
+            await TestAsync("delegate void [|C$$|] ();"); // Without the space, that position is actually on the open paren.
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void Test1()
+        public async Task Test1()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo()
@@ -76,9 +77,9 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void Test2()
+        public async Task Test2()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo()
@@ -89,9 +90,9 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void Test3()
+        public async Task Test3()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo()
@@ -102,9 +103,9 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void Test4()
+        public async Task Test4()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo()
@@ -115,9 +116,9 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void Test5()
+        public async Task Test5()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo()
@@ -128,9 +129,9 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void Test6()
+        public async Task Test6()
         {
-            TestNoDataTip(
+            await TestNoDataTipAsync(
 @"class C
 {
   void Foo()
@@ -141,9 +142,9 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void Test7()
+        public async Task Test7()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo()
@@ -154,9 +155,9 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void Test8()
+        public async Task Test8()
         {
-            TestNoDataTip(
+            await TestNoDataTipAsync(
 @"class C
 {
   void Foo()
@@ -167,9 +168,9 @@ void Foo()
         }
 
         [WpfFact]
-        public void TestVar()
+        public async Task TestVar()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo()
@@ -180,9 +181,9 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestVariableType()
+        public async Task TestVariableType()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo()
@@ -193,9 +194,9 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestVariableIdentifier()
+        public async Task TestVariableIdentifier()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo()
@@ -207,9 +208,9 @@ void Foo()
 
         [WorkItem(539910)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestLiterals()
+        public async Task TestLiterals()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo()
@@ -220,9 +221,9 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestNonExpressions()
+        public async Task TestNonExpressions()
         {
-            TestNoDataTip(
+            await TestNoDataTipAsync(
 @"class C
 {
   void Foo()
@@ -233,9 +234,9 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestParameterIdentifier()
+        public async Task TestParameterIdentifier()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo(int [|$$i|])
@@ -246,9 +247,9 @@ void Foo(int [|$$i|])
 
         [WorkItem(942699)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestCatchIdentifier()
+        public async Task TestCatchIdentifier()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
     void Foo()
@@ -264,15 +265,15 @@ void Foo()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestEvent()
+        public async Task TestEvent()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
     event System.Action [|$$E|];
 }");
 
-            Test(
+            await TestAsync(
 @"class C
 {
     event System.Action [|$$E|]
@@ -284,9 +285,9 @@ public void TestEvent()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestMethod()
+        public async Task TestMethod()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
     int [|$$M|]() { }
@@ -294,10 +295,10 @@ public void TestMethod()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestTypeParameter()
+        public async Task TestTypeParameter()
         {
-            Test("class C<T, [|$$U|], V> { }");
-            Test(
+            await TestAsync("class C<T, [|$$U|], V> { }");
+            await TestAsync(
 @"class C
 {
     void M<T, [|$$U|]>() { }
@@ -305,9 +306,9 @@ public void TestTypeParameter()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void UsingAlias()
+        public async Task UsingAlias()
         {
-            Test(
+            await TestAsync(
 @"using [|$$S|] = Static;
 
 static class Static
@@ -317,9 +318,9 @@ static class Static
 
         [WorkItem(540921)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestForEachIdentifier()
+        public async Task TestForEachIdentifier()
         {
-            Test(
+            await TestAsync(
 @"class C
 {
   void Foo(string[] args)
@@ -333,9 +334,9 @@ void Foo(string[] args)
 
         [WorkItem(546328)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestProperty()
+        public async Task TestProperty()
         {
-            Test(
+            await TestAsync(
 @"namespace ConsoleApplication16
 {
     class C
@@ -362,9 +363,9 @@ static void Main(string[] args)
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips)]
-        public void TestQueryIdentifier()
+        public async Task TestQueryIdentifier()
         {
-            Test( // From
+            await TestAsync( // From
 @"class C
 {
     object Foo(string[] args)
@@ -372,7 +373,7 @@ object Foo(string[] args)
         return from [|$$a|] in args select a;
     }
 }");
-            Test( // Let
+            await TestAsync( // Let
 @"class C
 {
     object Foo(string[] args)
@@ -380,7 +381,7 @@ object Foo(string[] args)
         return from a in args let [|$$b|] = ""END"" select a + b;
     }
 }");
-            Test( // Join
+            await TestAsync( // Join
 @"class C
 {
     object Foo(string[] args)
@@ -388,7 +389,7 @@ object Foo(string[] args)
         return from a in args join [|$$b|] in args on a equals b;
     }
 }");
-            Test( // Join Into
+            await TestAsync( // Join Into
 @"class C
 {
     object Foo(string[] args)
@@ -396,7 +397,7 @@ object Foo(string[] args)
         return from a in args join b in args on a equals b into [|$$c|];
     }
 }");
-            Test( // Continuation
+            await TestAsync( // Continuation
 @"class C
 {
     object Foo(string[] args)
@@ -407,7 +408,7 @@ object Foo(string[] args)
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips), WorkItem(1077843)]
-        public void TestConditionalAccessExpression()
+        public async Task TestConditionalAccessExpression()
         {
             var sourceTemplate = @"
 class A
@@ -436,50 +437,50 @@ class D
 ";
 
             // One level.
-            Test(string.Format(sourceTemplate, "[|Me?.$$B|]"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.$$B|]"));
 
             // Two levels.
-            Test(string.Format(sourceTemplate, "[|Me?.$$B|].C"));
-            Test(string.Format(sourceTemplate, "[|Me?.B.$$C|]"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.$$B|].C"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.B.$$C|]"));
 
-            Test(string.Format(sourceTemplate, "[|Me.$$B|]?.C"));
-            Test(string.Format(sourceTemplate, "[|Me.B?.$$C|]"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me.$$B|]?.C"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me.B?.$$C|]"));
 
-            Test(string.Format(sourceTemplate, "[|Me?.$$B|]?.C"));
-            Test(string.Format(sourceTemplate, "[|Me?.B?.$$C|]"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.$$B|]?.C"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.B?.$$C|]"));
 
             // Three levels.
-            Test(string.Format(sourceTemplate, "[|Me?.$$B|].C.D"));
-            Test(string.Format(sourceTemplate, "[|Me?.B.$$C|].D"));
-            Test(string.Format(sourceTemplate, "[|Me?.B.C.$$D|]"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.$$B|].C.D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.B.$$C|].D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.B.C.$$D|]"));
 
-            Test(string.Format(sourceTemplate, "[|Me.$$B|]?.C.D"));
-            Test(string.Format(sourceTemplate, "[|Me.B?.$$C|].D"));
-            Test(string.Format(sourceTemplate, "[|Me.B?.C.$$D|]"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me.$$B|]?.C.D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me.B?.$$C|].D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me.B?.C.$$D|]"));
 
-            Test(string.Format(sourceTemplate, "[|Me.$$B|].C?.D"));
-            Test(string.Format(sourceTemplate, "[|Me.B.$$C|]?.D"));
-            Test(string.Format(sourceTemplate, "[|Me.B.C?.$$D|]"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me.$$B|].C?.D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me.B.$$C|]?.D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me.B.C?.$$D|]"));
 
-            Test(string.Format(sourceTemplate, "[|Me?.$$B|]?.C.D"));
-            Test(string.Format(sourceTemplate, "[|Me?.B?.$$C|].D"));
-            Test(string.Format(sourceTemplate, "[|Me?.B?.C.$$D|]"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.$$B|]?.C.D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.B?.$$C|].D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.B?.C.$$D|]"));
 
-            Test(string.Format(sourceTemplate, "[|Me?.$$B|].C?.D"));
-            Test(string.Format(sourceTemplate, "[|Me?.B.$$C|]?.D"));
-            Test(string.Format(sourceTemplate, "[|Me?.B.C?.$$D|]"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.$$B|].C?.D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.B.$$C|]?.D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.B.C?.$$D|]"));
 
-            Test(string.Format(sourceTemplate, "[|Me.$$B|]?.C?.D"));
-            Test(string.Format(sourceTemplate, "[|Me.B?.$$C|]?.D"));
-            Test(string.Format(sourceTemplate, "[|Me.B?.C?.$$D|]"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me.$$B|]?.C?.D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me.B?.$$C|]?.D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me.B?.C?.$$D|]"));
 
-            Test(string.Format(sourceTemplate, "[|Me?.$$B|]?.C?.D"));
-            Test(string.Format(sourceTemplate, "[|Me?.B?.$$C|]?.D"));
-            Test(string.Format(sourceTemplate, "[|Me?.B?.C?.$$D|]"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.$$B|]?.C?.D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.B?.$$C|]?.D"));
+            await TestAsync(string.Format(sourceTemplate, "[|Me?.B?.C?.$$D|]"));
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingDataTips), WorkItem(1077843)]
-        public void TestConditionalAccessExpression_Trivia()
+        public async Task TestConditionalAccessExpression_Trivia()
         {
             var sourceTemplate = @"
 class A
@@ -502,9 +503,9 @@ class C
 }}
 ";
 
-            Test(string.Format(sourceTemplate, "/*1*/[|$$Me|]/*2*/?./*3*/B/*4*/?./*5*/C/*6*/"));
-            Test(string.Format(sourceTemplate, "/*1*/[|Me/*2*/?./*3*/$$B|]/*4*/?./*5*/C/*6*/"));
-            Test(string.Format(sourceTemplate, "/*1*/[|Me/*2*/?./*3*/B/*4*/?./*5*/$$C|]/*6*/"));
+            await TestAsync(string.Format(sourceTemplate, "/*1*/[|$$Me|]/*2*/?./*3*/B/*4*/?./*5*/C/*6*/"));
+            await TestAsync(string.Format(sourceTemplate, "/*1*/[|Me/*2*/?./*3*/$$B|]/*4*/?./*5*/C/*6*/"));
+            await TestAsync(string.Format(sourceTemplate, "/*1*/[|Me/*2*/?./*3*/B/*4*/?./*5*/$$C|]/*6*/"));
         }
     }
 }
diff --git a/src/VisualStudio/CSharp/Test/Debugging/NameResolverTests.cs b/src/VisualStudio/CSharp/Test/Debugging/NameResolverTests.cs
index a247459f4127748d649297a809e6f0ddc4f22c0c..676478fa381e22edb01cb6a87b65f65bd9d6093b 100644
--- a/src/VisualStudio/CSharp/Test/Debugging/NameResolverTests.cs
+++ b/src/VisualStudio/CSharp/Test/Debugging/NameResolverTests.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServices.CSharp.Debugging;
@@ -14,9 +15,9 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Debugging
 {
     public class NameResolverTests
     {
-        private void Test(string text, string searchText, params string[] expectedNames)
+        private async Task TestAsync(string text, string searchText, params string[] expectedNames)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(text))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(text))
             {
                 var nameResolver = new BreakpointResolver(workspace.CurrentSolution, searchText);
                 var results = nameResolver.DoAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None);
@@ -26,9 +27,9 @@ private void Test(string text, string searchText, params string[] expectedNames)
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestCSharpLanguageDebugInfoCreateNameResolver()
+        public async Task TestCSharpLanguageDebugInfoCreateNameResolver()
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(" "))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(" "))
             {
                 var debugInfo = new CSharpBreakpointResolutionService();
                 var results = debugInfo.ResolveBreakpointsAsync(workspace.CurrentSolution, "foo", CancellationToken.None).WaitAndGetResult(CancellationToken.None);
@@ -37,7 +38,7 @@ public void TestCSharpLanguageDebugInfoCreateNameResolver()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestSimpleNameInClass()
+        public async Task TestSimpleNameInClass()
         {
             var text =
 @"class C
@@ -46,19 +47,19 @@ void Foo()
   {
   }
 }";
-            Test(text, "Foo", "C.Foo()");
-            Test(text, "foo");
-            Test(text, "C.Foo", "C.Foo()");
-            Test(text, "N.C.Foo");
-            Test(text, "Foo<T>");
-            Test(text, "C<T>.Foo");
-            Test(text, "Foo()", "C.Foo()");
-            Test(text, "Foo(int i)");
-            Test(text, "Foo(int)");
+            await TestAsync(text, "Foo", "C.Foo()");
+            await TestAsync(text, "foo");
+            await TestAsync(text, "C.Foo", "C.Foo()");
+            await TestAsync(text, "N.C.Foo");
+            await TestAsync(text, "Foo<T>");
+            await TestAsync(text, "C<T>.Foo");
+            await TestAsync(text, "Foo()", "C.Foo()");
+            await TestAsync(text, "Foo(int i)");
+            await TestAsync(text, "Foo(int)");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestSimpleNameInNamespace()
+        public async Task TestSimpleNameInNamespace()
         {
             var text =
 @"
@@ -71,22 +72,22 @@ void Foo()
     }
   }
 }";
-            Test(text, "Foo", "N.C.Foo()");
-            Test(text, "foo");
-            Test(text, "C.Foo", "N.C.Foo()");
-            Test(text, "N.C.Foo", "N.C.Foo()");
-            Test(text, "Foo<T>");
-            Test(text, "C<T>.Foo");
-            Test(text, "Foo()", "N.C.Foo()");
-            Test(text, "C.Foo()", "N.C.Foo()");
-            Test(text, "N.C.Foo()", "N.C.Foo()");
-            Test(text, "Foo(int i)");
-            Test(text, "Foo(int)");
-            Test(text, "Foo(a)");
+            await TestAsync(text, "Foo", "N.C.Foo()");
+            await TestAsync(text, "foo");
+            await TestAsync(text, "C.Foo", "N.C.Foo()");
+            await TestAsync(text, "N.C.Foo", "N.C.Foo()");
+            await TestAsync(text, "Foo<T>");
+            await TestAsync(text, "C<T>.Foo");
+            await TestAsync(text, "Foo()", "N.C.Foo()");
+            await TestAsync(text, "C.Foo()", "N.C.Foo()");
+            await TestAsync(text, "N.C.Foo()", "N.C.Foo()");
+            await TestAsync(text, "Foo(int i)");
+            await TestAsync(text, "Foo(int)");
+            await TestAsync(text, "Foo(a)");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestSimpleNameInGenericClassNamespace()
+        public async Task TestSimpleNameInGenericClassNamespace()
         {
             var text =
 @"
@@ -99,23 +100,23 @@ void Foo()
     }
   }
 }";
-            Test(text, "Foo", "N.C<T>.Foo()");
-            Test(text, "foo");
-            Test(text, "C.Foo", "N.C<T>.Foo()");
-            Test(text, "N.C.Foo", "N.C<T>.Foo()");
-            Test(text, "Foo<T>");
-            Test(text, "C<T>.Foo", "N.C<T>.Foo()");
-            Test(text, "C<T>.Foo()", "N.C<T>.Foo()");
-            Test(text, "Foo()", "N.C<T>.Foo()");
-            Test(text, "C.Foo()", "N.C<T>.Foo()");
-            Test(text, "N.C.Foo()", "N.C<T>.Foo()");
-            Test(text, "Foo(int i)");
-            Test(text, "Foo(int)");
-            Test(text, "Foo(a)");
+            await TestAsync(text, "Foo", "N.C<T>.Foo()");
+            await TestAsync(text, "foo");
+            await TestAsync(text, "C.Foo", "N.C<T>.Foo()");
+            await TestAsync(text, "N.C.Foo", "N.C<T>.Foo()");
+            await TestAsync(text, "Foo<T>");
+            await TestAsync(text, "C<T>.Foo", "N.C<T>.Foo()");
+            await TestAsync(text, "C<T>.Foo()", "N.C<T>.Foo()");
+            await TestAsync(text, "Foo()", "N.C<T>.Foo()");
+            await TestAsync(text, "C.Foo()", "N.C<T>.Foo()");
+            await TestAsync(text, "N.C.Foo()", "N.C<T>.Foo()");
+            await TestAsync(text, "Foo(int i)");
+            await TestAsync(text, "Foo(int)");
+            await TestAsync(text, "Foo(a)");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestGenericNameInClassNamespace()
+        public async Task TestGenericNameInClassNamespace()
         {
             var text =
 @"
@@ -128,28 +129,28 @@ void Foo<T>()
     }
   }
 }";
-            Test(text, "Foo", "N.C.Foo<T>()");
-            Test(text, "foo");
-            Test(text, "C.Foo", "N.C.Foo<T>()");
-            Test(text, "N.C.Foo", "N.C.Foo<T>()");
-            Test(text, "Foo<T>", "N.C.Foo<T>()");
-            Test(text, "Foo<X>", "N.C.Foo<T>()");
-            Test(text, "Foo<T,X>");
-            Test(text, "C<T>.Foo");
-            Test(text, "C<T>.Foo()");
-            Test(text, "Foo()", "N.C.Foo<T>()");
-            Test(text, "C.Foo()", "N.C.Foo<T>()");
-            Test(text, "N.C.Foo()", "N.C.Foo<T>()");
-            Test(text, "Foo(int i)");
-            Test(text, "Foo(int)");
-            Test(text, "Foo(a)");
-            Test(text, "Foo<T>(int i)");
-            Test(text, "Foo<T>(int)");
-            Test(text, "Foo<T>(a)");
+            await TestAsync(text, "Foo", "N.C.Foo<T>()");
+            await TestAsync(text, "foo");
+            await TestAsync(text, "C.Foo", "N.C.Foo<T>()");
+            await TestAsync(text, "N.C.Foo", "N.C.Foo<T>()");
+            await TestAsync(text, "Foo<T>", "N.C.Foo<T>()");
+            await TestAsync(text, "Foo<X>", "N.C.Foo<T>()");
+            await TestAsync(text, "Foo<T,X>");
+            await TestAsync(text, "C<T>.Foo");
+            await TestAsync(text, "C<T>.Foo()");
+            await TestAsync(text, "Foo()", "N.C.Foo<T>()");
+            await TestAsync(text, "C.Foo()", "N.C.Foo<T>()");
+            await TestAsync(text, "N.C.Foo()", "N.C.Foo<T>()");
+            await TestAsync(text, "Foo(int i)");
+            await TestAsync(text, "Foo(int)");
+            await TestAsync(text, "Foo(a)");
+            await TestAsync(text, "Foo<T>(int i)");
+            await TestAsync(text, "Foo<T>(int)");
+            await TestAsync(text, "Foo<T>(a)");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestOverloadsInSingleClass()
+        public async Task TestOverloadsInSingleClass()
         {
             var text =
 @"class C
@@ -162,20 +163,20 @@ void Foo(int i)
   {
   }
 }";
-            Test(text, "Foo", "C.Foo()", "C.Foo(int)");
-            Test(text, "foo");
-            Test(text, "C.Foo", "C.Foo()", "C.Foo(int)");
-            Test(text, "N.C.Foo");
-            Test(text, "Foo<T>");
-            Test(text, "C<T>.Foo");
-            Test(text, "Foo()", "C.Foo()");
-            Test(text, "Foo(int i)", "C.Foo(int)");
-            Test(text, "Foo(int)", "C.Foo(int)");
-            Test(text, "Foo(i)", "C.Foo(int)");
+            await TestAsync(text, "Foo", "C.Foo()", "C.Foo(int)");
+            await TestAsync(text, "foo");
+            await TestAsync(text, "C.Foo", "C.Foo()", "C.Foo(int)");
+            await TestAsync(text, "N.C.Foo");
+            await TestAsync(text, "Foo<T>");
+            await TestAsync(text, "C<T>.Foo");
+            await TestAsync(text, "Foo()", "C.Foo()");
+            await TestAsync(text, "Foo(int i)", "C.Foo(int)");
+            await TestAsync(text, "Foo(int)", "C.Foo(int)");
+            await TestAsync(text, "Foo(i)", "C.Foo(int)");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestMethodsInMultipleClasses()
+        public async Task TestMethodsInMultipleClasses()
         {
             var text =
 @"namespace N
@@ -197,21 +198,21 @@ void Foo(int i)
     }
   }
 }";
-            Test(text, "Foo", "N1.C.Foo(int)", "N.C.Foo()");
-            Test(text, "foo");
-            Test(text, "C.Foo", "N1.C.Foo(int)", "N.C.Foo()");
-            Test(text, "N.C.Foo", "N.C.Foo()");
-            Test(text, "N1.C.Foo", "N1.C.Foo(int)");
-            Test(text, "Foo<T>");
-            Test(text, "C<T>.Foo");
-            Test(text, "Foo()", "N.C.Foo()");
-            Test(text, "Foo(int i)", "N1.C.Foo(int)");
-            Test(text, "Foo(int)", "N1.C.Foo(int)");
-            Test(text, "Foo(i)", "N1.C.Foo(int)");
+            await TestAsync(text, "Foo", "N1.C.Foo(int)", "N.C.Foo()");
+            await TestAsync(text, "foo");
+            await TestAsync(text, "C.Foo", "N1.C.Foo(int)", "N.C.Foo()");
+            await TestAsync(text, "N.C.Foo", "N.C.Foo()");
+            await TestAsync(text, "N1.C.Foo", "N1.C.Foo(int)");
+            await TestAsync(text, "Foo<T>");
+            await TestAsync(text, "C<T>.Foo");
+            await TestAsync(text, "Foo()", "N.C.Foo()");
+            await TestAsync(text, "Foo(int i)", "N1.C.Foo(int)");
+            await TestAsync(text, "Foo(int)", "N1.C.Foo(int)");
+            await TestAsync(text, "Foo(i)", "N1.C.Foo(int)");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestMethodsWithDifferentArityInMultipleClasses()
+        public async Task TestMethodsWithDifferentArityInMultipleClasses()
         {
             var text =
 @"namespace N
@@ -233,25 +234,25 @@ void Foo<T>(int i)
     }
   }
 }";
-            Test(text, "Foo", "N1.C.Foo<T>(int)", "N.C.Foo()");
-            Test(text, "foo");
-            Test(text, "C.Foo", "N1.C.Foo<T>(int)", "N.C.Foo()");
-            Test(text, "N.C.Foo", "N.C.Foo()");
-            Test(text, "N1.C.Foo", "N1.C.Foo<T>(int)");
-            Test(text, "Foo<T>", "N1.C.Foo<T>(int)");
-            Test(text, "C<T>.Foo");
-            Test(text, "Foo()", "N.C.Foo()");
-            Test(text, "Foo<T>()");
-            Test(text, "Foo(int i)", "N1.C.Foo<T>(int)");
-            Test(text, "Foo(int)", "N1.C.Foo<T>(int)");
-            Test(text, "Foo(i)", "N1.C.Foo<T>(int)");
-            Test(text, "Foo<T>(int i)", "N1.C.Foo<T>(int)");
-            Test(text, "Foo<T>(int)", "N1.C.Foo<T>(int)");
-            Test(text, "Foo<T>(i)", "N1.C.Foo<T>(int)");
+            await TestAsync(text, "Foo", "N1.C.Foo<T>(int)", "N.C.Foo()");
+            await TestAsync(text, "foo");
+            await TestAsync(text, "C.Foo", "N1.C.Foo<T>(int)", "N.C.Foo()");
+            await TestAsync(text, "N.C.Foo", "N.C.Foo()");
+            await TestAsync(text, "N1.C.Foo", "N1.C.Foo<T>(int)");
+            await TestAsync(text, "Foo<T>", "N1.C.Foo<T>(int)");
+            await TestAsync(text, "C<T>.Foo");
+            await TestAsync(text, "Foo()", "N.C.Foo()");
+            await TestAsync(text, "Foo<T>()");
+            await TestAsync(text, "Foo(int i)", "N1.C.Foo<T>(int)");
+            await TestAsync(text, "Foo(int)", "N1.C.Foo<T>(int)");
+            await TestAsync(text, "Foo(i)", "N1.C.Foo<T>(int)");
+            await TestAsync(text, "Foo<T>(int i)", "N1.C.Foo<T>(int)");
+            await TestAsync(text, "Foo<T>(int)", "N1.C.Foo<T>(int)");
+            await TestAsync(text, "Foo<T>(i)", "N1.C.Foo<T>(int)");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestOverloadsWithMultipleParametersInSingleClass()
+        public async Task TestOverloadsWithMultipleParametersInSingleClass()
         {
             var text =
 @"class C
@@ -268,32 +269,32 @@ void Foo(__arglist)
   {
   }
 }";
-            Test(text, "Foo", "C.Foo(int)", "C.Foo(int, [string])", "C.Foo(__arglist)");
-            Test(text, "foo");
-            Test(text, "C.Foo", "C.Foo(int)", "C.Foo(int, [string])", "C.Foo(__arglist)");
-            Test(text, "N.C.Foo");
-            Test(text, "Foo<T>");
-            Test(text, "C<T>.Foo");
-            Test(text, "Foo()", "C.Foo(__arglist)");
-            Test(text, "Foo(int i)", "C.Foo(int)");
-            Test(text, "Foo(int)", "C.Foo(int)");
-            Test(text, "Foo(int x = 42)", "C.Foo(int)");
-            Test(text, "Foo(i)", "C.Foo(int)");
-            Test(text, "Foo(int i, int b)", "C.Foo(int, [string])");
-            Test(text, "Foo(int, bool)", "C.Foo(int, [string])");
-            Test(text, "Foo(i, s)", "C.Foo(int, [string])");
-            Test(text, "Foo(,)", "C.Foo(int, [string])");
-            Test(text, "Foo(int x = 42,)", "C.Foo(int, [string])");
-            Test(text, "Foo(int x = 42, y = 42)", "C.Foo(int, [string])");
-            Test(text, "Foo([attr] x = 42, y = 42)", "C.Foo(int, [string])");
-            Test(text, "Foo(int i, int b, char c)");
-            Test(text, "Foo(int, bool, char)");
-            Test(text, "Foo(i, s, c)");
-            Test(text, "Foo(__arglist)", "C.Foo(int)");
+            await TestAsync(text, "Foo", "C.Foo(int)", "C.Foo(int, [string])", "C.Foo(__arglist)");
+            await TestAsync(text, "foo");
+            await TestAsync(text, "C.Foo", "C.Foo(int)", "C.Foo(int, [string])", "C.Foo(__arglist)");
+            await TestAsync(text, "N.C.Foo");
+            await TestAsync(text, "Foo<T>");
+            await TestAsync(text, "C<T>.Foo");
+            await TestAsync(text, "Foo()", "C.Foo(__arglist)");
+            await TestAsync(text, "Foo(int i)", "C.Foo(int)");
+            await TestAsync(text, "Foo(int)", "C.Foo(int)");
+            await TestAsync(text, "Foo(int x = 42)", "C.Foo(int)");
+            await TestAsync(text, "Foo(i)", "C.Foo(int)");
+            await TestAsync(text, "Foo(int i, int b)", "C.Foo(int, [string])");
+            await TestAsync(text, "Foo(int, bool)", "C.Foo(int, [string])");
+            await TestAsync(text, "Foo(i, s)", "C.Foo(int, [string])");
+            await TestAsync(text, "Foo(,)", "C.Foo(int, [string])");
+            await TestAsync(text, "Foo(int x = 42,)", "C.Foo(int, [string])");
+            await TestAsync(text, "Foo(int x = 42, y = 42)", "C.Foo(int, [string])");
+            await TestAsync(text, "Foo([attr] x = 42, y = 42)", "C.Foo(int, [string])");
+            await TestAsync(text, "Foo(int i, int b, char c)");
+            await TestAsync(text, "Foo(int, bool, char)");
+            await TestAsync(text, "Foo(i, s, c)");
+            await TestAsync(text, "Foo(__arglist)", "C.Foo(int)");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void AccessorTests()
+        public async Task AccessorTests()
         {
             var text =
 @"class C
@@ -302,13 +303,13 @@ public void AccessorTests()
   int Property2 { set { } }
   int Property3 { get; set;}
 }";
-            Test(text, "Property1", "C.Property1");
-            Test(text, "Property2", "C.Property2");
-            Test(text, "Property3", "C.Property3");
+            await TestAsync(text, "Property1", "C.Property1");
+            await TestAsync(text, "Property2", "C.Property2");
+            await TestAsync(text, "Property3", "C.Property3");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void NegativeTests()
+        public async Task NegativeTests()
         {
             var text =
 @"using System.Runtime.CompilerServices;
@@ -324,41 +325,41 @@ abstract class C
     void Foo(int x = 1, int y = 2) { }
     ~C() { }
 }";
-            Test(text, "AbstractMethod");
-            Test(text, "Field");
-            Test(text, "Delegate");
-            Test(text, "Event");
-            Test(text, "this");
-            Test(text, "C.this[int]");
-            Test(text, "C.get_Item");
-            Test(text, "C.get_Item(i)");
-            Test(text, "C[i]");
-            Test(text, "ABCD");
-            Test(text, "C.ABCD(int)");
-            Test(text, "42");
-            Test(text, "Foo", "C.Foo()", "C.Foo([int], [int])"); // just making sure it would normally resolve before trying bad syntax
-            Test(text, "Foo Foo");
-            Test(text, "Foo()asdf");
-            Test(text, "Foo(),");
-            Test(text, "Foo(),f");
-            Test(text, "Foo().Foo");
-            Test(text, "Foo(");
-            Test(text, "(Foo");
-            Test(text, "Foo)");
-            Test(text, "(Foo)");
-            Test(text, "Foo(x = 42, y = 42)", "C.Foo([int], [int])"); // just making sure it would normally resolve before trying bad syntax
-            Test(text, "int x = 42");
-            Test(text, "Foo(int x = 42, y = 42");
-            Test(text, "C");
-            Test(text, "C.C");
-            Test(text, "~");
-            Test(text, "~C");
-            Test(text, "C.~C()");
-            Test(text, "");
+            await TestAsync(text, "AbstractMethod");
+            await TestAsync(text, "Field");
+            await TestAsync(text, "Delegate");
+            await TestAsync(text, "Event");
+            await TestAsync(text, "this");
+            await TestAsync(text, "C.this[int]");
+            await TestAsync(text, "C.get_Item");
+            await TestAsync(text, "C.get_Item(i)");
+            await TestAsync(text, "C[i]");
+            await TestAsync(text, "ABCD");
+            await TestAsync(text, "C.ABCD(int)");
+            await TestAsync(text, "42");
+            await TestAsync(text, "Foo", "C.Foo()", "C.Foo([int], [int])"); // just making sure it would normally resolve before trying bad syntax
+            await TestAsync(text, "Foo Foo");
+            await TestAsync(text, "Foo()asdf");
+            await TestAsync(text, "Foo(),");
+            await TestAsync(text, "Foo(),f");
+            await TestAsync(text, "Foo().Foo");
+            await TestAsync(text, "Foo(");
+            await TestAsync(text, "(Foo");
+            await TestAsync(text, "Foo)");
+            await TestAsync(text, "(Foo)");
+            await TestAsync(text, "Foo(x = 42, y = 42)", "C.Foo([int], [int])"); // just making sure it would normally resolve before trying bad syntax
+            await TestAsync(text, "int x = 42");
+            await TestAsync(text, "Foo(int x = 42, y = 42");
+            await TestAsync(text, "C");
+            await TestAsync(text, "C.C");
+            await TestAsync(text, "~");
+            await TestAsync(text, "~C");
+            await TestAsync(text, "C.~C()");
+            await TestAsync(text, "");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestInstanceConstructors()
+        public async Task TestInstanceConstructors()
         {
             var text =
 @"class C
@@ -371,35 +372,35 @@ class G<T>
   public G() { }
   ~G() { }
 }";
-            Test(text, "C", "C.C()");
-            Test(text, "C.C", "C.C()");
-            Test(text, "C.C()", "C.C()");
-            Test(text, "C()", "C.C()");
-            Test(text, "C<T>");
-            Test(text, "C<T>()");
-            Test(text, "C(int i)");
-            Test(text, "C(int)");
-            Test(text, "C(i)");
-            Test(text, "G", "G<T>.G()");
-            Test(text, "G()", "G<T>.G()");
-            Test(text, "G.G", "G<T>.G()");
-            Test(text, "G.G()", "G<T>.G()");
-            Test(text, "G<T>.G", "G<T>.G()");
-            Test(text, "G<t>.G()", "G<T>.G()");
-            Test(text, "G<T>");
-            Test(text, "G<T>()");
-            Test(text, "G.G<T>");
-            Test(text, ".ctor");
-            Test(text, ".ctor()");
-            Test(text, "C.ctor");
-            Test(text, "C.ctor()");
-            Test(text, "G.ctor");
-            Test(text, "G<T>.ctor()");
-            Test(text, "Finalize", "G<T>.~G()");
+            await TestAsync(text, "C", "C.C()");
+            await TestAsync(text, "C.C", "C.C()");
+            await TestAsync(text, "C.C()", "C.C()");
+            await TestAsync(text, "C()", "C.C()");
+            await TestAsync(text, "C<T>");
+            await TestAsync(text, "C<T>()");
+            await TestAsync(text, "C(int i)");
+            await TestAsync(text, "C(int)");
+            await TestAsync(text, "C(i)");
+            await TestAsync(text, "G", "G<T>.G()");
+            await TestAsync(text, "G()", "G<T>.G()");
+            await TestAsync(text, "G.G", "G<T>.G()");
+            await TestAsync(text, "G.G()", "G<T>.G()");
+            await TestAsync(text, "G<T>.G", "G<T>.G()");
+            await TestAsync(text, "G<t>.G()", "G<T>.G()");
+            await TestAsync(text, "G<T>");
+            await TestAsync(text, "G<T>()");
+            await TestAsync(text, "G.G<T>");
+            await TestAsync(text, ".ctor");
+            await TestAsync(text, ".ctor()");
+            await TestAsync(text, "C.ctor");
+            await TestAsync(text, "C.ctor()");
+            await TestAsync(text, "G.ctor");
+            await TestAsync(text, "G<T>.ctor()");
+            await TestAsync(text, "Finalize", "G<T>.~G()");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestStaticConstructors()
+        public async Task TestStaticConstructors()
         {
             var text =
 @"class C
@@ -408,21 +409,21 @@ static C()
   {
   }
 }";
-            Test(text, "C", "C.C()");
-            Test(text, "C.C", "C.C()");
-            Test(text, "C.C()", "C.C()");
-            Test(text, "C()", "C.C()");
-            Test(text, "C<T>");
-            Test(text, "C<T>()");
-            Test(text, "C(int i)");
-            Test(text, "C(int)");
-            Test(text, "C(i)");
-            Test(text, "C.cctor");
-            Test(text, "C.cctor()");
+            await TestAsync(text, "C", "C.C()");
+            await TestAsync(text, "C.C", "C.C()");
+            await TestAsync(text, "C.C()", "C.C()");
+            await TestAsync(text, "C()", "C.C()");
+            await TestAsync(text, "C<T>");
+            await TestAsync(text, "C<T>()");
+            await TestAsync(text, "C(int i)");
+            await TestAsync(text, "C(int)");
+            await TestAsync(text, "C(i)");
+            await TestAsync(text, "C.cctor");
+            await TestAsync(text, "C.cctor()");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestAllConstructors()
+        public async Task TestAllConstructors()
         {
             var text =
 @"class C
@@ -435,19 +436,19 @@ public C(int i)
   {
   }
 }";
-            Test(text, "C", "C.C(int)", "C.C()");
-            Test(text, "C.C", "C.C(int)", "C.C()");
-            Test(text, "C.C()", "C.C()");
-            Test(text, "C()", "C.C()");
-            Test(text, "C<T>");
-            Test(text, "C<T>()");
-            Test(text, "C(int i)", "C.C(int)");
-            Test(text, "C(int)", "C.C(int)");
-            Test(text, "C(i)", "C.C(int)");
+            await TestAsync(text, "C", "C.C(int)", "C.C()");
+            await TestAsync(text, "C.C", "C.C(int)", "C.C()");
+            await TestAsync(text, "C.C()", "C.C()");
+            await TestAsync(text, "C()", "C.C()");
+            await TestAsync(text, "C<T>");
+            await TestAsync(text, "C<T>()");
+            await TestAsync(text, "C(int i)", "C.C(int)");
+            await TestAsync(text, "C(int)", "C.C(int)");
+            await TestAsync(text, "C(i)", "C.C(int)");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestPartialMethods()
+        public async Task TestPartialMethods()
         {
             var text =
 @"partial class C
@@ -464,36 +465,36 @@ public void TestPartialMethods()
 
   partial void M4() { }
 }";
-            Test(text, "M1");
-            Test(text, "C.M1");
-            Test(text, "M2", "C.M2()");
-            Test(text, "M3", "C.M3(int)");
-            Test(text, "M3()");
-            Test(text, "M3(y)", "C.M3(int)");
-            Test(text, "M4", "C.M4()");
+            await TestAsync(text, "M1");
+            await TestAsync(text, "C.M1");
+            await TestAsync(text, "M2", "C.M2()");
+            await TestAsync(text, "M3", "C.M3(int)");
+            await TestAsync(text, "M3()");
+            await TestAsync(text, "M3(y)", "C.M3(int)");
+            await TestAsync(text, "M4", "C.M4()");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestLeadingAndTrailingText()
+        public async Task TestLeadingAndTrailingText()
         {
             var text =
 @"class C
 {
   void Foo() { };
 }";
-            Test(text, "Foo;", "C.Foo()");
-            Test(text, "Foo();", "C.Foo()");
-            Test(text, "  Foo;", "C.Foo()");
-            Test(text, "  Foo;;");
-            Test(text, "  Foo; ;");
-            Test(text, "Foo(); ", "C.Foo()");
-            Test(text, " Foo (  )  ; ", "C.Foo()");
-            Test(text, "Foo(); // comment", "C.Foo()");
-            Test(text, "/*comment*/Foo(/* params */); /* comment", "C.Foo()");
+            await TestAsync(text, "Foo;", "C.Foo()");
+            await TestAsync(text, "Foo();", "C.Foo()");
+            await TestAsync(text, "  Foo;", "C.Foo()");
+            await TestAsync(text, "  Foo;;");
+            await TestAsync(text, "  Foo; ;");
+            await TestAsync(text, "Foo(); ", "C.Foo()");
+            await TestAsync(text, " Foo (  )  ; ", "C.Foo()");
+            await TestAsync(text, "Foo(); // comment", "C.Foo()");
+            await TestAsync(text, "/*comment*/Foo(/* params */); /* comment", "C.Foo()");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestEscapedKeywords()
+        public async Task TestEscapedKeywords()
         {
             var text =
 @"struct @true { }
@@ -502,17 +503,17 @@ class @foreach
     void where(@true @this) { }
     void @false() { }
 }";
-            Test(text, "where", "@foreach.where(@true)");
-            Test(text, "@where", "@foreach.where(@true)");
-            Test(text, "@foreach.where", "@foreach.where(@true)");
-            Test(text, "foreach.where");
-            Test(text, "@foreach.where(true)");
-            Test(text, "@foreach.where(@if)", "@foreach.where(@true)");
-            Test(text, "false");
+            await TestAsync(text, "where", "@foreach.where(@true)");
+            await TestAsync(text, "@where", "@foreach.where(@true)");
+            await TestAsync(text, "@foreach.where", "@foreach.where(@true)");
+            await TestAsync(text, "foreach.where");
+            await TestAsync(text, "@foreach.where(true)");
+            await TestAsync(text, "@foreach.where(@if)", "@foreach.where(@true)");
+            await TestAsync(text, "false");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestAliasQualifiedNames()
+        public async Task TestAliasQualifiedNames()
         {
             var text =
 @"extern alias A
@@ -520,15 +521,15 @@ class C
 {
     void Foo(D d) { }
 }";
-            Test(text, "A::Foo");
-            Test(text, "A::Foo(A::B)");
-            Test(text, "A::Foo(A::B)");
-            Test(text, "A::C.Foo");
-            Test(text, "C.Foo(A::Q)", "C.Foo(D)");
+            await TestAsync(text, "A::Foo");
+            await TestAsync(text, "A::Foo(A::B)");
+            await TestAsync(text, "A::Foo(A::B)");
+            await TestAsync(text, "A::C.Foo");
+            await TestAsync(text, "C.Foo(A::Q)", "C.Foo(D)");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestNestedTypesAndNamespaces()
+        public async Task TestNestedTypesAndNamespaces()
         {
             var text =
 @"namespace N1
@@ -565,17 +566,17 @@ class E
   namespace N5 { }
 }";
 
-            Test(text, "Foo", "N1.N4.C.Foo(double)", "N1.N4.C.D.Foo()", "N1.N4.C.D.E.Foo()", "N1.C.Foo()");
-            Test(text, "C.Foo", "N1.N4.C.Foo(double)", "N1.C.Foo()");
-            Test(text, "D.Foo", "N1.N4.C.D.Foo()");
-            Test(text, "N1.N4.C.D.Foo", "N1.N4.C.D.Foo()");
-            Test(text, "N1.Foo");
-            Test(text, "N3.C.Foo");
-            Test(text, "N5.C.Foo");
+            await TestAsync(text, "Foo", "N1.N4.C.Foo(double)", "N1.N4.C.D.Foo()", "N1.N4.C.D.E.Foo()", "N1.C.Foo()");
+            await TestAsync(text, "C.Foo", "N1.N4.C.Foo(double)", "N1.C.Foo()");
+            await TestAsync(text, "D.Foo", "N1.N4.C.D.Foo()");
+            await TestAsync(text, "N1.N4.C.D.Foo", "N1.N4.C.D.Foo()");
+            await TestAsync(text, "N1.Foo");
+            await TestAsync(text, "N3.C.Foo");
+            await TestAsync(text, "N5.C.Foo");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingNameResolver)]
-        public void TestInterfaces()
+        public async Task TestInterfaces()
         {
             var text =
 @"interface I1
@@ -587,10 +588,10 @@ class C1 : I1
   void I1.Foo() { }
 }";
 
-            Test(text, "Foo", "C1.Foo()");
-            Test(text, "I1.Foo");
-            Test(text, "C1.Foo", "C1.Foo()");
-            Test(text, "C1.I1.Moo");
+            await TestAsync(text, "Foo", "C1.Foo()");
+            await TestAsync(text, "I1.Foo");
+            await TestAsync(text, "C1.Foo", "C1.Foo()");
+            await TestAsync(text, "C1.I1.Moo");
         }
     }
 }
diff --git a/src/VisualStudio/CSharp/Test/Debugging/ProximityExpressionsGetterTests.cs b/src/VisualStudio/CSharp/Test/Debugging/ProximityExpressionsGetterTests.cs
index 5b562621fd49ac3414dd8e32b6102f9522594b38..4085c56c326b5276ee8d470961acf9bc723cc2f3 100644
--- a/src/VisualStudio/CSharp/Test/Debugging/ProximityExpressionsGetterTests.cs
+++ b/src/VisualStudio/CSharp/Test/Debugging/ProximityExpressionsGetterTests.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
@@ -31,12 +32,12 @@ private SyntaxTree GetTreeFromCode(string code)
             return SyntaxFactory.ParseSyntaxTree(code);
         }
 
-        public void GenerateBaseline()
+        public async Task GenerateBaseline()
         {
             Console.WriteLine(typeof(FactAttribute));
 
             var text = Resources.ProximityExpressionsGetterTestFile;
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(text))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(text))
             {
                 var languageDebugInfo = new CSharpLanguageDebugInfoService();
 
@@ -119,11 +120,11 @@ static void Main(string[] args)
             AssertEx.Equal(new[] { "yy", "xx" }, terms);
         }
 
-        private void TestProximityExpressionGetter(
+        private async Task TestProximityExpressionGetterAsync(
             string markup,
             Action<CSharpProximityExpressionsService, Document, int> continuation)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(markup))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(markup))
             {
                 var testDocument = workspace.Documents.Single();
                 var caretPosition = testDocument.CursorPosition.Value;
@@ -137,9 +138,9 @@ static void Main(string[] args)
             }
         }
 
-        private void TestTryDo(string input, params string[] expectedTerms)
+        private async Task TestTryDoAsync(string input, params string[] expectedTerms)
         {
-            TestProximityExpressionGetter(input, (getter, document, position) =>
+            await TestProximityExpressionGetterAsync(input, (getter, document, position) =>
             {
                 var actualTerms = getter.GetProximityExpressionsAsync(document, position, CancellationToken.None).Result;
 
@@ -151,9 +152,9 @@ private void TestTryDo(string input, params string[] expectedTerms)
             });
         }
 
-        private void TestIsValid(string input, string expression, bool expectedValid)
+        private async Task TestIsValidAsync(string input, string expression, bool expectedValid)
         {
-            TestProximityExpressionGetter(input, (getter, semanticSnapshot, position) =>
+            await TestProximityExpressionGetterAsync(input, (getter, semanticSnapshot, position) =>
             {
                 var actualValid = getter.IsValidAsync(semanticSnapshot, position, expression, CancellationToken.None).Result;
                 Assert.Equal(expectedValid, actualValid);
@@ -161,58 +162,58 @@ private void TestIsValid(string input, string expression, bool expectedValid)
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestTryDo1()
+        public async Task TestTryDo1()
         {
-            TestTryDo("class Class { void Method() { string local;$$ } }", "local", "this");
+            await TestTryDoAsync("class Class { void Method() { string local;$$ } }", "local", "this");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestNoParentToken()
+        public async Task TestNoParentToken()
         {
-            TestTryDo("$$");
+            await TestTryDoAsync("$$");
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestIsValid1()
+        public async Task TestIsValid1()
         {
-            TestIsValid("class Class { void Method() { string local;$$ } }", "local", true);
+            await TestIsValidAsync("class Class { void Method() { string local;$$ } }", "local", true);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestIsValidWithDiagnostics()
+        public async Task TestIsValidWithDiagnostics()
         {
             // local doesn't exist in this context
-            TestIsValid("class Class { void Method() { string local; } $$}", "local", false);
+            await TestIsValidAsync("class Class { void Method() { string local; } $$}", "local", false);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestIsValidReferencingLocalBeforeDeclaration()
+        public async Task TestIsValidReferencingLocalBeforeDeclaration()
         {
-            TestIsValid("class Class { void Method() { $$int i; int j; } }", "j", false);
+            await TestIsValidAsync("class Class { void Method() { $$int i; int j; } }", "j", false);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestIsValidReferencingUndefinedVariable()
+        public async Task TestIsValidReferencingUndefinedVariable()
         {
-            TestIsValid("class Class { void Method() { $$int i; int j; } }", "k", false);
+            await TestIsValidAsync("class Class { void Method() { $$int i; int j; } }", "k", false);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestIsValidNoTypeSymbol()
+        public async Task TestIsValidNoTypeSymbol()
         {
-            TestIsValid("namespace Namespace$$ { }", "foo", false);
+            await TestIsValidAsync("namespace Namespace$$ { }", "foo", false);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestIsValidLocalAfterPosition()
+        public async Task TestIsValidLocalAfterPosition()
         {
-            TestIsValid("class Class { void Method() { $$ int i; string local; } }", "local", false);
+            await TestIsValidAsync("class Class { void Method() { $$ int i; string local; } }", "local", false);
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestThis()
+        public async Task TestThis()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     public Class() : this(true) 
@@ -224,9 +225,9 @@ public Class() : this(true)
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestArrayCreationExpression()
+        public async Task TestArrayCreationExpression()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -237,9 +238,9 @@ void Method()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestPostfixUnaryExpressionSyntax()
+        public async Task TestPostfixUnaryExpressionSyntax()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -251,9 +252,9 @@ void Method()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestLabeledStatement()
+        public async Task TestLabeledStatement()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -265,9 +266,9 @@ void Method()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestThrowStatement()
+        public async Task TestThrowStatement()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     static void Method()
@@ -279,9 +280,9 @@ static void Method()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestDoStatement()
+        public async Task TestDoStatement()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     static void Method()
@@ -292,9 +293,9 @@ static void Method()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestLockStatement()
+        public async Task TestLockStatement()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     static void Method()
@@ -305,9 +306,9 @@ static void Method()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestWhileStatement()
+        public async Task TestWhileStatement()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     static void Method()
@@ -318,9 +319,9 @@ static void Method()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestForStatementWithDeclarators()
+        public async Task TestForStatementWithDeclarators()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     static void Method()
@@ -331,9 +332,9 @@ static void Method()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestForStatementWithInitializers()
+        public async Task TestForStatementWithInitializers()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     static void Method()
@@ -345,9 +346,9 @@ static void Method()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestUsingStatement()
+        public async Task TestUsingStatement()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -359,9 +360,9 @@ void Method()
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
         [WorkItem(538879)]
-        public void TestValueInPropertySetter()
+        public async Task TestValueInPropertySetter()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     string Name
@@ -373,9 +374,9 @@ string Name
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestValueInEventAdd()
+        public async Task TestValueInEventAdd()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     event Action Event
@@ -387,9 +388,9 @@ class Class
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestValueInEventRemove()
+        public async Task TestValueInEventRemove()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     event Action Event
@@ -402,9 +403,9 @@ class Class
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
         [WorkItem(538880)]
-        public void TestValueInIndexerSetter()
+        public async Task TestValueInIndexerSetter()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     string this[int index]
@@ -417,9 +418,9 @@ class Class
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
         [WorkItem(538881)]
-        public void TestCatchBlock()
+        public async Task TestCatchBlock()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -432,9 +433,9 @@ void Method()
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
         [WorkItem(538881)]
-        public void TestCatchBlockEmpty_OpenBrace()
+        public async Task TestCatchBlockEmpty_OpenBrace()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -446,9 +447,9 @@ void Method()
         }
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestCatchBlockEmpty_CloseBrace()
+        public async Task TestCatchBlockEmpty_CloseBrace()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -461,9 +462,9 @@ void Method()
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
         [WorkItem(538874)]
-        public void TestObjectCreation()
+        public async Task TestObjectCreation()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     void Method()
@@ -475,9 +476,9 @@ void Method()
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
         [WorkItem(538874)]
-        public void Test2()
+        public async Task Test2()
         {
-            TestIsValid(@"
+            await TestIsValidAsync(@"
 class D
 {
    private static int x;
@@ -494,9 +495,9 @@ void Method()
 
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
         [WorkItem(538890)]
-        public void TestArrayCreation()
+        public async Task TestArrayCreation()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Class 
 {
     int a;
@@ -509,9 +510,9 @@ void Method()
 
         [WorkItem(751141)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void Bug751141()
+        public async Task Bug751141()
         {
-            TestTryDo(@"
+            await TestTryDoAsync(@"
 class Program
 {
     double m_double = 1.1;
@@ -530,9 +531,9 @@ void M()
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ForLoopExpressionsInFirstStatementOfLoop1()
+        public async Task ForLoopExpressionsInFirstStatementOfLoop1()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -546,9 +547,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ForLoopExpressionsInFirstStatementOfLoop2()
+        public async Task ForLoopExpressionsInFirstStatementOfLoop2()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -565,9 +566,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ForLoopExpressionsInFirstStatementOfLoop3()
+        public async Task ForLoopExpressionsInFirstStatementOfLoop3()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -584,9 +585,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ForLoopExpressionsInFirstStatementOfLoop4()
+        public async Task ForLoopExpressionsInFirstStatementOfLoop4()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -600,9 +601,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ForEachLoopExpressionsInFirstStatementOfLoop1()
+        public async Task ForEachLoopExpressionsInFirstStatementOfLoop1()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -616,9 +617,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ForEachLoopExpressionsInFirstStatementOfLoop2()
+        public async Task ForEachLoopExpressionsInFirstStatementOfLoop2()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -630,9 +631,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterForLoop1()
+        public async Task ExpressionsAfterForLoop1()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -651,9 +652,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterForLoop2()
+        public async Task ExpressionsAfterForLoop2()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -672,9 +673,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterForEachLoop()
+        public async Task ExpressionsAfterForEachLoop()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -693,9 +694,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterNestedForLoop()
+        public async Task ExpressionsAfterNestedForLoop()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -719,9 +720,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterCheckedStatement()
+        public async Task ExpressionsAfterCheckedStatement()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -740,9 +741,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterUncheckedStatement()
+        public async Task ExpressionsAfterUncheckedStatement()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -761,9 +762,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterIfStatement()
+        public async Task ExpressionsAfterIfStatement()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -782,9 +783,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterIfStatementWithElse()
+        public async Task ExpressionsAfterIfStatementWithElse()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -808,9 +809,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterLockStatement()
+        public async Task ExpressionsAfterLockStatement()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -829,9 +830,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterSwitchStatement()
+        public async Task ExpressionsAfterSwitchStatement()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -860,9 +861,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterTryStatement()
+        public async Task ExpressionsAfterTryStatement()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -891,9 +892,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterTryStatementWithFinally()
+        public async Task ExpressionsAfterTryStatementWithFinally()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -926,9 +927,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterUsingStatement()
+        public async Task ExpressionsAfterUsingStatement()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -947,9 +948,9 @@ static void Main(string[] args)
 
         [WorkItem(775161)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsAfterWhileStatement()
+        public async Task ExpressionsAfterWhileStatement()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
@@ -968,9 +969,9 @@ static void Main(string[] args)
 
         [WorkItem(778215)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void ExpressionsInParenthesizedExpressions()
+        public async Task ExpressionsInParenthesizedExpressions()
         {
-            TestTryDo(@"class Program
+            await TestTryDoAsync(@"class Program
 {
     static void Main(string[] args)
     {
diff --git a/src/VisualStudio/CSharp/Test/Debugging/ProximityExpressionsGetterTests_Caching.cs b/src/VisualStudio/CSharp/Test/Debugging/ProximityExpressionsGetterTests_Caching.cs
index c258e2f9676b325ac719b032aad368bff909e931..5c46a56d0d8beae2f8ed2345335c1c95217889d8 100644
--- a/src/VisualStudio/CSharp/Test/Debugging/ProximityExpressionsGetterTests_Caching.cs
+++ b/src/VisualStudio/CSharp/Test/Debugging/ProximityExpressionsGetterTests_Caching.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -19,9 +20,9 @@ namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Debugging
 {
     public partial class ProximityExpressionsGetterTests
     {
-        private void TestCaching(string markup, params string[][] expectedArray)
+        private async Task TestCachingAsync(string markup, params string[][] expectedArray)
         {
-            using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(markup))
+            using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(markup))
             {
                 var testDocument = workspace.Documents.Single();
                 var spans = testDocument.AnnotatedSpans;
@@ -71,7 +72,7 @@ private void TestCaching(string markup, params string[][] expectedArray)
         //
         // We should figure out some better way to test the feature.
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestCaching1()
+        public async Task TestCaching1()
         {
             var input = @"
 class Class
@@ -84,12 +85,12 @@ void Method(string args)
     }
 }";
 
-            TestCaching(input, new[] { "args", "this" }, new[] { "i", "args", "this" }, new[] { "i", "j", "k", "this", "args" });
+            await TestCachingAsync(input, new[] { "args", "this" }, new[] { "i", "args", "this" }, new[] { "i", "j", "k", "this", "args" });
         }
 
         [WorkItem(538259)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestCaching2()
+        public async Task TestCaching2()
         {
             var input = @"
 class Program
@@ -109,12 +110,12 @@ private static void Foo()
 }
 ";
 
-            TestCaching(input, new[] { "i" }, new[] { "i", "j" }, new[] { "j", "i" }, new[] { "k", "j" }, new[] { "k", "j" }, new[] { "j" });
+            await TestCachingAsync(input, new[] { "i" }, new[] { "i", "j" }, new[] { "j", "i" }, new[] { "k", "j" }, new[] { "k", "j" }, new[] { "j" });
         }
 
         [WorkItem(538259)]
         [WpfFact, Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
-        public void TestCaching3()
+        public async Task TestCaching3()
         {
             var input = @"
 class Program
@@ -134,7 +135,7 @@ private static void Foo()
 }
 ";
 
-            TestCaching(input, new[] { "i" }, new[] { "i", "j" }, new[] { "j", "i" }, new[] { "k", }, new[] { "k", }, Array.Empty<string>());
+            await TestCachingAsync(input, new[] { "i" }, new[] { "i", "j" }, new[] { "j", "i" }, new[] { "k", }, new[] { "k", }, Array.Empty<string>());
         }
     }
 }
diff --git a/src/VisualStudio/Core/Test/Diagnostics/DiagnosticTableDataSourceTests.vb b/src/VisualStudio/Core/Test/Diagnostics/DiagnosticTableDataSourceTests.vb
index 91814499b3569eefa5cc4f5a63a8650e685c7ae1..01ac167d6c2d7961010376af55aebb89e35c0282 100644
--- a/src/VisualStudio/Core/Test/Diagnostics/DiagnosticTableDataSourceTests.vb
+++ b/src/VisualStudio/Core/Test/Diagnostics/DiagnosticTableDataSourceTests.vb
@@ -2,6 +2,7 @@
 
 Imports System.Collections.Immutable
 Imports System.Threading
+Imports System.Threading.Tasks
 Imports System.Windows
 Imports System.Windows.Controls
 Imports Microsoft.CodeAnalysis
@@ -22,8 +23,8 @@ Imports Roslyn.Utilities
 Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
     Public Class DiagnosticTableDataSourceTests
         <WpfFact>
-        Public Sub TestCreation()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestCreation() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim provider = New TestDiagnosticService()
                 Dim tableManagerProvider = New TestTableManagerProvider()
 
@@ -51,11 +52,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 subscription.Dispose()
                 Assert.Equal(0, source.NumberOfSubscription_TestOnly)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestInitialEntries()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestInitialEntries() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim provider = New TestDiagnosticService(CreateItem(workspace, documentId))
                 Dim tableManagerProvider = New TestTableManagerProvider()
@@ -70,11 +71,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Dim sink = DirectCast(sinkAndSubscription.Key, TestTableManagerProvider.TestTableManager.TestSink)
                 Assert.Equal(1, sink.Entries.Count)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestEntryChanged()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestEntryChanged() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim provider = New TestDiagnosticService()
                 Dim tableManagerProvider = New TestTableManagerProvider()
@@ -95,11 +96,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 provider.RaiseClearDiagnosticsUpdated(workspace, documentId.ProjectId, documentId)
                 Assert.Equal(0, sink.Entries.Count)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestEntry()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestEntry() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
 
                 Dim item = CreateItem(workspace, documentId)
@@ -136,11 +137,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Assert.True(snapshot.TryGetValue(0, StandardTableKeyNames.Column, column))
                 Assert.Equal(If(item.DataLocation?.MappedStartColumn, 0), column)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestSnapshotEntry()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestSnapshotEntry() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
 
                 Dim item = CreateItem(workspace, documentId)
@@ -184,11 +185,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Assert.True(snapshot1.TryGetValue(0, StandardTableKeyNames.Column, column))
                 Assert.Equal(If(item.DataLocation?.MappedStartColumn, 0), column)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestInvalidEntry()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestInvalidEntry() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
 
                 Dim item = CreateItem(workspace, documentId)
@@ -214,11 +215,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Assert.False(snapshot.TryGetValue(1, StandardTableKeyNames.DocumentName, temp))
                 Assert.False(snapshot.TryGetValue(0, "Test", temp))
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestNoHiddenEntry()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestNoHiddenEntry() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
 
                 Dim item = CreateItem(workspace, documentId, DiagnosticSeverity.Error)
@@ -241,11 +242,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
                 Assert.Equal(1, snapshot.Count)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestProjectEntry()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestProjectEntry() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim projectId = workspace.CurrentSolution.Projects.First().Id
 
                 Dim item = CreateItem(workspace, projectId, Nothing, DiagnosticSeverity.Error)
@@ -267,12 +268,12 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
                 Assert.Equal(1, snapshot.Count)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestMultipleWorkspace()
-            Using workspace1 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
-                Using workspace2 = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestMultipleWorkspace() As Task
+            Using workspace1 = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
+                Using workspace2 = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                     Dim documentId = workspace1.CurrentSolution.Projects.First().DocumentIds.First()
                     Dim projectId = documentId.ProjectId
 
@@ -302,11 +303,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                     Assert.Equal(2, sink.Entries.Count)
                 End Using
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestDetailExpander()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestDetailExpander() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim projectId = documentId.ProjectId
 
@@ -339,11 +340,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Assert.Equal(New Thickness(10, 6, 10, 8), textBlock.Padding)
                 Assert.Equal(Nothing, textBlock.Background)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestHyperLink()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestHyperLink() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim projectId = documentId.ProjectId
 
@@ -371,11 +372,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
                 Assert.Null(ui)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestBingHyperLink()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestBingHyperLink() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim projectId = documentId.ProjectId
 
@@ -403,11 +404,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
                 Assert.Null(ui)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestHelpLink()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestHelpLink() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim projectId = documentId.ProjectId
 
@@ -432,11 +433,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
                 Assert.Equal(item1.HelpLink, helpLink.ToString())
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestHelpKeyword()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestHelpKeyword() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim projectId = documentId.ProjectId
 
@@ -461,11 +462,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
                 Assert.Equal(item1.Id, keyword.ToString())
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestBingHelpLink()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestBingHelpLink() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim projectId = documentId.ProjectId
 
@@ -490,11 +491,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
                 Assert.True(helpLink.ToString().IndexOf("https://bingdev.cloudapp.net/BingUrl.svc/Get?selectedText=test%20format&mainLanguage=C%23&projectType=%7BFAE04EC0-301F-11D3-BF4B-00C04F79EFBC%7D") = 0)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestBingHelpLink_NoCustomType()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines("class A { int 111a; }")
+        Public Async Function TestBingHelpLink_NoCustomType() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync("class A { int 111a; }")
                 Dim diagnostic = workspace.CurrentSolution.Projects.First().GetCompilationAsync().Result.GetDiagnostics().First(Function(d) d.Id = "CS1519")
 
                 Dim helpMessage = diagnostic.GetBingHelpMessage(workspace)
@@ -507,11 +508,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Dim helpMessage2 = diagnostic.GetBingHelpMessage(workspace)
                 Assert.Equal("Invalid token '{0}' in class, struct, or interface member declaration", helpMessage2)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestErrorSource()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestErrorSource() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim projectId = documentId.ProjectId
 
@@ -536,11 +537,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
                 Assert.Equal("BuildTool", buildTool.ToString())
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestWorkspaceDiagnostic()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestWorkspaceDiagnostic() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim projectId = documentId.ProjectId
 
@@ -566,11 +567,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Dim projectname As Object = Nothing
                 Assert.False(snapshot.TryGetValue(0, StandardTableKeyNames.ProjectName, projectname))
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestProjectDiagnostic()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestProjectDiagnostic() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim projectId = documentId.ProjectId
 
@@ -598,7 +599,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
                 Assert.Equal("Test", projectname)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
         Public Sub TestAggregatedDiagnostic()
diff --git a/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb b/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb
index cd90b9510f6bd969c92380a7b9622ac693e9659e..920a55a35f34d37a649679a5a44755e6dedab476 100644
--- a/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb
+++ b/src/VisualStudio/Core/Test/Diagnostics/ExternalDiagnosticUpdateSourceTests.vb
@@ -17,19 +17,19 @@ Imports Roslyn.Utilities
 Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
     Public Class ExternalDiagnosticUpdateSourceTests
         <WpfFact>
-        Public Sub TestExternalDiagnostics_SupportGetDiagnostics()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestExternalDiagnostics_SupportGetDiagnostics() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim waiter = New Waiter()
                 Dim service = New TestDiagnosticAnalyzerService()
                 Dim source = New ExternalErrorDiagnosticUpdateSource(workspace, service, New MockDiagnosticUpdateSourceRegistrationService(), waiter)
 
                 Assert.False(source.SupportGetDiagnostics)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
         Public Async Function TestExternalDiagnostics_RaiseEvents() As Task
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim waiter = New Waiter()
                 Dim service = New TestDiagnosticAnalyzerService()
                 Dim source = New ExternalErrorDiagnosticUpdateSource(workspace, service, New MockDiagnosticUpdateSourceRegistrationService(), waiter)
@@ -57,7 +57,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
         <WpfFact>
         Public Async Function TestExternalDiagnostics_DuplicatedError() As Task
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim waiter = New Waiter()
 
                 Dim project = workspace.CurrentSolution.Projects.First()
@@ -82,7 +82,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
         <WpfFact>
         Public Async Function TestBuildStartEvent() As Task
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim waiter = New Waiter()
 
                 Dim project = workspace.CurrentSolution.Projects.First()
diff --git a/src/VisualStudio/Core/Test/Diagnostics/MiscDiagnosticUpdateSourceTests.vb b/src/VisualStudio/Core/Test/Diagnostics/MiscDiagnosticUpdateSourceTests.vb
index 51e3c3498f9345a26ce621bd16d41fa7c625ef81..a380f07a688e411a8fe19cc8a232dff248384fef 100644
--- a/src/VisualStudio/Core/Test/Diagnostics/MiscDiagnosticUpdateSourceTests.vb
+++ b/src/VisualStudio/Core/Test/Diagnostics/MiscDiagnosticUpdateSourceTests.vb
@@ -24,7 +24,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
             Dim code = <code>
 class 123 { }
                        </code>
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(code.ToString())
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code.ToString())
                 Dim miscService = New MiscellaneousDiagnosticAnalyzerService(
                     New TestDiagnosticAnalyzerService(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap()),
                     New MockDiagnosticUpdateSourceRegistrationService())
@@ -66,7 +66,7 @@ class 123 { }
             Dim code = <code>
 class 123 { }
                        </code>
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(code.ToString())
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(code.ToString())
                 Dim miscService = New MiscellaneousDiagnosticAnalyzerService(
                     New TestDiagnosticAnalyzerService(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap()),
                     New MockDiagnosticUpdateSourceRegistrationService())
diff --git a/src/VisualStudio/Core/Test/Diagnostics/TodoListTableDataSourceTests.vb b/src/VisualStudio/Core/Test/Diagnostics/TodoListTableDataSourceTests.vb
index d102eb5fc14cb9dc5dc8754785bb72e1f1eda92a..b582a3bdf0f56fbb99cdccb2ab7ffc5ccd2e23e0 100644
--- a/src/VisualStudio/Core/Test/Diagnostics/TodoListTableDataSourceTests.vb
+++ b/src/VisualStudio/Core/Test/Diagnostics/TodoListTableDataSourceTests.vb
@@ -2,6 +2,7 @@
 
 Imports System.Collections.Immutable
 Imports System.Threading
+Imports System.Threading.Tasks
 Imports Microsoft.CodeAnalysis
 Imports Microsoft.CodeAnalysis.Common
 Imports Microsoft.CodeAnalysis.Editor
@@ -14,8 +15,8 @@ Imports Roslyn.Utilities
 Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
     Public Class TodoListTableDataSourceTests
         <WpfFact>
-        Public Sub TestCreation()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestCreation() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim provider = New TestTodoListProvider()
                 Dim tableManagerProvider = New TestTableManagerProvider()
 
@@ -43,11 +44,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 subscription.Dispose()
                 Assert.Equal(0, source.NumberOfSubscription_TestOnly)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestInitialEntries()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestInitialEntries() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim provider = New TestTodoListProvider(CreateItem(workspace, documentId))
                 Dim tableManagerProvider = New TestTableManagerProvider()
@@ -62,11 +63,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Dim sink = DirectCast(sinkAndSubscription.Key, TestTableManagerProvider.TestTableManager.TestSink)
                 Assert.Equal(1, sink.Entries.Count)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestEntryChanged()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestEntryChanged() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
                 Dim provider = New TestTodoListProvider()
                 Dim tableManagerProvider = New TestTableManagerProvider()
@@ -87,11 +88,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 provider.RaiseClearTodoListUpdated(workspace, documentId)
                 Assert.Equal(0, sink.Entries.Count)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestEntry()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestEntry() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
 
                 Dim item = CreateItem(workspace, documentId)
@@ -128,11 +129,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Assert.True(snapshot.TryGetValue(0, StandardTableKeyNames.Column, column))
                 Assert.Equal(item.MappedColumn, column)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestSnapshotEntry()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestSnapshotEntry() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
 
                 Dim item = CreateItem(workspace, documentId)
@@ -176,11 +177,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Assert.True(snapshot1.TryGetValue(0, StandardTableKeyNames.Column, column))
                 Assert.Equal(item.MappedColumn, column)
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestSnapshotTranslateTo()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestSnapshotTranslateTo() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
 
                 Dim item = CreateItem(workspace, documentId)
@@ -206,11 +207,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
 
                 Assert.Equal(0, snapshot1.IndexOf(0, snapshot2))
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestSnapshotTranslateTo2()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestSnapshotTranslateTo2() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
 
                 Dim item = CreateItem(workspace, documentId)
@@ -239,11 +240,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Dim snapshot2 = factory.GetCurrentSnapshot()
                 Assert.Equal(1, snapshot1.IndexOf(0, snapshot2))
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestSnapshotTranslateTo3()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestSnapshotTranslateTo3() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
 
                 Dim item = CreateItem(workspace, documentId)
@@ -272,11 +273,11 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Dim snapshot2 = factory.GetCurrentSnapshot()
                 Assert.Equal(-1, snapshot1.IndexOf(0, snapshot2))
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
-        Public Sub TestInvalidEntry()
-            Using workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(String.Empty)
+        Public Async Function TestInvalidEntry() As Task
+            Using workspace = Await CSharpWorkspaceFactory.CreateWorkspaceFromLinesAsync(String.Empty)
                 Dim documentId = workspace.CurrentSolution.Projects.First().DocumentIds.First()
 
                 Dim item = CreateItem(workspace, documentId)
@@ -300,7 +301,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
                 Assert.False(snapshot.TryGetValue(1, StandardTableKeyNames.DocumentName, temp))
                 Assert.False(snapshot.TryGetValue(0, "Test", temp))
             End Using
-        End Sub
+        End Function
 
         <WpfFact>
         Public Sub TestAggregatedEntries()