first unit tests to test that .next unit tests are working.

following up unit tests will add more tests and add proper listener to remove explicit delay

src/EditorFeatures/TestUtilities/MinimalTestExportProvider.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;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor.Shared.Options;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Utilities;
+using Microsoft.CodeAnalysis.Shared.Options;
+using Microsoft.CodeAnalysis.SolutionCrawler;
+using Microsoft.VisualStudio.Composition;
+using Roslyn.Test.Utilities;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Editor.UnitTests
+{
+    public static class MinimalTestExportProvider
+    {
+        private static readonly PartDiscovery s_partDiscovery = CreatePartDiscovery(Resolver.DefaultInstance);
+        private static readonly Lazy<ComposableCatalog> s_lazyLanguageNeutralCatalog = new Lazy<ComposableCatalog>(() => CreateAssemblyCatalog(GetVisualStudioAssemblies()).WithParts(CreateAssemblyCatalog(GetLanguageNeutralTypes().Select(t => t.Assembly).Distinct())));
+
+        public static ComposableCatalog LanguageNeutralCatalog
+        {
+            get
+            {
+                return s_lazyLanguageNeutralCatalog.Value;
+            }
+        }
+
+        public static Type[] GetLanguageNeutralTypes()
+        {
+            var types = new[]
+            {
+                // ROSLYN
+                typeof(Microsoft.CodeAnalysis.Editor.Implementation.Workspaces.WorkspaceTaskSchedulerFactoryFactory),
+                typeof(Microsoft.CodeAnalysis.Host.WorkspaceTaskSchedulerFactoryFactory),
+                typeof(Microsoft.CodeAnalysis.Formatting.Rules.DefaultFormattingRuleFactoryServiceFactory),
+                typeof(Microsoft.CodeAnalysis.Host.PersistentStorageServiceFactory),
+                typeof(Microsoft.CodeAnalysis.Text.Implementation.TextBufferFactoryService.TextBufferCloneServiceFactory),
+                typeof(Microsoft.CodeAnalysis.Host.MetadataServiceFactory),
+                typeof(Microsoft.CodeAnalysis.Host.TemporaryStorageServiceFactory),
+                typeof(Microsoft.CodeAnalysis.Host.TextFactoryService),
+                typeof(Microsoft.CodeAnalysis.Editor.Implementation.Workspaces.ProjectCacheHostServiceFactory),
+                typeof(Solution), // ServicesCore
+                typeof(Microsoft.CodeAnalysis.Options.GlobalOptionService),
+                typeof(Microsoft.CodeAnalysis.Options.OptionServiceFactory),
+                typeof(Microsoft.CodeAnalysis.Options.Providers.ExportedOptionProvider),
+                typeof(Microsoft.CodeAnalysis.Editor.Implementation.SmartIndent.SmartIndentProvider),
+                typeof(Microsoft.CodeAnalysis.Editor.Implementation.ForegroundNotification.ForegroundNotificationService),
+                typeof(Microsoft.CodeAnalysis.Editor.UnitTests.TestOptionsServiceFactory),
+                typeof(SymbolMapping.SymbolMappingServiceFactory),
+                typeof(TestWaitIndicator),
+                typeof(TestExtensionErrorHandler),
+                typeof(TestExportProvider)
+            };
+
+            return types.Concat(TestHelpers.GetAllTypesWithStaticFieldsImplementingType(typeof(InternalSolutionCrawlerOptions).Assembly, typeof(Microsoft.CodeAnalysis.Options.IOption)))
+                        .Concat(TestHelpers.GetAllTypesWithStaticFieldsImplementingType(typeof(EditorComponentOnOffOptions).Assembly, typeof(Microsoft.CodeAnalysis.Options.IOption)))
+                        .Concat(TestHelpers.GetAllTypesWithStaticFieldsImplementingType(typeof(ServiceComponentOnOffOptions).Assembly, typeof(Microsoft.CodeAnalysis.Options.IOption)))
+                        .Concat(TestHelpers.GetAllTypesWithStaticFieldsImplementingType(typeof(Microsoft.CodeAnalysis.Formatting.FormattingOptions).Assembly, typeof(Microsoft.CodeAnalysis.Options.IOption)))
+                        .Distinct()
+                        .ToArray();
+        }
+
+        public static IEnumerable<Assembly> GetVisualStudioAssemblies()
+        {
+            var assemblies = new[]
+            {
+                // EDITOR
+
+                // Microsoft.VisualStudio.Platform.VSEditor.dll:
+                typeof(Microsoft.VisualStudio.Platform.VSEditor.EventArgsHelper).Assembly,
+
+                // Microsoft.VisualStudio.Text.Logic.dll:
+                //   Must include this because several editor options are actually stored as exported information 
+                //   on this DLL.  Including most importantly, the tab size information.
+                typeof(Microsoft.VisualStudio.Text.Editor.DefaultOptions).Assembly,
+
+                // Microsoft.VisualStudio.Text.UI.dll:
+                //   Include this DLL to get several more EditorOptions including WordWrapStyle.
+                typeof(Microsoft.VisualStudio.Text.Editor.WordWrapStyle).Assembly,
+
+                // Microsoft.VisualStudio.Text.UI.Wpf.dll:
+                //   Include this DLL to get more EditorOptions values.
+                typeof(Microsoft.VisualStudio.Text.Editor.HighlightCurrentLineOption).Assembly,
+
+                // BasicUndo.dll:
+                //   Include this DLL to satisfy ITextUndoHistoryRegistry
+                typeof(BasicUndo.IBasicUndoHistory).Assembly,
+
+                // Microsoft.VisualStudio.Language.StandardClassification.dll:
+                typeof(Microsoft.VisualStudio.Language.StandardClassification.PredefinedClassificationTypeNames).Assembly
+            };
+
+            return assemblies;
+        }
+
+        public static ComposableCatalog CreateAssemblyCatalog(Assembly assembly)
+        {
+            return CreateAssemblyCatalog(SpecializedCollections.SingletonEnumerable(assembly));
+        }
+
+        public static ComposableCatalog CreateAssemblyCatalog(IEnumerable<Assembly> assemblies, Resolver resolver = null)
+        {
+            var discovery = resolver == null ? s_partDiscovery : CreatePartDiscovery(resolver);
+
+            // If we run CreatePartsAsync on the test thread we may deadlock since it'll schedule stuff back
+            // on the thread.
+            var parts = Task.Run(async () => await discovery.CreatePartsAsync(assemblies).ConfigureAwait(false)).Result;
+
+            return ComposableCatalog.Create(resolver ?? Resolver.DefaultInstance).AddParts(parts);
+        }
+
+        public static ComposableCatalog CreateTypeCatalog(IEnumerable<Type> types, Resolver resolver = null)
+        {
+            var discovery = resolver == null ? s_partDiscovery : CreatePartDiscovery(resolver);
+
+            // If we run CreatePartsAsync on the test thread we may deadlock since it'll schedule stuff back
+            // on the thread.
+            var parts = Task.Run(async () => await discovery.CreatePartsAsync(types).ConfigureAwait(false)).Result;
+
+            return ComposableCatalog.Create(resolver ?? Resolver.DefaultInstance).AddParts(parts);
+        }
+
+        public static Resolver CreateResolver()
+        {
+            // simple assembly loader is stateless, so okay to share
+            return new Resolver(SimpleAssemblyLoader.Instance);
+        }
+
+        public static PartDiscovery CreatePartDiscovery(Resolver resolver)
+        {
+            return PartDiscovery.Combine(new AttributedPartDiscoveryV1(resolver), new AttributedPartDiscovery(resolver, isNonPublicSupported: true));
+        }
+
+        public static ExportProvider CreateExportProvider(ComposableCatalog catalog)
+        {
+            var configuration = CompositionConfiguration.Create(catalog.WithDesktopSupport().WithCompositionService());
+            var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
+            return runtimeComposition.CreateExportProviderFactory().CreateExportProvider();
+        }
+
+        public static ComposableCatalog WithParts(this ComposableCatalog @this, ComposableCatalog catalog)
+        {
+            return @this.AddParts(catalog.DiscoveredParts);
+        }
+
+        public static ComposableCatalog WithParts(this ComposableCatalog catalog, IEnumerable<Type> types)
+        {
+            return catalog.WithParts(CreateTypeCatalog(types));
+        }
+
+        public static ComposableCatalog WithParts(this ComposableCatalog catalog, params Type[] types)
+        {
+            return WithParts(catalog, (IEnumerable<Type>)types);
+        }
+
+        public static ComposableCatalog WithPart(this ComposableCatalog catalog, Type t)
+        {
+            return catalog.WithParts(CreateTypeCatalog(SpecializedCollections.SingletonEnumerable(t)));
+        }
+
+        private class SimpleAssemblyLoader : IAssemblyLoader
+        {
+            public static readonly IAssemblyLoader Instance = new SimpleAssemblyLoader();
+
+            public Assembly LoadAssembly(AssemblyName assemblyName)
+            {
+                return Assembly.Load(assemblyName);
+            }
+
+            public Assembly LoadAssembly(string assemblyFullName, string codeBasePath)
+            {
+                var assemblyName = new AssemblyName(assemblyFullName);
+                if (!string.IsNullOrEmpty(codeBasePath))
+                {
+                    assemblyName.CodeBase = codeBasePath;
+                }
+
+                return this.LoadAssembly(assemblyName);
+            }
+        }
+    }
+}

src/EditorFeatures/TestUtilities/ServicesTestUtilities.csproj

@@ -29,6 +29,10 @@
     <PlatformTarget>ARM</PlatformTarget>
   </PropertyGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\Features\Core\Portable\Features.csproj">
+      <Project>{edc68a0e-c68d-4a74-91b7-bf38ec909888}</Project>
+      <Name>Features</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\Test\Utilities\Desktop\TestUtilities.Desktop.csproj">
       <Project>{76c6f005-c89d-4348-bb4a-391898dbeb52}</Project>
       <Name>TestUtilities.Desktop</Name>
@@ -37,6 +41,10 @@
       <Project>{f7712928-1175-47b3-8819-ee086753dee2}</Project>
       <Name>TestUtilities.FX45</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\Workspaces\Core\Desktop\Workspaces.Desktop.csproj">
+      <Project>{2e87fa96-50bb-4607-8676-46521599f998}</Project>
+      <Name>Workspaces.Desktop</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\Workspaces\Core\Portable\Workspaces.csproj">
       <Project>{5f8d2414-064a-4b3a-9b42-8e2a04246be5}</Project>
       <Name>Workspaces</Name>
@@ -45,6 +53,10 @@
       <Project>{3CDEEAB7-2256-418A-BEB2-620B5CB16302}</Project>
       <Name>EditorFeatures</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Text\TextEditorFeatures.csproj">
+      <Project>{18f5fbb8-7570-4412-8cc7-0a86ff13b7ba}</Project>
+      <Name>TextEditorFeatures</Name>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <Reference Include="PresentationCore" />
@@ -66,6 +78,11 @@
     <Compile Include="DispatcherExtensions.cs" />
     <Compile Include="DirectoryExtensions.cs" />
     <Compile Include="ExceptionUtilities.cs" />
+    <Compile Include="MinimalTestExportProvider.cs" />
+    <Compile Include="TestExportProvider.cs" />
+    <Compile Include="TestExtensionErrorHandler.cs" />
+    <Compile Include="TestOptionsServiceFactory.cs" />
+    <Compile Include="TestWaitIndicator.cs" />
     <Compile Include="Threading\ConditionalWpfFactAttribute.cs" />
     <Compile Include="Threading\StaTaskScheduler.cs" />
     <Compile Include="Threading\WpfFactAttribute.cs" />
@@ -99,4 +116,4 @@
   </ItemGroup>
   <Import Project="..\..\..\build\Targets\VSL.Imports.targets" />
   <Import Project="..\..\..\build\Targets\Roslyn.Toolsets.Xunit.targets" />
-</Project>
+</Project>
\ No newline at end of file

src/EditorFeatures/TestUtilities/TestExportProvider.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;
+using System.Linq;
+using Microsoft.CodeAnalysis.CodeGeneration;
+using Microsoft.CodeAnalysis.Editor.Implementation.NavigateTo;
+using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Formatting.Rules;
+using Microsoft.VisualStudio.Composition;
+using Roslyn.Test.Utilities;
+
+namespace Microsoft.CodeAnalysis.Editor.UnitTests
+{
+    /// <summary>
+    /// This type caches MEF compositions for our unit tests.  MEF composition is a relatively expensive
+    /// operation and caching yields demonstrable benefits for testing.
+    /// 
+    /// These caches must be done in a thread static manner.  Many of the stored values are non-frozen
+    /// WPF elements which will throw if shared between threads.  It is legal for a given xUnit runner
+    /// to execute classes on different threads hence we must handle this scenario.  
+    /// </summary>
+    public static class TestExportProvider
+    {
+        [ThreadStatic]
+        private static Lazy<ComposableCatalog> t_lazyEntireAssemblyCatalogWithCSharpAndVisualBasic;
+
+        public static ComposableCatalog EntireAssemblyCatalogWithCSharpAndVisualBasic
+        {
+            get
+            {
+                if (t_lazyEntireAssemblyCatalogWithCSharpAndVisualBasic == null)
+                {
+                    t_lazyEntireAssemblyCatalogWithCSharpAndVisualBasic = new Lazy<ComposableCatalog>(() => CreateAssemblyCatalogWithCSharpAndVisualBasic());
+                }
+
+                return t_lazyEntireAssemblyCatalogWithCSharpAndVisualBasic.Value;
+            }
+        }
+
+        [ThreadStatic]
+        private static Lazy<ExportProvider> t_lazyExportProviderWithCSharpAndVisualBasic;
+
+        public static ExportProvider ExportProviderWithCSharpAndVisualBasic
+        {
+            get
+            {
+                if (t_lazyExportProviderWithCSharpAndVisualBasic == null)
+                {
+                    t_lazyExportProviderWithCSharpAndVisualBasic = new Lazy<ExportProvider>(CreateExportProviderWithCSharpAndVisualBasic);
+                }
+
+                return t_lazyExportProviderWithCSharpAndVisualBasic.Value;
+            }
+        }
+
+        [ThreadStatic]
+        private static Lazy<ComposableCatalog> t_lazyMinimumCatalogWithCSharpAndVisualBasic;
+
+        public static ComposableCatalog MinimumCatalogWithCSharpAndVisualBasic
+        {
+            get
+            {
+                if (t_lazyMinimumCatalogWithCSharpAndVisualBasic == null)
+                {
+                    t_lazyMinimumCatalogWithCSharpAndVisualBasic = new Lazy<ComposableCatalog>(() => MinimalTestExportProvider.CreateTypeCatalog(GetNeutralAndCSharpAndVisualBasicTypes())
+                        .WithParts(MinimalTestExportProvider.CreateAssemblyCatalog(MinimalTestExportProvider.GetVisualStudioAssemblies())));
+                }
+
+                return t_lazyMinimumCatalogWithCSharpAndVisualBasic.Value;
+            }
+        }
+
+        private static Type[] GetNeutralAndCSharpAndVisualBasicTypes()
+        {
+            var types = new[]
+            {
+                // ROSLYN
+                typeof(Workspaces.NoCompilationLanguageServiceFactory),
+                typeof(Workspaces.NoCompilationContentTypeDefinitions),
+                typeof(Workspaces.NoCompilationContentTypeLanguageService),
+                typeof(Microsoft.CodeAnalysis.CSharp.IntroduceVariable.CSharpIntroduceVariableService), // Ensures that CSharpFeatures is included in the composition
+                typeof(Microsoft.CodeAnalysis.VisualBasic.IntroduceVariable.VisualBasicIntroduceVariableService), // Ensures that BasicFeatures is included in the composition
+                typeof(Microsoft.CodeAnalysis.Editor.CSharp.ContentType.ContentTypeDefinitions), // CSharp Content Type
+                typeof(Microsoft.CodeAnalysis.Editor.VisualBasic.ContentType.ContentTypeDefinitions), // VB Content Type
+                typeof(Microsoft.CodeAnalysis.Editor.Implementation.SmartIndent.SmartIndentProvider),
+                typeof(Microsoft.CodeAnalysis.Editor.VisualBasic.Formatting.Indentation.VisualBasicIndentationService),
+                typeof(Microsoft.CodeAnalysis.Editor.CSharp.Formatting.Indentation.CSharpIndentationService),
+                typeof(Microsoft.CodeAnalysis.Editor.Implementation.ForegroundNotification.ForegroundNotificationService),
+                typeof(Microsoft.CodeAnalysis.CSharp.CSharpCompilationFactoryService),
+                typeof(Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationFactoryService),
+                typeof(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTreeFactoryServiceFactory), // CSharpServicesCore
+                typeof(Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTreeFactoryServiceFactory), // BasicServicesCore
+                typeof(CodeAnalysis.CSharp.CodeGeneration.CSharpCodeGenerationServiceFactory),
+                typeof(CodeAnalysis.VisualBasic.CodeGeneration.VisualBasicCodeGenerationServiceFactory),
+                typeof(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxFactsServiceFactory),
+                typeof(Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxFactsServiceFactory),
+                typeof(CodeAnalysis.CSharp.CSharpSymbolDeclarationService),
+                typeof(CodeAnalysis.VisualBasic.VisualBasicSymbolDeclarationService),
+                typeof(CodeAnalysis.Editor.CSharp.LanguageServices.CSharpSymbolDisplayServiceFactory),
+                typeof(Microsoft.CodeAnalysis.Editor.CSharp.Interactive.CSharpInteractiveEvaluator),
+                typeof(CodeAnalysis.Editor.VisualBasic.LanguageServices.VisualBasicSymbolDisplayServiceFactory),
+                typeof(Microsoft.CodeAnalysis.Editor.VisualBasic.Interactive.VisualBasicInteractiveEvaluator),
+                typeof(CodeAnalysis.CSharp.Simplification.CSharpSimplificationService),
+                typeof(CodeAnalysis.VisualBasic.Simplification.VisualBasicSimplificationService),
+                typeof(CodeAnalysis.CSharp.Rename.CSharpRenameConflictLanguageService),
+                typeof(CodeAnalysis.VisualBasic.Rename.VisualBasicRenameRewriterLanguageServiceFactory),
+                typeof(CodeAnalysis.CSharp.CSharpSemanticFactsService),
+                typeof(CodeAnalysis.VisualBasic.VisualBasicSemanticFactsService),
+                typeof(CodeAnalysis.CSharp.CodeGeneration.CSharpSyntaxGenerator),
+                typeof(CodeAnalysis.VisualBasic.CodeGeneration.VisualBasicSyntaxGenerator),
+                typeof(CSharp.LanguageServices.CSharpContentTypeLanguageService),
+                typeof(VisualBasic.LanguageServices.VisualBasicContentTypeLanguageService),
+                typeof(IncrementalCaches.SymbolTreeInfoIncrementalAnalyzerProvider),
+                typeof(CodeAnalysis.Diagnostics.EngineV2.InProcCodeAnalysisDiagnosticAnalyzerExecutor)
+            };
+
+            return MinimalTestExportProvider.GetLanguageNeutralTypes()
+                .Concat(types)
+                .Concat(TestHelpers.GetAllTypesImplementingGivenInterface(typeof(Microsoft.CodeAnalysis.CSharp.Formatting.DefaultOperationProvider).Assembly, typeof(ISyntaxFormattingService)))
+                .Concat(TestHelpers.GetAllTypesImplementingGivenInterface(typeof(Microsoft.CodeAnalysis.VisualBasic.Formatting.DefaultOperationProvider).Assembly, typeof(ISyntaxFormattingService)))
+                .Concat(TestHelpers.GetAllTypesImplementingGivenInterface(typeof(Microsoft.CodeAnalysis.CSharp.Formatting.DefaultOperationProvider).Assembly, typeof(IFormattingRule)))
+                .Concat(TestHelpers.GetAllTypesImplementingGivenInterface(typeof(Microsoft.CodeAnalysis.VisualBasic.Formatting.DefaultOperationProvider).Assembly, typeof(IFormattingRule)))
+                .Concat(TestHelpers.GetAllTypesImplementingGivenInterface(typeof(Microsoft.CodeAnalysis.CSharp.Formatting.DefaultOperationProvider).Assembly, typeof(ICodeGenerationService)))
+                .Concat(TestHelpers.GetAllTypesImplementingGivenInterface(typeof(Microsoft.CodeAnalysis.VisualBasic.Formatting.DefaultOperationProvider).Assembly, typeof(ICodeGenerationService)))
+                .Concat(TestHelpers.GetAllTypesWithStaticFieldsImplementingType(typeof(Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions).Assembly, typeof(Microsoft.CodeAnalysis.Options.IOption)))
+                .Distinct()
+                .ToArray();
+        }
+
+        /// <summary>
+        /// Create fresh ExportProvider that doesnt share anything with others. 
+        /// test can use this export provider to create all new MEF components not shared with others.
+        /// </summary>
+        public static ExportProvider CreateExportProviderWithCSharpAndVisualBasic()
+        {
+            return MinimalTestExportProvider.CreateExportProvider(CreateAssemblyCatalogWithCSharpAndVisualBasic());
+        }
+
+        /// <summary>
+        /// Create fresh ComposableCatalog that doesnt share anything with others.
+        /// everything under this catalog should have been created from scratch that doesnt share anything with others.
+        /// </summary>
+        public static ComposableCatalog CreateAssemblyCatalogWithCSharpAndVisualBasic()
+        {
+            return MinimalTestExportProvider.CreateAssemblyCatalog(
+                GetNeutralAndCSharpAndVisualBasicTypes().Select(t => t.Assembly).Distinct().Concat(MinimalTestExportProvider.GetVisualStudioAssemblies()),
+                MinimalTestExportProvider.CreateResolver());
+        }
+    }
+}

src/EditorFeatures/TestUtilities/TestExtensionErrorHandler.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;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.VisualStudio.Text;
+
+namespace Microsoft.CodeAnalysis.Editor.UnitTests
+{
+    [Export(typeof(TestExtensionErrorHandler))]
+    [Export(typeof(IExtensionErrorHandler))]
+    internal class TestExtensionErrorHandler : IExtensionErrorHandler
+    {
+        private List<Exception> _exceptions = new List<Exception>();
+
+        public void HandleError(object sender, Exception exception)
+        {
+            if (exception is ArgumentOutOfRangeException && ((ArgumentOutOfRangeException)exception).ParamName == "span")
+            {
+                // TODO: this is known bug 655591, fixed by Jack in changeset 931906
+                // Remove this workaround once the fix reaches the DP branch and we all move over.
+                return;
+            }
+
+            _exceptions.Add(exception);
+        }
+
+        public ICollection<Exception> GetExceptions()
+        {
+            // We'll clear off our list, so that way we don't report this for other tests
+            var newExceptions = _exceptions;
+            _exceptions = new List<Exception>();
+            return newExceptions;
+        }
+    }
+}

src/EditorFeatures/TestUtilities/TestOptionsServiceFactory.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;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Options.Providers;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Editor.UnitTests
+{
+    [ExportWorkspaceServiceFactory(typeof(IOptionService), TestWorkspace.WorkspaceName), Shared]
+    internal class TestOptionsServiceFactory : IWorkspaceServiceFactory
+    {
+        private readonly ImmutableArray<Lazy<IOptionProvider>> _providers;
+
+        [ImportingConstructor]
+        public TestOptionsServiceFactory(
+            [ImportMany] IEnumerable<Lazy<IOptionProvider>> optionProviders)
+        {
+            _providers = optionProviders.ToImmutableArray();
+        }
+
+        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
+        {
+            // give out new option service per workspace
+            return new OptionServiceFactory.OptionService(
+                new GlobalOptionService(_providers, SpecializedCollections.EmptyEnumerable<Lazy<IOptionPersister>>()),
+                workspaceServices);
+        }
+    }
+}
\ No newline at end of file

src/EditorFeatures/TestUtilities/TestWaitIndicator.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;
+using System.ComponentModel.Composition;
+using System.Threading;
+using Microsoft.CodeAnalysis.Editor.Host;
+using Microsoft.CodeAnalysis.Shared.Utilities;
+using VisualStudioIndicator = Microsoft.VisualStudio.Language.Intellisense.Utilities;
+
+namespace Microsoft.CodeAnalysis.Editor.UnitTests.Utilities
+{
+    [Export(typeof(IWaitIndicator))]
+    [Export(typeof(VisualStudioIndicator.IWaitIndicator))]
+    public sealed class TestWaitIndicator : IWaitIndicator, VisualStudioIndicator.IWaitIndicator
+    {
+        public static readonly TestWaitIndicator Default = new TestWaitIndicator();
+
+        private readonly IWaitContext _waitContext;
+        private readonly Microsoft.VisualStudio.Language.Intellisense.Utilities.IWaitContext _platformWaitContext = new UncancellableWaitContext();
+
+        public TestWaitIndicator()
+            : this(new UncancellableWaitContext())
+        {
+        }
+
+        internal TestWaitIndicator(IWaitContext waitContext)
+        {
+            _waitContext = waitContext;
+        }
+
+        IWaitContext IWaitIndicator.StartWait(string title, string message, bool allowCancel, bool showProgress)
+        {
+            return _waitContext;
+        }
+
+        WaitIndicatorResult IWaitIndicator.Wait(string title, string message, bool allowCancel, bool showProgress, Action<IWaitContext> action)
+        {
+            try
+            {
+                action(_waitContext);
+            }
+            catch (OperationCanceledException)
+            {
+                return WaitIndicatorResult.Canceled;
+            }
+
+            return WaitIndicatorResult.Completed;
+        }
+
+        VisualStudioIndicator.IWaitContext VisualStudioIndicator.IWaitIndicator.StartWait(string title, string message, bool allowCancel)
+        {
+            return _platformWaitContext;
+        }
+
+        VisualStudioIndicator.WaitIndicatorResult VisualStudioIndicator.IWaitIndicator.Wait(string title, string message, bool allowCancel, Action<VisualStudioIndicator.IWaitContext> action)
+        {
+            try
+            {
+                action(_platformWaitContext);
+            }
+            catch (OperationCanceledException)
+            {
+                return VisualStudioIndicator.WaitIndicatorResult.Canceled;
+            }
+
+            return VisualStudioIndicator.WaitIndicatorResult.Completed;
+        }
+
+        private sealed class UncancellableWaitContext : IWaitContext, VisualStudioIndicator.IWaitContext
+        {
+            public CancellationToken CancellationToken
+            {
+                get { return CancellationToken.None; }
+            }
+
+            public IProgressTracker ProgressTracker { get; } = new ProgressTracker();
+
+            public void UpdateProgress()
+            {
+            }
+
+            public bool AllowCancel
+            {
+                get
+                {
+                    return false;
+                }
+
+                set
+                {
+                }
+            }
+
+            public string Message
+            {
+                get
+                {
+                    return "";
+                }
+
+                set
+                {
+                }
+            }
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}

src/EditorFeatures/TestUtilities/Traits.cs

@@ -139,6 +139,7 @@ public static class Features
             public const string ReferenceHighlighting = nameof(ReferenceHighlighting);
             public const string Rename = nameof(Rename);
             public const string RenameTracking = nameof(RenameTracking);
+            public const string RemoteHost = nameof(RemoteHost);
             public const string RQName = nameof(RQName);
             public const string SignatureHelp = nameof(SignatureHelp);
             public const string Simplification = nameof(Simplification);

src/EditorFeatures/TestUtilities/project.json

 {
-    "dependencies": {
-        "xunit": "2.1.0",
-        "xunit.runner.console": "2.2.0-beta1-build3239"
-    },
-    "frameworks": {
-        "net46": { }
-    }
+  "dependencies": {
+    "xunit": "2.1.0",
+    "xunit.runner.console": "2.2.0-beta1-build3239",
+    "BasicUndo": "0.9.3",
+    "Microsoft.VisualStudio.Composition": "14.2.19-pre",
+    "RoslynDependencies.Microsoft.VisualStudio.Platform.VSEditor": "14.3.25407"
+  },
+  "frameworks": {
+    "net46": { }
+  }
 }
\ No newline at end of file

src/EditorFeatures/Text/TextEditorFeatures.csproj

@@ -55,6 +55,7 @@
     <InternalsVisibleToTest Include="Roslyn.Services.Editor.VisualBasic.UnitTests" />
     <InternalsVisibleToTest Include="Roslyn.VisualStudio.Services.UnitTests" />
     <InternalsVisibleToTest Include="RoslynETAHost" />
+    <InternalsVisibleToTest Include="Roslyn.Services.Test.Utilities" />
   </ItemGroup>
   <ItemGroup>
     <!-- Compile items go here -->

src/Features/Core/Portable/Features.csproj

@@ -72,6 +72,9 @@
     <InternalsVisibleToTest Include="Roslyn.VisualStudio.IntegrationTests" />
     <InternalsVisibleToTest Include="Roslyn.VisualStudio.Services.UnitTests" />
     <InternalsVisibleToTest Include="Roslyn.VisualStudio.Test.Utilities" />
+    <InternalsVisibleToTest Include="Roslyn.VisualStudio.Test.Utilities.Next" />
+    <InternalsVisibleToTest Include="Roslyn.VisualStudio.Next.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Services.Test.Utilities" />
     <InternalsVisibleToTest Include="RoslynETAHost" />
     <InternalsVisibleToTest Include="RoslynTaoActions" />
     <InternalsVisibleToTest Include="Roslyn.VisualStudio.CSharp.UnitTests" />

src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs

@@ -214,6 +214,12 @@ private void OnConnectionChanged(object sender, bool connected)
 
             private bool FeaturesEnabled()
             {
+                if (_workspace.Options.GetOption(RemoteHostOptions.RemoteHostTest))
+                {
+                    // if it is under test, remote host is always enabled
+                    return true;
+                }
+
                 if (ServiceFeatureOnOffOptions.IsClosedFileDiagnosticsEnabled(_workspace.Options, LanguageNames.CSharp))
                 {
                     return true;

src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostOptions.cs

@@ -7,6 +7,9 @@ namespace Microsoft.VisualStudio.LanguageServices.Remote
 {
     internal static class RemoteHostOptions
     {
+        [ExportOption]
+        public static readonly Option<bool> RemoteHostTest = new Option<bool>(OptionName, nameof(RemoteHostTest), defaultValue: false);
+
         [ExportOption]
         public static readonly Option<bool> RemoteHost = new Option<bool>(nameof(InternalFeatureOnOffOptions), nameof(RemoteHost), defaultValue: true,
             storageLocations: new LocalUserProfileStorageLocation(InternalFeatureOnOffOptions.LocalRegistryPath + nameof(RemoteHost)));
@@ -14,5 +17,8 @@ internal static class RemoteHostOptions
         [ExportOption]
         public static readonly Option<int> SolutionChecksumMonitorBackOffTimeSpanInMS = new Option<int>(nameof(InternalFeatureOnOffOptions), nameof(SolutionChecksumMonitorBackOffTimeSpanInMS), defaultValue: 10000,
             storageLocations: new LocalUserProfileStorageLocation(InternalFeatureOnOffOptions.LocalRegistryPath + nameof(SolutionChecksumMonitorBackOffTimeSpanInMS)));
+
+        [ExportOption]
+        public static readonly Option<bool> RemoteHostTest = new Option<bool>(nameof(InternalFeatureOnOffOptions), nameof(RemoteHostTest), defaultValue: false);
     }
 }

src/VisualStudio/Core/Test.Next/Mocks/InProcRemoteHostClientFactory.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;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.VisualStudio.LanguageServices.Remote;
+using Roslyn.VisualStudio.Test.Utilities.Remote;
+
+namespace Roslyn.VisualStudio.Next.UnitTests.Mocks
+{
+    [ExportWorkspaceService(typeof(IRemoteHostClientFactory), layer: ServiceLayer.Host), Shared]
+    internal class InProcRemoteHostClientFactory : IRemoteHostClientFactory
+    {
+        public Task<RemoteHostClient> CreateAsync(Workspace workspace, CancellationToken cancellationToken)
+        {
+            return InProcRemoteHostClient.CreateAsync(workspace, cancellationToken);
+        }
+    }
+}

src/VisualStudio/Core/Test.Next/Mocks/TestHostServices.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 Microsoft.CodeAnalysis.Editor.UnitTests;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.VisualStudio.Composition;
+
+namespace Roslyn.VisualStudio.Next.UnitTests.Mocks
+{
+    public static class TestHostServices
+    {
+        public static HostServices CreateHostServices()
+        {
+            return MefV1HostServices.Create(
+                MinimalTestExportProvider.CreateExportProvider(
+                    TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithPart(typeof(InProcRemoteHostClientFactory))).AsExportProvider());
+        }
+    }
+}

src/VisualStudio/Core/Test.Next/Remote/RemoteHostClientServiceFactoryTests.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;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Execution;
+using Microsoft.CodeAnalysis.Shared.Options;
+using Microsoft.VisualStudio.LanguageServices.Remote;
+using Microsoft.VisualStudio.Text.Editor;
+using Moq;
+using Roslyn.Test.Utilities;
+using Roslyn.Utilities;
+using Roslyn.VisualStudio.Next.UnitTests.Mocks;
+using Xunit;
+
+namespace Roslyn.VisualStudio.Next.UnitTests.Remote
+{
+    public class RemoteHostClientServiceFactoryTests
+    {
+        [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
+        public void Creation()
+        {
+            var service = CreateRemoteHostClientService();
+            Assert.NotNull(service);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
+        public async Task Enable_Disable()
+        {
+            var service = CreateRemoteHostClientService();
+
+            service.Enable();
+
+            var enabledClient = await service.GetRemoteHostClientAsync(CancellationToken.None).ConfigureAwait(false);
+            Assert.NotNull(enabledClient);
+
+            service.Disable();
+
+            var disabledClient = await service.GetRemoteHostClientAsync(CancellationToken.None).ConfigureAwait(false);
+            Assert.Null(disabledClient);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
+        public async Task GlobalAssets()
+        {
+            var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
+
+            var analyzerReference = new AnalyzerFileReference(typeof(object).Assembly.Location, new NullAssemblyAnalyzerLoader());
+            var service = CreateRemoteHostClientService(workspace, SpecializedCollections.SingletonEnumerable<AnalyzerReference>(analyzerReference));
+
+            service.Enable();
+
+            // make sure client is ready
+            var client = await service.GetRemoteHostClientAsync(CancellationToken.None).ConfigureAwait(false);
+
+            var checksumService = workspace.Services.GetService<ISolutionChecksumService>();
+            var asset = checksumService.GetGlobalAsset(analyzerReference, CancellationToken.None);
+            Assert.NotNull(asset);
+
+            service.Disable();
+
+            var noAsset = checksumService.GetGlobalAsset(analyzerReference, CancellationToken.None);
+            Assert.Null(noAsset);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.RemoteHost)]
+        public async Task UpdaterService()
+        {
+            var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices());
+            workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS, 1);
+
+            var analyzerReference = new AnalyzerFileReference(typeof(object).Assembly.Location, new NullAssemblyAnalyzerLoader());
+            var service = CreateRemoteHostClientService(workspace, SpecializedCollections.SingletonEnumerable<AnalyzerReference>(analyzerReference));
+
+            service.Enable();
+
+            // make sure client is ready
+            var client = await service.GetRemoteHostClientAsync(CancellationToken.None).ConfigureAwait(false);
+
+            // add solution
+            workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default));
+
+            // TODO: use waiter to make sure workspace events and updater is ready.
+            //       this delay is temporary until I set all .Next unit test hardness to setup correctly
+            await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
+
+            var checksumService = workspace.Services.GetService<ISolutionChecksumService>();
+
+            Checksum checksum;
+            using (var scope = await checksumService.CreateChecksumAsync(workspace.CurrentSolution, CancellationToken.None).ConfigureAwait(false))
+            {
+                // create solution checksum and hold onto the checksum and let it go
+                checksum = scope.SolutionChecksum.Checksum;
+            }
+
+            // there should be one held in memory by solution checksum updator
+            var solutionObject = checksumService.GetChecksumObject(checksum, CancellationToken.None);
+            Assert.Equal(solutionObject.Checksum, checksum);
+
+            service.Disable();
+        }
+
+        private RemoteHostClientServiceFactory.RemoteHostClientService CreateRemoteHostClientService(Workspace workspace = null, IEnumerable<AnalyzerReference> hostAnalyzerReferences = null)
+        {
+            workspace = workspace ?? new AdhocWorkspace(TestHostServices.CreateHostServices());
+            workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.RemoteHost, true)
+                                                 .WithChangedOption(RemoteHostOptions.RemoteHostTest, true)
+                                                 .WithChangedOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, LanguageNames.CSharp, true)
+                                                 .WithChangedOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, LanguageNames.VisualBasic, true);
+
+            var analyzerService = GetDiagnosticAnalyzerService(hostAnalyzerReferences ?? SpecializedCollections.EmptyEnumerable<AnalyzerReference>());
+
+            var optionMock = new Mock<IEditorOptions>(MockBehavior.Strict);
+            var optionFactoryMock = new Mock<IEditorOptionsFactoryService>(MockBehavior.Strict);
+            optionFactoryMock.SetupGet(i => i.GlobalOptions).Returns(optionMock.Object);
+
+            var factory = new RemoteHostClientServiceFactory(analyzerService, optionFactoryMock.Object);
+            return factory.CreateService(workspace.Services) as RemoteHostClientServiceFactory.RemoteHostClientService;
+        }
+
+        private IDiagnosticAnalyzerService GetDiagnosticAnalyzerService(IEnumerable<AnalyzerReference> references)
+        {
+            var mock = new Mock<IDiagnosticAnalyzerService>(MockBehavior.Strict);
+            mock.Setup(a => a.GetHostAnalyzerReferences()).Returns(references);
+            return mock.Object;
+        }
+
+        private class NullAssemblyAnalyzerLoader : IAnalyzerAssemblyLoader
+        {
+            public void AddDependencyLocation(string fullPath)
+            {
+            }
+
+            public Assembly LoadFromPath(string fullPath)
+            {
+                // doesn't matter what it returns
+                return typeof(object).Assembly;
+            }
+        }
+    }
+}
\ No newline at end of file

src/VisualStudio/Core/Test.Next/VisualStudioTest.Next.csproj

@@ -12,32 +12,54 @@
     <PlatformTarget>AnyCPU</PlatformTarget>
     <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
     <TargetFrameworkProfile />
+    <OutDir>$(OutDir)Dev15Tests\</OutDir>
+    <ForceGenerationOfBindingRedirects>true</ForceGenerationOfBindingRedirects>
   </PropertyGroup>
   <ItemGroup Label="Project References">
+    <ProjectReference Include="..\..\..\Compilers\CSharp\Portable\CSharpCodeAnalysis.csproj">
+      <Project>{b501a547-c911-4a05-ac6e-274a50dff30e}</Project>
+      <Name>CSharpCodeAnalysis</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Compilers\VisualBasic\Portable\BasicCodeAnalysis.vbproj">
+      <Project>{2523d0e6-df32-4a3e-8ae0-a19bffae2ef6}</Project>
+      <Name>BasicCodeAnalysis</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\EditorFeatures\CSharp\CSharpEditorFeatures.csproj">
+      <Project>{b0ce9307-ffdb-4838-a5ec-ce1f7cdc4ac2}</Project>
+      <Name>CSharpEditorFeatures</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\EditorFeatures\VisualBasic\BasicEditorFeatures.vbproj">
+      <Project>{49bfae50-1bce-48ae-bc89-78b7d90a3ecd}</Project>
+      <Name>BasicEditorFeatures</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Features\Core\Portable\Features.csproj">
+      <Project>{edc68a0e-c68d-4a74-91b7-bf38ec909888}</Project>
+      <Name>Features</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Features\CSharp\Portable\CSharpFeatures.csproj">
+      <Project>{3973b09a-4fbf-44a5-8359-3d22ceb71f71}</Project>
+      <Name>CSharpFeatures</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Features\VisualBasic\Portable\BasicFeatures.vbproj">
+      <Project>{a1bcd0ce-6c2f-4f8c-9a48-d9d93928e26d}</Project>
+      <Name>BasicFeatures</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\Test\Utilities\Portable.FX45\TestUtilities.FX45.csproj">
       <Project>{f7712928-1175-47b3-8819-ee086753dee2}</Project>
       <Name>TestUtilities.FX45</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\Test\Utilities\Portable\TestUtilities.csproj">
+      <Project>{ccbd3438-3e84-40a9-83ad-533f23bcfca5}</Project>
+      <Name>TestUtilities</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\Workspaces\Core\Desktop\Workspaces.Desktop.csproj">
       <Project>{2e87fa96-50bb-4607-8676-46521599f998}</Project>
       <Name>Workspaces.Desktop</Name>
     </ProjectReference>
-    <ProjectReference Include="..\..\..\Workspaces\CSharp\Portable\CSharpWorkspace.csproj">
-      <Project>{21B239D0-D144-430F-A394-C066D58EE267}</Project>
-      <Name>CSharpWorkspace</Name>
-    </ProjectReference>
     <ProjectReference Include="..\..\..\Compilers\Core\Portable\CodeAnalysis.csproj">
       <Project>{1EE8CAD3-55F9-4D91-96B2-084641DA9A6C}</Project>
       <Name>CodeAnalysis</Name>
     </ProjectReference>
-    <ProjectReference Include="..\..\..\Compilers\CSharp\Portable\CSharpCodeAnalysis.csproj">
-      <Project>{B501A547-C911-4A05-AC6E-274A50DFF30E}</Project>
-      <Name>CSharpCodeAnalysis</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\..\..\EditorFeatures\CSharp\CSharpEditorFeatures.csproj">
-      <Project>{B0CE9307-FFDB-4838-A5EC-CE1F7CDC4AC2}</Project>
-      <Name>CSharpEditorFeatures</Name>
-    </ProjectReference>
     <ProjectReference Include="..\..\..\EditorFeatures\Core\EditorFeatures.csproj">
       <Project>{3CDEEAB7-2256-418A-BEB2-620B5CB16302}</Project>
       <Name>EditorFeatures</Name>
@@ -54,6 +76,10 @@
       <Project>{86FD5B9A-4FA0-4B10-B59F-CFAF077A859C}</Project>
       <Name>ServicesVisualStudio</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\Workspaces\CSharp\Portable\CSharpWorkspace.csproj">
+      <Project>{21b239d0-d144-430f-a394-c066d58ee267}</Project>
+      <Name>CSharpWorkspace</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\Workspaces\Remote\Core\RemoteWorkspaces.csproj">
       <Project>{f822f72a-cc87-4e31-b57d-853f65cbebf3}</Project>
       <Name>RemoteWorkspaces</Name>
@@ -62,37 +88,30 @@
       <Project>{80fddd00-9393-47f7-8baf-7e87ce011068}</Project>
       <Name>ServiceHub</Name>
     </ProjectReference>
-    <ProjectReference Include="..\..\Core\Test\ServicesVisualStudioTest.vbproj">
-      <Project>{A1455D30-55FC-45EF-8759-3AEBDB13D940}</Project>
-      <Name>ServicesVisualStudioTest</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\..\CSharp\Impl\CSharpVisualStudio.csproj">
-      <Project>{5DEFADBD-44EB-47A2-A53E-F1282CC9E4E9}</Project>
-      <Name>CSharpVisualStudio</Name>
+    <ProjectReference Include="..\..\..\Workspaces\VisualBasic\Portable\BasicWorkspace.vbproj">
+      <Project>{57ca988d-f010-4bf2-9a2e-07d6dcd2ff2c}</Project>
+      <Name>BasicWorkspace</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\..\EditorFeatures\TestUtilities\ServicesTestUtilities.csproj">
       <Project>{76C6F005-C89D-4348-BB4A-39189DDBEB52}</Project>
       <Name>ServicesTestUtilities</Name>
     </ProjectReference>
-    <ProjectReference Include="..\..\..\Features\CSharp\Portable\CSharpFeatures.csproj">
-      <Project>{3973B09A-4FBF-44A5-8359-3D22CEB71F71}</Project>
-      <Name>CSharpFeatures</Name>
-      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
-    </ProjectReference>
     <ProjectReference Include="..\..\..\EditorFeatures\Text\TextEditorFeatures.csproj">
       <Project>{18F5FBB8-7570-4412-8CC7-0A86FF13B7BA}</Project>
       <Name>TextEditorFeatures</Name>
-      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
-    <ProjectReference Include="..\..\..\Features\Core\Portable\Features.csproj">
-      <Project>{EDC68A0E-C68D-4A74-91B7-BF38EC909888}</Project>
-      <Name>Features</Name>
-      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    <ProjectReference Include="..\..\CSharp\Impl\CSharpVisualStudio.csproj">
+      <Project>{5defadbd-44eb-47a2-a53e-f1282cc9e4e9}</Project>
+      <Name>CSharpVisualStudio</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\TestUtilities.Next\VisualStudioTestUtilities.Next.csproj">
       <Project>{78324e87-92d5-412c-9fa8-5cc2fbfbaf6c}</Project>
       <Name>VisualStudioTestUtilities.Next</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\VisualBasic\Impl\BasicVisualStudio.vbproj">
+      <Project>{d49439d7-56d2-450f-a4f0-74cb95d620e6}</Project>
+      <Name>BasicVisualStudio</Name>
+    </ProjectReference>
     <ProjectReference Include="..\Next\ServicesVisualStudio.Next.csproj">
       <Project>{fe0d4bdd-1c30-488e-a870-854f5b8c5014}</Project>
       <Name>ServicesVisualStudio.Next</Name>
@@ -103,34 +122,33 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'">
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="envdte, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-    <Reference Include="envdte80, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
     <Reference Include="Microsoft.CSharp" />
-    <Reference Include="microsoft.msxml, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-      <Private>false</Private>
-    </Reference>
     <Reference Include="System" />
     <Reference Include="System.ComponentModel.Composition" />
     <Reference Include="System.Core" />
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
     <Reference Include="System.Xml.Linq" />
-    <Reference Include="VSLangProj, Version=7.0.3300.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
   </ItemGroup>
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="app.config">
-      <SubType>Designer</SubType>
-    </None>
+    <None Include="app.config" />
     <None Include="project.json" />
   </ItemGroup>
   <ItemGroup>
     <Folder Include="RemoteWorkspace\" />
-    <Folder Include="Remote\" />
     <Folder Include="ServiceHub\" />
   </ItemGroup>
+  <ItemGroup>
+    <InternalsVisibleToMoq Include="DynamicProxyGenAssembly2" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Mocks\TestHostServices.cs" />
+    <Compile Include="Mocks\InProcRemoteHostClientFactory.cs" />
+    <Compile Include="Remote\RemoteHostClientServiceFactoryTests.cs" />
+  </ItemGroup>
   <Import Project="..\..\..\..\build\Targets\VSL.Imports.targets" />
   <Import Project="..\..\..\..\build\Targets\Roslyn.Toolsets.Xunit.targets" />
 </Project>
\ No newline at end of file

src/VisualStudio/Core/Test.Next/app.config

@@ -13,12 +13,4 @@
       </listeners>
     </trace>
   </system.diagnostics>
-  <runtime>
-    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
-      <dependentAssembly>
-        <assemblyIdentity name="System.Collections.Immutable" publicKeyToken="b03f5f7f11d50a3a" culture="neutral"/>
-        <bindingRedirect oldVersion="0.0.0.0-1.2.0.0" newVersion="1.2.0.0"/>
-      </dependentAssembly>
-    </assemblyBinding>
-  </runtime>
 </configuration>

src/VisualStudio/Core/Test.Next/project.json

 {
-  "dependencies": { },
+  "dependencies": {
+    "Newtonsoft.Json": "8.0.3"
+  },
   "frameworks": {
     "net46": {}
   },

src/VisualStudio/TestUtilities.Next/VisualStudioTestUtilities.Next.csproj

@@ -34,6 +34,14 @@
     <Reference Include="System" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\Compilers\Core\Portable\CodeAnalysis.csproj">
+      <Project>{1ee8cad3-55f9-4d91-96b2-084641da9a6c}</Project>
+      <Name>CodeAnalysis</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Features\Core\Portable\Features.csproj">
+      <Project>{EDC68A0E-C68D-4A74-91B7-BF38EC909888}</Project>
+      <Name>Features</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\Workspaces\Core\Portable\Workspaces.csproj">
       <Project>{5f8d2414-064a-4b3a-9b42-8e2a04246be5}</Project>
       <Name>Workspaces</Name>

src/Workspaces/Core/Desktop/Workspaces.Desktop.csproj

@@ -147,6 +147,7 @@
     <InternalsVisibleToTest Include="Roslyn.Services.Editor.UnitTests2" />
     <InternalsVisibleToTest Include="Roslyn.Services.Editor.CSharp.UnitTests" />
     <InternalsVisibleToTest Include="Roslyn.Services.Editor.VisualBasic.UnitTests" />
+    <InternalsVisibleToTest Include="Roslyn.Services.Test.Utilities" />
     <InternalsVisibleToTest Include="Roslyn.Services.UnitTests" />
     <InternalsVisibleToTest Include="Roslyn.VisualStudio.CSharp.UnitTests" />
     <InternalsVisibleToTest Include="RoslynETAHost" />

src/Workspaces/Core/Portable/Workspaces.csproj

@@ -282,6 +282,7 @@
     <InternalsVisibleToTest Include="Roslyn.VisualStudio.Test.Setup" />
     <InternalsVisibleToTest Include="Roslyn.VisualStudio.Test.Utilities" />
     <InternalsVisibleToTest Include="Roslyn.VisualStudio.Test.Utilities.Next" />
+    <InternalsVisibleToTest Include="Roslyn.VisualStudio.Next.UnitTests" />
     <InternalsVisibleToTest Include="Roslyn.VisualStudio.Services.UnitTests" />
     <InternalsVisibleToTest Include="RoslynETAHost" />
     <InternalsVisibleToTest Include="RoslynTaoActions" />