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 GetTreatNoTestsAsError(string runSettings)
+        {
+            bool failWhenNoTestFound = false;
+
+            if (runSettings != null)
+            {
+                try
+                {
+                    RunConfiguration runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runSettings);
+                    failWhenNoTestFound = GetTreatNoTestsAsError(runConfiguration);
+                }
+                catch (SettingsException se)
+                {
+                    if (EqtTrace.IsErrorEnabled)
+                    {
+                        EqtTrace.Error("RunSettingsUtilities.GetTreatNoTestsAsError: Unable to get the value of TreatNoTestsAsError from runsettings: Error {0}", se);
+                    }
+                }
+            }
+
+            return failWhenNoTestFound;
+        }
+
+        private static bool GetTreatNoTestsAsError(RunConfiguration runConfiguration)
+        {
+            bool treatNoTestsAsError = false;
+
+            if (runConfiguration != null)
+            {
+                treatNoTestsAsError = runConfiguration.TreatNoTestsAsError;
+            }
+
+            return treatNoTestsAsError;
+        }
+
 
         /// <summary>
         /// Gets the test adapters path from the run configuration

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

@@ -307,6 +307,14 @@ public Framework TargetFramework
                 this.TargetFrameworkSet = true;
             }
         }
+        /// <summary>
+        /// Gets or sets value indicating exit code when no tests are discovered or executed
+        /// </summary>
+        public bool TreatNoTestsAsError 
+        { 
+            get; 
+            set; 
+        }
 
         /// <summary>
         /// Gets or sets the target Framework this run is targeting. Possible values are Framework3.5|Framework4.0|Framework4.5
@@ -594,6 +602,13 @@ public override XmlElement ToXml()
                 root.AppendChild(dotnetHostPath);
             }
 
+            if (this.TreatNoTestsAsError)
+            {
+                XmlElement treatAsError = doc.CreateElement(nameof(TreatNoTestsAsError));
+                treatAsError.InnerText = this.TreatNoTestsAsError.ToString();
+                root.AppendChild(treatAsError);
+            }
+
             return root;
         }
 
@@ -754,7 +769,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 +914,17 @@ public static RunConfiguration FromXml(XmlReader reader)
                             XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
                             runConfiguration.DotnetHostPath = reader.ReadElementContentAsString();
                             break;
+                        case "TreatNoTestsAsError":
+                            XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
+                            string treatNoTestsAsErrorValueString = reader.ReadElementContentAsString();
+                            bool treatNoTestsAsError;
+                            if (!bool.TryParse(treatNoTestsAsErrorValueString, out treatNoTestsAsError))
+                            {
+                                throw new SettingsException(string.Format(CultureInfo.CurrentCulture,
+                                    Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, treatNoTestsAsErrorValueString, elementName));
+                            }
+                            runConfiguration.TreatNoTestsAsError = treatNoTestsAsError;
+                            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,13 @@ public ArgumentProcessorResult Execute()
             // Now that tests are discovered and filtered, we run only those selected tests.
             this.ExecuteSelectedTests();
 
+            bool treatNoTestsAsError = RunSettingsUtilities.GetTreatNoTestsAsError(effectiveRunSettings);
+
+            if (treatNoTestsAsError && this.selectedTestCases.Count == 0)
+            {
+                return ArgumentProcessorResult.Fail;
+            }
+
             return ArgumentProcessorResult.Success;
         }
 
@@ -285,6 +293,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,31 @@ 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 treatNoTestsAsError = RunSettingsUtilities.GetTreatNoTestsAsError(runSettings);
+
+            if (treatNoTestsAsError && 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 +253,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

test/Microsoft.TestPlatform.AcceptanceTests/ExecutionTests.cs

@@ -263,5 +263,77 @@ public void IncompatibleSourcesWarningShouldBeDisplayedInTheConsoleOnlyWhenRunni
                 this.StdOutputContains(expectedWarningContains);
             }
         }
+
+        [TestMethod]
+        [NetFullTargetFrameworkDataSource]
+        public void ExitCodeShouldReturnOneWhenTreatNoTestsAsErrorParameterSetToTrueAndNoTestMatchesFilter(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 the test name, which does not exists in the assembly, so we will have 0 tests executed
+            arguments = string.Concat(arguments, " /TestCaseFilter:TestNameThatMatchesNoTestInTheAssembly");
+
+            arguments = string.Concat(arguments, " -- RunConfiguration.TreatNoTestsAsError=true");
+            this.InvokeVsTest(arguments);
+
+            this.ExitCodeEquals(1);
+        }
+
+        [TestMethod]
+        [NetFullTargetFrameworkDataSource]
+        public void ExitCodeShouldReturnZeroWhenTreatNoTestsAsErrorParameterSetToFalseAndNoTestMatchesFilter(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 the test name, which does not exists in the assembly, so we will have 0 tests executed
+            arguments = string.Concat(arguments, " /TestCaseFilter:TestNameThatMatchesNoTestInTheAssembly");
+
+            arguments = string.Concat(arguments, " -- RunConfiguration.TreatNoTestsAsError=false");
+            this.InvokeVsTest(arguments);
+
+            this.ExitCodeEquals(0);
+        }
+
+        [TestMethod]
+        [NetFullTargetFrameworkDataSource]
+        public void ExitCodeShouldNotDependOnTreatNoTestsAsErrorTrueValueWhenThereAreAnyTestsToRun(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);
+
+            arguments = string.Concat(arguments, " -- RunConfiguration.TreatNoTestsAsError=true");
+            this.InvokeVsTest(arguments);
+
+            // Returning 1 because of failing test in test assembly (SimpleTestProject2.dll)
+            this.ExitCodeEquals(1);
+        }
+
+        [TestMethod]
+        [NetFullTargetFrameworkDataSource]
+        public void ExitCodeShouldNotDependOnFailTreatNoTestsAsErrorFalseValueWhenTestsAreAvailable(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);
+
+            arguments = string.Concat(arguments, " -- RunConfiguration.TreatNoTestsAsError=false");
+            this.InvokeVsTest(arguments);
+
+            // Returning 1 because of failing test in test assembly (SimpleTestProject2.dll)
+            this.ExitCodeEquals(1);
+        }
     }
 }