Run NetFramework tests inside vstest.console.exe process

src/Microsoft.TestPlatform.CrossPlatEngine/Client/InProcessProxyDiscoveryManager.cs

@@ -0,0 +1,101 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Client;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Engine;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Engine.TesthostProtocol;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging;
+
+    class InProcessProxyDiscoveryManager : IProxyDiscoveryManager
+    {
+        private ITestHostManagerFactory testHostManagerFactory;
+        public bool IsInitialized { get; private set; } = false;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InProcessProxyDiscoveryManager"/> class.
+        /// </summary>
+        public InProcessProxyDiscoveryManager() : this(new TestHostManagerFactory())
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InProcessProxyDiscoveryManager"/> class.
+        /// </summary>
+        /// <param name="testHostManagerFactory">Manager factory</param>
+        internal InProcessProxyDiscoveryManager(ITestHostManagerFactory testHostManagerFactory)
+        {
+            this.testHostManagerFactory = testHostManagerFactory;
+        }
+
+        /// <summary>
+        /// Initializes test discovery.
+        /// </summary>
+        public void Initialize()
+        {
+            if(!this.IsInitialized)
+            {
+                var discoveryManager = this.testHostManagerFactory.GetDiscoveryManager();
+
+                // We don't need to pass list of extension as we are running inside vstest.console and
+                // it will use TestPluginCache of vstest.console
+                discoveryManager.Initialize(Enumerable.Empty<string>());
+                this.IsInitialized = true;
+            }
+        }
+
+        /// <summary>
+        /// Discovers tests
+        /// </summary>
+        /// <param name="discoveryCriteria">Settings, parameters for the discovery request</param>
+        /// <param name="eventHandler">EventHandler for handling discovery events from Engine</param>
+        public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler eventHandler)
+        {
+            var discoveryManager = this.testHostManagerFactory.GetDiscoveryManager();
+
+            Task.Run(() =>
+            {
+                try
+                {
+                    // Initialize extension before discovery if it’s not initialized
+                    if (!this.IsInitialized)
+                    {
+                        discoveryManager.Initialize(Enumerable.Empty<string>());
+                    }
+                    discoveryManager.DiscoverTests(discoveryCriteria, eventHandler);
+                }
+                catch (Exception exception)
+                {
+                    EqtTrace.Error("InProcessProxyDiscoveryManager.DiscoverTests: Failed to discover tests: {0}", exception);
+
+                    // Send a discovery complete to caller.
+                    eventHandler.HandleLogMessage(TestMessageLevel.Error, exception.Message);
+                    eventHandler.HandleDiscoveryComplete(-1, new List<TestCase>(), true);
+                }
+            }
+            );
+        }
+
+        /// <summary>
+        /// Closes the current test operation.
+        /// This function is of no use in this context as we are not creating any testhost
+        /// </summary>
+        public void Close()
+        {
+        }
+
+        /// <summary>
+        /// Aborts the test operation.
+        /// </summary>
+        public void Abort()
+        {
+            Task.Run(() => this.testHostManagerFactory.GetDiscoveryManager().Abort());
+        }
+    }
+}

src/Microsoft.TestPlatform.CrossPlatEngine/Client/InProcessProxyexecutionManager.cs

@@ -0,0 +1,127 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client
+{
+    using System;
+    using System.Collections.ObjectModel;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Client;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Engine;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Engine.ClientProtocol;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Engine.TesthostProtocol;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging;
+
+    class InProcessProxyExecutionManager : IProxyExecutionManager
+    {
+        private ITestHostManagerFactory testHostManagerFactory;
+        public bool IsInitialized { get; private set; } = false;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InProcessProxyexecutionManager"/> class.
+        /// </summary>
+        public InProcessProxyExecutionManager() : this(new TestHostManagerFactory())
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InProcessProxyexecutionManager"/> class.
+        /// </summary>
+        /// <param name="testHostManagerFactory">
+        /// Manager factory
+        /// </param>
+        internal InProcessProxyExecutionManager(ITestHostManagerFactory testHostManagerFactory)
+        {
+            this.testHostManagerFactory = testHostManagerFactory;
+        }
+
+        public void Initialize()
+        {
+            if (!this.IsInitialized)
+            {
+                var executionManager = this.testHostManagerFactory.GetExecutionManager();
+
+                // We don't need to pass list of extension as we are running inside vstest.console and
+                // it will use TestPluginCache of vstest.console
+                executionManager.Initialize(Enumerable.Empty<string>());
+                this.IsInitialized = true;
+            }
+        }
+
+        public int StartTestRun(TestRunCriteria testRunCriteria, ITestRunEventsHandler eventHandler)
+        {
+            try
+            {
+                var executionManager = this.testHostManagerFactory.GetExecutionManager();
+
+                // Initialize extension before execution if not already initialized
+                if (!this.IsInitialized)
+                {
+                    executionManager.Initialize(Enumerable.Empty<string>());
+                }
+
+                var executionContext = new TestExecutionContext(
+                            testRunCriteria.FrequencyOfRunStatsChangeEvent,
+                            testRunCriteria.RunStatsChangeEventTimeout,
+                            inIsolation: false,
+                            keepAlive: testRunCriteria.KeepAlive,
+                            isDataCollectionEnabled: false,
+                            areTestCaseLevelEventsRequired: false,
+                            hasTestRun: true,
+                            isDebug: (testRunCriteria.TestHostLauncher != null && testRunCriteria.TestHostLauncher.IsDebug),
+                            testCaseFilter: testRunCriteria.TestCaseFilter);
+
+
+                if (testRunCriteria.HasSpecificSources)
+                {
+                    // [TODO]: we need to revisit to second-last argument if we will enable datacollector. 
+                    Task.Run(() => executionManager.StartTestRun(testRunCriteria.AdapterSourceMap, testRunCriteria.TestRunSettings, executionContext, null, eventHandler));
+                }
+                else
+                {
+                    // [TODO]: we need to revisit to second-last argument if we will enable datacollector. 
+                    Task.Run(() => executionManager.StartTestRun(testRunCriteria.Tests, testRunCriteria.TestRunSettings, executionContext, null, eventHandler));
+                }
+            }
+            catch (Exception exception)
+            {
+                EqtTrace.Error("InProcessProxyexecutionManager.StartTestRun: Failed to start test run: {0}", exception);
+
+                // Send a discovery complete to caller.
+                eventHandler.HandleLogMessage(TestMessageLevel.Error, exception.Message);
+
+                // Send a run complete to caller.
+                var completeArgs = new TestRunCompleteEventArgs(null, false, true, exception, new Collection<AttachmentSet>(), TimeSpan.Zero);
+                eventHandler.HandleTestRunComplete(completeArgs, null, null, null);
+            }
+
+            return 0;
+        }
+
+        /// <summary>
+        /// Aborts the test operation.
+        /// </summary>
+        public void Abort()
+        {
+            Task.Run(() => this.testHostManagerFactory.GetExecutionManager().Abort());
+        }
+
+        /// <summary>
+        /// Cancels the test run.
+        /// </summary>
+        public void Cancel()
+        {
+            Task.Run(() => this.testHostManagerFactory.GetExecutionManager().Cancel());
+        }
+
+        /// <summary>
+        /// Closes the current test operation.
+        /// This function is of no use in this context as we are not creating any testhost
+        /// </summary>
+        public void Close()
+        {
+        }
+    }
+}

src/Microsoft.TestPlatform.CrossPlatEngine/Discovery/DiscoveryManager.cs

@@ -60,8 +60,11 @@ public void Initialize(IEnumerable<string> pathToAdditionalExtensions)
         {
             this.testPlatformEventSource.AdapterSearchStart();
 
-            // Start using these additional extensions
-            TestPluginCache.Instance.DefaultExtensionPaths = pathToAdditionalExtensions;
+            if (pathToAdditionalExtensions != null && pathToAdditionalExtensions.Count() > 0)
+            {
+                // Start using these additional extensions
+                TestPluginCache.Instance.DefaultExtensionPaths = pathToAdditionalExtensions;
+            }
 
             // Load and Initialize extensions.
             TestDiscoveryExtensionManager.LoadAndInitializeAllExtensions(false);

src/Microsoft.TestPlatform.CrossPlatEngine/Execution/ExecutionManager.cs

@@ -5,7 +5,7 @@ namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Execution
 {
     using System;
     using System.Collections.Generic;
-
+    using System.Linq;
     using Microsoft.VisualStudio.TestPlatform.Common.ExtensionFramework;
     using Microsoft.VisualStudio.TestPlatform.Common.SettingsProvider;
     using Microsoft.VisualStudio.TestPlatform.CoreUtilities.Tracing;
@@ -53,8 +53,12 @@ public void Initialize(IEnumerable<string> pathToAdditionalExtensions)
         {
             this.testPlatformEventSource.AdapterSearchStart();
 
-            // Start using these additional extensions
-            TestPluginCache.Instance.DefaultExtensionPaths = pathToAdditionalExtensions;
+            if (pathToAdditionalExtensions != null && pathToAdditionalExtensions.Count() > 0)
+            {
+                // Start using these additional extensions
+                TestPluginCache.Instance.DefaultExtensionPaths = pathToAdditionalExtensions;
+            }
+
             this.LoadExtensions();
 
             this.testPlatformEventSource.AdapterSearchStop();

src/Microsoft.TestPlatform.CrossPlatEngine/TestEngine.cs

@@ -18,6 +18,8 @@ namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine
     using Microsoft.VisualStudio.TestPlatform.ObjectModel.Engine;
     using Microsoft.VisualStudio.TestPlatform.ObjectModel.Host;
     using Microsoft.VisualStudio.TestPlatform.ObjectModel.Utilities;
+    using Microsoft.VisualStudio.TestPlatform.PlatformAbstractions;
+    using Microsoft.VisualStudio.TestPlatform.PlatformAbstractions.Interfaces;
 
     /// <summary>
     /// Cross Platform test engine entry point for the client.
@@ -28,16 +30,18 @@ public class TestEngine : ITestEngine
 
         private readonly TestRuntimeProviderManager testHostProviderManager;
         private ITestExtensionManager testExtensionManager;
+        private IProcessHelper processHelper;
 
         #endregion
 
-        public TestEngine() : this(TestRuntimeProviderManager.Instance)
+        public TestEngine() : this(TestRuntimeProviderManager.Instance, new ProcessHelper())
         {
         }
 
-        protected TestEngine(TestRuntimeProviderManager testHostProviderManager)
+        protected TestEngine(TestRuntimeProviderManager testHostProviderManager, IProcessHelper processHelper)
         {
             this.testHostProviderManager = testHostProviderManager;
+            this.processHelper = processHelper;
         }
 
         #region ITestEngine implementation
@@ -59,14 +63,19 @@ public IProxyDiscoveryManager GetDiscoveryManager(ITestRuntimeProvider testHostM
         {
             var parallelLevel = this.VerifyParallelSettingAndCalculateParallelLevel(discoveryCriteria.Sources.Count(), discoveryCriteria.RunSettings);
 
+            if (this.ShouldRunInNoIsolation(discoveryCriteria.RunSettings))
+            {
+                return new InProcessProxyDiscoveryManager();
+            }
+
             Func<IProxyDiscoveryManager> proxyDiscoveryManagerCreator = delegate
             {
                 var hostManager = this.testHostProviderManager.GetTestHostManagerByRunConfiguration(discoveryCriteria.RunSettings);
                 hostManager?.Initialize(TestSessionMessageLogger.Instance, discoveryCriteria.RunSettings);
 
                 return new ProxyDiscoveryManager(new TestRequestSender(protocolConfig, hostManager.GetTestHostConnectionInfo()), hostManager);
             };
-                
+
             return !testHostManager.Shared ? new ParallelProxyDiscoveryManager(proxyDiscoveryManagerCreator, parallelLevel, sharedHosts: testHostManager.Shared) : proxyDiscoveryManagerCreator();
         }
 
@@ -86,6 +95,11 @@ public IProxyExecutionManager GetExecutionManager(ITestRuntimeProvider testHostM
 
             var isDataCollectorEnabled = XmlRunSettingsUtilities.IsDataCollectionEnabled(testRunCriteria.TestRunSettings);
 
+            if (parallelLevel <= 1 && !isDataCollectorEnabled && this.ShouldRunInNoIsolation(testRunCriteria.TestRunSettings))
+            {
+                return new InProcessProxyExecutionManager();
+            }
+
             // SetupChannel ProxyExecutionManager with data collection if data collectors are specififed in run settings.
             Func<IProxyExecutionManager> proxyExecutionManagerCreator = delegate
             {
@@ -103,7 +117,7 @@ public IProxyExecutionManager GetExecutionManager(ITestRuntimeProvider testHostM
                 return isDataCollectorEnabled ? new ProxyExecutionManagerWithDataCollection(requestSender, hostManager, new ProxyDataCollectionManager(testRunCriteria.TestRunSettings))
                                                 : new ProxyExecutionManager(requestSender, hostManager);
             };
-                    
+
             // parallelLevel = 1 for desktop should go via else route.
             if (parallelLevel > 1 || !testHostManager.Shared)
             {
@@ -193,5 +207,30 @@ private int VerifyParallelSettingAndCalculateParallelLevel(int sourceCount, stri
 
             return parallelLevelToUse;
         }
+
+        private bool ShouldRunInNoIsolation(string runsettings)
+        {
+            var currentProcessPath = this.processHelper.GetCurrentProcessFileName();
+
+            // If running with the dotnet executable, then dont run in NoIsolation
+            if (currentProcessPath.EndsWith("dotnet", StringComparison.OrdinalIgnoreCase)
+                || currentProcessPath.EndsWith("dotnet.exe", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runsettings);
+
+            if (runConfiguration.InProcess &&
+                !runConfiguration.DisableAppDomain &&
+                !runConfiguration.DesignMode &&
+                !(runConfiguration.TargetFrameworkVersion.Name.IndexOf("netstandard", StringComparison.OrdinalIgnoreCase) >= 0
+                || runConfiguration.TargetFrameworkVersion.Name.IndexOf("netcoreapp", StringComparison.OrdinalIgnoreCase) >= 0))
+            {
+                return true ;
+            }
+
+            return false;
+        }
     }
 }