Add tests for experiment service

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/TypeImportCompletionProviderTests.cs

 // 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.Composition;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.CSharp.Completion.Providers;
+using Microsoft.CodeAnalysis.Editor.UnitTests;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Experiments;
+using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.VisualStudio.Composition;
 using Roslyn.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Completion.CompletionProviders
 {
+    [UseExportProvider]
     public class TypeImportCompletionProviderTests : AbstractCSharpCompletionProviderTests
     {
         public TypeImportCompletionProviderTests(CSharpTestWorkspaceFixture workspaceFixture) : base(workspaceFixture)
@@ -29,25 +35,63 @@ protected override void SetWorkspaceOptions(TestWorkspace workspace)
                 .WithChangedOption(CompletionOptions.ShowItemsFromUnimportedNamespaces, LanguageNames.CSharp, ShowImportCompletionItemsOptionValue);
         }
 
+        ExportProvider _exportProvider = null;
+        protected override ExportProvider ExportProvider
+        {
+            get
+            {
+                if (_exportProvider == null)
+                {
+                    _exportProvider = ExportProviderCache
+                        .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithPart(typeof(MockTypeImportCompletionExperimentationService)))
+                        .CreateExportProvider();
+                }
+                return _exportProvider;
+            }
+        }
+
         #region "Option tests"
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
-        public async Task OptionSetToNull()
+        public async Task OptionSetToNull_ExpEnabled()
         {
+            var mockExperimentService = ExportProvider.GetExportedValue<MockTypeImportCompletionExperimentationService>();
+            mockExperimentService.ExperimentEnabled = true;
+
             ShowImportCompletionItemsOptionValue = null;
+
             var markup = @"
 class Bar
 {
      $$
 }";
 
-            await VerifyNoItemsExistAsync(markup);
+            await VerifyAnyItemExistsAsync(markup);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
-        public async Task OptionSetToFalse()
+        public async Task OptionSetToNull_ExpDisabled()
         {
+            ShowImportCompletionItemsOptionValue = null;
+            var markup = @"
+class Bar
+{
+     $$
+}";
+
+            await VerifyNoItemsExistAsync(markup);
+        }
+
+        [InlineData(true)]
+        [InlineData(false)]
+        [Theory, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task OptionSetToFalse(bool isExperimentEnabled)
+        {
+            var mockExperimentService = ExportProvider.GetExportedValue<MockTypeImportCompletionExperimentationService>();
+            mockExperimentService.ExperimentEnabled = isExperimentEnabled;
+
             ShowImportCompletionItemsOptionValue = false;
+
             var markup = @"
 class Bar
 {
@@ -57,10 +101,16 @@ class Bar
             await VerifyNoItemsExistAsync(markup);
         }
 
-        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
-        public async Task OptionSetToTrue()
+        [InlineData(true)]
+        [InlineData(false)]
+        [Theory, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task OptionSetToTrue(bool isExperimentEnabled)
         {
+            var mockExperimentService = ExportProvider.GetExportedValue<MockTypeImportCompletionExperimentationService>();
+            mockExperimentService.ExperimentEnabled = isExperimentEnabled;
+
             ShowImportCompletionItemsOptionValue = true;
+
             var markup = @"
 class Bar
 {
@@ -816,5 +866,18 @@ private Task VerifyTypeImportItemIsAbsentAsync(string markup, string expectedIte
         {
             return VerifyItemIsAbsentAsync(markup, expectedItem, displayTextSuffix: displayTextSuffix, inlineDescription: inlineDescription);
         }
+
+        [Shared]
+        [Export(typeof(MockTypeImportCompletionExperimentationService))]
+        [ExportWorkspaceService(typeof(IExperimentationService), WorkspaceKind.Test)]
+        private class MockTypeImportCompletionExperimentationService : IExperimentationService
+        {
+            public bool ExperimentEnabled { get; set; } = false;
+
+            public bool IsExperimentEnabled(string experimentName)
+            {
+                return ExperimentEnabled && WellKnownExperimentNames.TypeImportCompletion.Equals(experimentName);
+            }
+        }
     }
 }

src/EditorFeatures/TestUtilities/Completion/AbstractCompletionProviderTests.cs

@@ -15,6 +15,7 @@
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.VisualStudio.Composition;
 using Microsoft.VisualStudio.Language.Intellisense;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
@@ -149,12 +150,14 @@ internal static CompletionHelper GetCompletionHelper(Document document)
             }
         }
 
+        protected virtual ExportProvider ExportProvider => null;
+
         private Task VerifyAsync(
             string markup, string expectedItemOrNull, string expectedDescriptionOrNull,
             SourceCodeKind sourceCodeKind, bool usePreviousCharAsTrigger, bool checkForAbsence,
             int? glyph, int? matchPriority, bool? hasSuggestionModeItem, string displayTextSuffix, string inlineDescription)
         {
-            var workspace = WorkspaceFixture.GetWorkspace(markup);
+            var workspace = WorkspaceFixture.GetWorkspace(markup, ExportProvider);
             var code = WorkspaceFixture.Code;
             var position = WorkspaceFixture.Position;
             SetWorkspaceOptions(workspace);

src/EditorFeatures/TestUtilities/Workspaces/CSharpTestWorkspaceFixture.cs

@@ -2,16 +2,18 @@
 
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.VisualStudio.Composition;
 
 namespace Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 {
     public class CSharpTestWorkspaceFixture : TestWorkspaceFixture
     {
-        protected override TestWorkspace CreateWorkspace()
+        protected override TestWorkspace CreateWorkspace(ExportProvider exportProvider = null)
         {
             return TestWorkspace.CreateCSharp2(
                 new string[] { string.Empty, },
-                new CSharpParseOptions[] { new CSharpParseOptions(kind: SourceCodeKind.Regular), });
+                new CSharpParseOptions[] { new CSharpParseOptions(kind: SourceCodeKind.Regular), },
+                exportProvider: exportProvider);
         }
     }
 }

src/EditorFeatures/TestUtilities/Workspaces/TestWorkspaceFixture.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Xml;
 using System.Xml.Linq;
+using Microsoft.VisualStudio.Composition;
 using Microsoft.VisualStudio.Text;
 using Roslyn.Test.Utilities;
 
@@ -20,17 +21,17 @@ public abstract class TestWorkspaceFixture : IDisposable
 
         public TestHostDocument CurrentDocument => _currentDocument ?? _workspace.Documents.Single();
 
-        public TestWorkspace GetWorkspace()
+        public TestWorkspace GetWorkspace(ExportProvider exportProvider = null)
         {
-            _workspace = _workspace ?? CreateWorkspace();
+            _workspace = _workspace ?? CreateWorkspace(exportProvider);
             return _workspace;
         }
 
-        public TestWorkspace GetWorkspace(string markup)
+        public TestWorkspace GetWorkspace(string markup, ExportProvider exportProvider = null)
         {
             if (TryParseXElement(markup, out var workspaceElement) && workspaceElement.Name == "Workspace")
             {
-                _workspace = TestWorkspace.CreateWorkspace(workspaceElement);
+                _workspace = TestWorkspace.CreateWorkspace(workspaceElement, exportProvider: exportProvider);
                 _currentDocument = _workspace.Documents.First(d => d.CursorPosition.HasValue);
                 Position = _currentDocument.CursorPosition.Value;
                 Code = _currentDocument.TextBuffer.CurrentSnapshot.GetText();
@@ -39,7 +40,7 @@ public TestWorkspace GetWorkspace(string markup)
             else
             {
                 MarkupTestFile.GetPosition(markup.NormalizeLineEndings(), out Code, out Position);
-                var workspace = GetWorkspace();
+                var workspace = GetWorkspace(exportProvider);
                 _currentDocument = workspace.Documents.Single();
                 return workspace;
             }
@@ -49,7 +50,7 @@ public TestWorkspaceFixture()
         {
         }
 
-        protected abstract TestWorkspace CreateWorkspace();
+        protected abstract TestWorkspace CreateWorkspace(ExportProvider exportProvider);
 
         public void Dispose()
         {

src/EditorFeatures/TestUtilities/Workspaces/VisualBasicTestWorkspaceFixture.cs

@@ -6,17 +6,19 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.VisualBasic;
+using Microsoft.VisualStudio.Composition;
 
 namespace Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 {
     public class VisualBasicTestWorkspaceFixture : TestWorkspaceFixture
     {
-        protected override TestWorkspace CreateWorkspace()
+        protected override TestWorkspace CreateWorkspace(ExportProvider exportProvider = null)
         {
             return TestWorkspace.CreateVisualBasic(
                 new string[] { string.Empty },
                 new VisualBasicParseOptions[] { new VisualBasicParseOptions(kind: SourceCodeKind.Regular) },
-                new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+                new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary),
+                exportProvider: exportProvider);
         }
     }
 }