Make default testcase filter property name FullyQualifiedName

src/Microsoft.TestPlatform.Common/Filtering/Condition.cs

@@ -46,6 +46,15 @@ internal class Condition
         /// </summary>
         private static string propertyNameValueSeperatorString = @"(\!\=)|(\=)|(\~)|(\!)";
 
+        /// <summary>
+        ///  Default property name which will be used when filter has only property value.
+        /// </summary>
+        public const string DefaultPropertyName = "FullyQualifiedName";
+
+        /// <summary>
+        ///  Default operation which will be used when filter has only property value.
+        /// </summary>
+        public const Operation DefaultOperation = Operation.Contains;
 
         /// <summary>
         /// Name of the property used in condition.
@@ -156,17 +165,28 @@ internal bool Evaluate(Func<string, Object> propertyValueProvider)
         /// </summary>
         internal static Condition Parse(string conditionString)
         {
+            if (string.IsNullOrWhiteSpace(conditionString))
+            {
+                ThrownFormatExceptionForInvalidCondition(conditionString);
+            }
             string[] parts = Regex.Split(conditionString, propertyNameValueSeperatorString);
+            if (parts.Length == 1)
+            {
+                // If only parameter values is passed, create condition with default property name,
+                // default operation and given condition string as parameter value.
+                return new Condition(Condition.DefaultPropertyName, Condition.DefaultOperation, conditionString.Trim());
+            }
+
             if (parts.Length != 3)
             {
-                throw new FormatException(string.Format(CultureInfo.CurrentCulture, CommonResources.TestCaseFilterFormatException, string.Format(CultureInfo.CurrentCulture, CommonResources.InvalidCondition, conditionString)));
+                ThrownFormatExceptionForInvalidCondition(conditionString);
             }
 
             for (int index = 0; index < 3; index++)
             {
                 if (string.IsNullOrWhiteSpace(parts[index]))
                 {
-                    throw new FormatException(string.Format(CultureInfo.CurrentCulture, CommonResources.TestCaseFilterFormatException, string.Format(CultureInfo.CurrentCulture, CommonResources.InvalidCondition, conditionString)));
+                    ThrownFormatExceptionForInvalidCondition(conditionString);
                 }
                 parts[index] = parts[index].Trim();
             }
@@ -176,7 +196,11 @@ internal static Condition Parse(string conditionString)
             return condition;
         }
 
-
+        private static void ThrownFormatExceptionForInvalidCondition(string conditionString)
+        {
+            throw new FormatException(string.Format(CultureInfo.CurrentCulture, CommonResources.TestCaseFilterFormatException,
+                string.Format(CultureInfo.CurrentCulture, CommonResources.InvalidCondition, conditionString)));
+        }
 
 
         /// <summary>

test/Microsoft.TestPlatform.AcceptanceTests/TestCaseFilterTests.cs

@@ -128,5 +128,26 @@ public void RunSelectedTestsWithPriorityTrait(string runnerFramework, string tar
             this.InvokeVsTest(arguments);
             this.ValidateSummaryStatus(1, 0, 0);
         }
+
+        /// <summary>
+        /// In case TestCaseFilter is provide without any property like Name or ClassName. ex. /TestCaseFilter:"UnitTest1"
+        /// this command should provide same results as /TestCaseFilter:"FullyQualifiedName~UnitTest1".
+        /// </summary>
+        [CustomDataTestMethod]
+        [NET46TargetFramework]
+        [NETCORETargetFramework]
+        public void TestCaseFilterShouldWork_IfOnlyPropertyValueGivenInExpression(string runnerFramework, string targetFramework, string targetRuntime)
+        {
+            AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerFramework, targetFramework, targetRuntime);
+
+            var arguments = PrepareArguments(
+                this.GetSampleTestAssembly(),
+                this.GetTestAdapterPath(),
+                string.Empty,
+                this.FrameworkArgValue);
+            arguments = string.Concat(arguments, " /TestCaseFilter:UnitTest1");
+            this.InvokeVsTest(arguments);
+            this.ValidateSummaryStatus(1, 1, 1);
+        }
     }
 }

test/Microsoft.TestPlatform.Common.UnitTests/Filtering/ConditionTests.cs

@@ -0,0 +1,54 @@
+// 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.TestPlatform.Common.UnitTests.Filtering
+{
+    using System;
+    using Microsoft.VisualStudio.TestPlatform.Common.Filtering;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    [TestClass]
+    public class ConditionTests
+    {
+        [TestMethod]
+        public void ParseShouldThrownFormatException_OnNullConditionString()
+        {
+            string conditionString = null;
+            Assert.ThrowsException<FormatException>(() => Condition.Parse(conditionString));
+        }
+
+        [TestMethod]
+        public void ParseShouldThrownFormatException_OnEmptyConditionString()
+        {
+            var conditionString = "";
+            Assert.ThrowsException<FormatException>(() => Condition.Parse(conditionString));
+        }
+
+        [TestMethod]
+        public void ParseShouldThrownFormatException_OnIncompleteConditionString()
+        {
+            var conditionString = "PropertyName=";
+            Assert.ThrowsException<FormatException>( ()=> Condition.Parse(conditionString));
+        }
+
+        [TestMethod]
+        public void ParseShouldCreateDefaultCondition_WhenOnlyPropertyValuePassed()
+        {
+            var conditionString = "ABC";
+            Condition condition = Condition.Parse(conditionString);
+            Assert.AreEqual(Condition.DefaultPropertyName, condition.Name);
+            Assert.AreEqual(Operation.Contains, condition.Operation);
+            Assert.AreEqual(conditionString, condition.Value);
+        }
+
+        [TestMethod]
+        public void ParseShouldCreateProperCondition_OnValidConditionString()
+        {
+            var conditionString = "PropertyName=PropertyValue";
+            Condition condition = Condition.Parse(conditionString);
+            Assert.AreEqual("PropertyName", condition.Name);
+            Assert.AreEqual(Operation.Equal, condition.Operation);
+            Assert.AreEqual("PropertyValue", condition.Value);
+        }
+    }
+}