Implemented functionality to return non-zero value when no tests available.

src/Microsoft.TestPlatform.Common/Utilities/RunSettingsUtilities.cs

@@ -130,6 +130,46 @@ public static int GetMaxCpuCount(RunConfiguration runConfiguration)
 
             return cpuCount;
         }
+        /// <summary>
+        /// Gets the value of FailWhenNoTestsFound parameter from runsettings file
+        /// </summary>
+        /// <param name="runSettings">Runsetting string value</param>
+        /// <returns>The value of FailWhenNoTestsFound</returns>
+        public static bool GetFailWhenNoTestsFound(string runSettings)
+        {
+            bool failWhenNoTestFound = false;
+
+            if (runSettings != null)
+            {
+                try
+                {
+                    RunConfiguration runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runSettings);
+                    failWhenNoTestFound = GetFailWhenNoTestsFound(runConfiguration);
+                }
+                catch (SettingsException se)
+                {
+                    if (EqtTrace.IsErrorEnabled)
+                    {
+                        EqtTrace.Error("RunSpecificTestsArgumentProcessor.GetFailWhenNoTestsFound: Unable to get the value of FailWhenNoTestsFound from runsettings: Error {0}", se);
+                    }
+                }
+            }
+
+            return failWhenNoTestFound;
+        }
+
+        private static bool GetFailWhenNoTestsFound(RunConfiguration runConfiguration)
+        {
+            bool failWhenNoTestsFound = false;
+
+            if (runConfiguration != null)
+            {
+                failWhenNoTestsFound = runConfiguration.FailWhenNoTestsFound;
+            }
+
+            return failWhenNoTestsFound;
+        }
+
 
         /// <summary>
         /// Gets the test adapters path from the run configuration

src/Microsoft.TestPlatform.ObjectModel/RunSettings/RunConfiguration.cs

@@ -84,6 +84,11 @@ public class RunConfiguration : TestRunSettings
         /// </summary>
         private string targetDevice;
 
+        /// <summary>
+        /// Defines if Test Platform should return non-zero value if no tests found and executed
+        /// </summary>
+        private bool failWhenNoTestsFound;
+
         #endregion
 
         #region Constructor
@@ -308,6 +313,18 @@ public Framework TargetFramework
             }
         }
 
+        public bool FailWhenNoTestsFound
+        {
+            get
+            {
+                return failWhenNoTestsFound;
+            }
+            set
+            {
+                this.failWhenNoTestsFound = value;
+            }
+        }
+
         /// <summary>
         /// Gets or sets the target Framework this run is targeting. Possible values are Framework3.5|Framework4.0|Framework4.5
         /// </summary>
@@ -594,6 +611,13 @@ public override XmlElement ToXml()
                 root.AppendChild(dotnetHostPath);
             }
 
+            if (this.FailWhenNoTestsFound)
+            {
+                XmlElement treatAsError = doc.CreateElement(nameof(FailWhenNoTestsFound));
+                treatAsError.InnerText = this.FailWhenNoTestsFound.ToString();
+                root.AppendChild(treatAsError);
+            }
+
             return root;
         }
 
@@ -754,7 +778,7 @@ public static RunConfiguration FromXml(XmlReader reader)
                             bool disableParallelizationCheck;
                             if (!bool.TryParse(disableParallelizationValueString, out disableParallelizationCheck))
                             {
-                                throw new SettingsException(String.Format(CultureInfo.CurrentCulture,
+                                throw new SettingsException(string.Format(CultureInfo.CurrentCulture,
                                     Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, disableParallelizationValueString, elementName));
                             }
                             runConfiguration.DisableParallelization = disableParallelizationCheck;
@@ -899,6 +923,17 @@ public static RunConfiguration FromXml(XmlReader reader)
                             XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
                             runConfiguration.DotnetHostPath = reader.ReadElementContentAsString();
                             break;
+                        case "FailWhenNoTestsFound":
+                            XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
+                            string failWhenNoTestsFoundValueString = reader.ReadElementContentAsString();
+                            bool failWhenNoTestsFound;
+                            if (!bool.TryParse(failWhenNoTestsFoundValueString, out failWhenNoTestsFound))
+                            {
+                                throw new SettingsException(string.Format(CultureInfo.CurrentCulture,
+                                    Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, failWhenNoTestsFoundValueString, elementName));
+                            }
+                            runConfiguration.FailWhenNoTestsFound = failWhenNoTestsFound;
+                            break;
 
                         default:
                             // Ignore a runsettings element that we don't understand. It could occur in the case

src/vstest.console/Processors/RunSpecificTestsArgumentProcessor.cs

@@ -10,15 +10,16 @@ namespace Microsoft.VisualStudio.TestPlatform.CommandLine.Processors
     using System.Globalization;
     using System.Linq;
 
+    using Microsoft.VisualStudio.TestPlatform.Common;
+    using Microsoft.VisualStudio.TestPlatform.Common.Interfaces;
+    using Microsoft.VisualStudio.TestPlatform.Common.Utilities;
     using Microsoft.VisualStudio.TestPlatform.Client.RequestHelper;
     using Microsoft.VisualStudio.TestPlatform.CommandLine.Internal;
     using Microsoft.VisualStudio.TestPlatform.CommandLine.TestPlatformHelpers;
-    using Microsoft.VisualStudio.TestPlatform.Common;
-    using Microsoft.VisualStudio.TestPlatform.Common.Interfaces;
     using Microsoft.VisualStudio.TestPlatform.ObjectModel;
     using Microsoft.VisualStudio.TestPlatform.ObjectModel.Client;
     using Microsoft.VisualStudio.TestPlatform.Utilities;
-    using CommandLineResources = Microsoft.VisualStudio.TestPlatform.CommandLine.Resources.Resources;
+    using CommandLineResources = Resources.Resources;
 
     internal class RunSpecificTestsArgumentProcessor : IArgumentProcessor
     {
@@ -218,6 +219,14 @@ public ArgumentProcessorResult Execute()
             // Now that tests are discovered and filtered, we run only those selected tests.
             this.ExecuteSelectedTests();
 
+            bool failWhenNoTestsFound = RunSettingsUtilities.GetFailWhenNoTestsFound(effectiveRunSettings);
+
+            // If no tests found and FailWhenNoTestsFound parameter set to `true` then return fail
+            if (failWhenNoTestsFound && this.selectedTestCases.Count == 0)
+            {
+                return ArgumentProcessorResult.Fail;
+            }
+
             return ArgumentProcessorResult.Success;
         }
 
@@ -285,6 +294,7 @@ private void ExecuteSelectedTests()
             }
         }
 
+
         /// <summary>
         /// Filter discovered tests and find matching tests from given search strings.
         /// Any name of the test that can match multiple strings will be added only once.

src/vstest.console/Processors/RunTestsArgumentProcessor.cs

@@ -4,7 +4,6 @@
 namespace Microsoft.VisualStudio.TestPlatform.CommandLine.Processors
 {
     using System;
-    using System.Collections.Generic;
     using System.Diagnostics.Contracts;
     using System.Globalization;
     using System.Linq;
@@ -14,11 +13,12 @@ namespace Microsoft.VisualStudio.TestPlatform.CommandLine.Processors
     using Microsoft.VisualStudio.TestPlatform.CommandLine.TestPlatformHelpers;
     using Microsoft.VisualStudio.TestPlatform.Common;
     using Microsoft.VisualStudio.TestPlatform.Common.Interfaces;
+    using Microsoft.VisualStudio.TestPlatform.Common.Utilities;
     using Microsoft.VisualStudio.TestPlatform.ObjectModel;
     using Microsoft.VisualStudio.TestPlatform.ObjectModel.Client;
     using Microsoft.VisualStudio.TestPlatform.Utilities;
 
-    using CommandLineResources = Microsoft.VisualStudio.TestPlatform.CommandLine.Resources.Resources;
+    using CommandLineResources = Resources.Resources;
 
     internal class RunTestsArgumentProcessor : IArgumentProcessor
     {
@@ -110,6 +110,11 @@ internal class RunTestsArgumentExecutor : IArgumentExecutor
         /// Registers and Unregisters for test run events before and after test run
         /// </summary>
         private ITestRunEventsRegistrar testRunEventsRegistrar;
+
+        /// <summary>
+        /// Shows the number of tests which were executed
+        /// </summary>
+        private static long numberOfExecutedTests;
 
         #endregion
 
@@ -168,24 +173,32 @@ public ArgumentProcessorResult Execute()
                 this.output.Information(false, CommandLineResources.VstestDiagLogOutputPath, EqtTrace.LogFile);
             }
 
+            var runSettings = this.runSettingsManager.ActiveRunSettings.SettingsXml;
+
             if (this.commandLineOptions.Sources.Any())
             {
-                this.RunTests(this.commandLineOptions.Sources);
+                this.RunTests(runSettings);
+            }
+
+            bool failWhenNoTestsFound = RunSettingsUtilities.GetFailWhenNoTestsFound(runSettings);
+
+            // If no tests found and FailWhenNoTestsFound parameter set to `true` then return fail
+            if (failWhenNoTestsFound && numberOfExecutedTests == 0)
+            {
+                return ArgumentProcessorResult.Fail;
             }
 
             return ArgumentProcessorResult.Success;
         }
 
-        private void RunTests(IEnumerable<string> sources)
+        private void RunTests(string runSettings)
         {
             // create/start test run
             if (EqtTrace.IsInfoEnabled)
             {
                 EqtTrace.Info("RunTestsArgumentProcessor:Execute: Test run is starting.");
             }
 
-            var runSettings = this.runSettingsManager.ActiveRunSettings.SettingsXml;
-
             if (EqtTrace.IsVerboseEnabled)
             {
                 EqtTrace.Verbose("RunTestsArgumentProcessor:Execute: Queuing Test run.");
@@ -241,6 +254,7 @@ private void TestRunRequest_OnRunCompletion(object sender, TestRunCompleteEventA
                 // we need to check if there are any tests executed - to try show some help info to user to check for installed vsix extensions
                 if (!e.IsAborted && !e.IsCanceled)
                 {
+                    numberOfExecutedTests = e.TestRunStatistics.ExecutedTests;
                     var testsFoundInAnySource = (e.TestRunStatistics == null) ? false : (e.TestRunStatistics.ExecutedTests > 0);
 
                     // Indicate the user to use test adapter path command if there are no tests found

src/vstest.console/Program.cs

@@ -4,7 +4,9 @@
 namespace Microsoft.VisualStudio.TestPlatform.CommandLine
 {
     using System;
+    using System.Diagnostics;
     using System.Globalization;
+    using System.Threading;
     using Microsoft.VisualStudio.TestPlatform.Utilities;
 
     /// <summary>
@@ -24,21 +26,20 @@ public static int Main(string[] args)
             {
                 ConsoleOutput.Instance.WriteLine("Waiting for debugger attach...", OutputLevel.Information);
 
-                var currentProcess = System.Diagnostics.Process.GetCurrentProcess();
+                var currentProcess = Process.GetCurrentProcess();
                 ConsoleOutput.Instance.WriteLine(
                     string.Format("Process Id: {0}, Name: {1}", currentProcess.Id, currentProcess.ProcessName),
                     OutputLevel.Information);
 
-                while (!System.Diagnostics.Debugger.IsAttached)
+                while (!Debugger.IsAttached)
                 {
-                    System.Threading.Thread.Sleep(1000);
+                    Thread.Sleep(1000);
                 }
 
-                System.Diagnostics.Debugger.Break();
+                Debugger.Break();
             }
 
             SetCultureSpecifiedByUser();
-
             return new Executor(ConsoleOutput.Instance).Execute(args);
         }
 

test/Microsoft.TestPlatform.AcceptanceTests/ExecutionTests.cs

@@ -263,5 +263,79 @@ public void IncompatibleSourcesWarningShouldBeDisplayedInTheConsoleOnlyWhenRunni
                 this.StdOutputContains(expectedWarningContains);
             }
         }
+
+        [TestMethod]
+        [NetFullTargetFrameworkDataSource]
+        public void ExitCodeShouldReturnOneWhenFailWhenNoTestsFoundParameterSetToTrueAndNoTestAvailableWithFilter(RunnerInfo runnerInfo)
+        {
+            SetTestEnvironment(this.testEnvironment, runnerInfo);
+
+            var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject2.dll").Trim('\"');
+
+            var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue);
+
+            // Setting /TestCaseFilter to random test name, which does not exists
+            arguments = string.Concat(arguments, " /TestCaseFilter:SomeRandomTestName");
+
+            // set FailWhenNoTestsFound to true
+            arguments = string.Concat(arguments, " -- RunConfiguration.FailWhenNoTestsFound=true");
+            this.InvokeVsTest(arguments);
+
+            this.ExitCodeEquals(1);
+        }
+
+        [TestMethod]
+        [NetFullTargetFrameworkDataSource]
+        public void ExitCodeShouldReturnZeroWhenFailWhenNoTestsFoundParameterSetToTrueAndNoTestAvailableWithFilter(RunnerInfo runnerInfo)
+        {
+            SetTestEnvironment(this.testEnvironment, runnerInfo);
+
+            var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject2.dll").Trim('\"');
+
+            var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue);
+
+            // Setting /TestCaseFilter to random test name, which does not exists
+            arguments = string.Concat(arguments, " /TestCaseFilter:SomeRandomTestName");
+
+            // set FailWhenNoTestsFound to true
+            arguments = string.Concat(arguments, " -- RunConfiguration.FailWhenNoTestsFound=false");
+            this.InvokeVsTest(arguments);
+
+            this.ExitCodeEquals(0);
+        }
+
+        [TestMethod]
+        [NetFullTargetFrameworkDataSource]
+        public void ExitCodeShouldNotDependOnFailWhenNoTestsFoundTrueValueWhenTestsAreAvailable(RunnerInfo runnerInfo)
+        {
+            SetTestEnvironment(this.testEnvironment, runnerInfo);
+
+            var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject2.dll").Trim('\"');
+
+            var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue);
+
+            // set FailWhenNoTestsFound to true
+            arguments = string.Concat(arguments, " -- RunConfiguration.FailWhenNoTestsFound=true");
+            this.InvokeVsTest(arguments);
+
+            this.ExitCodeEquals(1);
+        }
+
+        [TestMethod]
+        [NetFullTargetFrameworkDataSource]
+        public void ExitCodeShouldNotDependOnFailWhenNoTestsFoundFalseValueWhenTestsAreAvailable(RunnerInfo runnerInfo)
+        {
+            SetTestEnvironment(this.testEnvironment, runnerInfo);
+
+            var assemblyPaths = this.BuildMultipleAssemblyPath("SimpleTestProject2.dll").Trim('\"');
+
+            var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, this.FrameworkArgValue, runnerInfo.InIsolationValue);
+
+            // set FailWhenNoTestsFound to true
+            arguments = string.Concat(arguments, " -- RunConfiguration.FailWhenNoTestsFound=true");
+            this.InvokeVsTest(arguments);
+
+            this.ExitCodeEquals(1);
+        }
     }
 }