Add support for substring-based test filtering and add infrastructure…

… (but not actual support since I don't feel like writing a parser right now) for the full dotnet test --filter syntax.

src/tests/Common/XUnitWrapperGenerator/ITestInfo.cs

@@ -13,6 +13,7 @@ namespace XUnitWrapperGenerator;
 interface ITestInfo
 {
     string TestNameExpression { get; }
+    string DisplayNameForFiltering { get; }
     string Method { get; }
     string ContainingType { get; }
 
@@ -33,6 +34,7 @@ public BasicTestMethod(IMethodSymbol method, string externAlias, ImmutableArray<
         var args = arguments.IsDefaultOrEmpty ? "" : string.Join(", ", arguments);
         ContainingType = method.ContainingType.ToDisplayString(XUnitWrapperGenerator.FullyQualifiedWithoutGlobalNamespace);
         Method = method.Name;
+        DisplayNameForFiltering = $"{ContainingType}.{Method}({args})";
         TestNameExpression = displayNameExpression ?? $"\"{externAlias}::{ContainingType}.{Method}({args})\"";
         if (method.IsStatic)
         {
@@ -45,6 +47,7 @@ public BasicTestMethod(IMethodSymbol method, string externAlias, ImmutableArray<
     }
 
     public string TestNameExpression { get; }
+    public string DisplayNameForFiltering { get; }
     public string Method { get; }
     public string ContainingType { get; }
     private string ExecutionStatement { get; }
@@ -69,10 +72,13 @@ public LegacyStandaloneEntryPointTestMethod(IMethodSymbol method, string externA
         ContainingType = method.ContainingType.ToDisplayString(XUnitWrapperGenerator.FullyQualifiedWithoutGlobalNamespace);
         Method = method.Name;
         TestNameExpression = $"\"{externAlias}::{ContainingType}.{Method}()\"";
+        DisplayNameForFiltering = $"{ContainingType}.{Method}()";
         ExecutionStatement = $"Xunit.Assert.Equal(100, {externAlias}::{ContainingType}.{Method}());";
     }
 
     public string TestNameExpression { get; }
+    public string DisplayNameForFiltering { get; }
+
     public string Method { get; }
     public string ContainingType { get; }
     private string ExecutionStatement { get; }
@@ -100,6 +106,7 @@ public ConditionalTest(ITestInfo innerTest, string condition)
         _innerTest = innerTest;
         _condition = condition;
         TestNameExpression = innerTest.TestNameExpression;
+        DisplayNameForFiltering = innerTest.DisplayNameForFiltering;
         Method = innerTest.Method;
         ContainingType = innerTest.ContainingType;
     }
@@ -110,6 +117,9 @@ public ConditionalTest(ITestInfo innerTest, Xunit.TestPlatforms platform)
     }
 
     public string TestNameExpression { get; }
+
+    public string DisplayNameForFiltering { get; }
+
     public string Method { get; }
     public string ContainingType { get; }
 
@@ -193,6 +203,7 @@ public MemberDataTest(ISymbol referencedMember, ITestInfo innerTest, string exte
         TestNameExpression = innerTest.TestNameExpression;
         Method = innerTest.Method;
         ContainingType = innerTest.ContainingType;
+        DisplayNameForFiltering = $"{ContainingType}.{Method}(...)";
         _innerTest = innerTest;
         _loopVarIdentifier = argumentLoopVarIdentifier;
 
@@ -206,6 +217,7 @@ public MemberDataTest(ISymbol referencedMember, ITestInfo innerTest, string exte
     }
 
     public string TestNameExpression { get; }
+    public string DisplayNameForFiltering { get; }
     public string Method { get; }
     public string ContainingType { get; }
 
@@ -234,12 +246,15 @@ sealed class OutOfProcessTest : ITestInfo
     public OutOfProcessTest(string displayName, string relativeAssemblyPath)
     {
         Method = displayName;
+        DisplayNameForFiltering = displayName;
         TestNameExpression = $"@\"{displayName}\"";
         ExecutionStatement = $@"TestLibrary.OutOfProcessTest.RunOutOfProcessTest(typeof(Program).Assembly.Location, @""{relativeAssemblyPath}"");";
     }
 
     public string TestNameExpression { get; }
 
+    public string DisplayNameForFiltering { get; }
+
     public string Method { get; }
 
     public string ContainingType => "OutOfProcessTest";
@@ -259,15 +274,18 @@ sealed class NoTestReporting : ITestReporterWrapper
 sealed class WrapperLibraryTestSummaryReporting : ITestReporterWrapper
 {
     private string _summaryLocalIdentifier;
+    private readonly string _filterLocalIdentifier;
 
-    public WrapperLibraryTestSummaryReporting(string summaryLocalIdentifier)
+    public WrapperLibraryTestSummaryReporting(string summaryLocalIdentifier, string filterLocalIdentifier)
     {
         _summaryLocalIdentifier = summaryLocalIdentifier;
+        _filterLocalIdentifier = filterLocalIdentifier;
     }
 
     public string WrapTestExecutionWithReporting(string testExecutionExpression, ITestInfo test)
     {
         StringBuilder builder = new();
+        builder.AppendLine($"if ({_filterLocalIdentifier} is null || {_filterLocalIdentifier}.ShouldRunTest(@\"{test.ContainingType}.{test.Method}\", {test.TestNameExpression}))");
         builder.AppendLine("{");
 
         builder.AppendLine($"TimeSpan testStart = stopwatch.Elapsed;");

src/tests/Common/XUnitWrapperGenerator/OptionsHelper.cs

@@ -11,6 +11,7 @@ public static class OptionsHelper
     private const string PriorityOption = "build_property.Priority";
     private const string RuntimeFlavorOption = "build_property.RuntimeFlavor";
     private const string IsOutOfProcessTestAssemblyOption = "build_metadata.AdditionalFiles.IsOutOfProcessTestAssembly";
+    private const string TestFilterOption = "build_metadata.AdditionalFiles.TestFilter";
     private const string TestAssemblyRelativePathOption = "build_metadata.AdditionalFiles.TestAssemblyRelativePath";
     private const string TestDisplayNameOption = "build_metadata.AdditionalFiles.TestDisplayName";
 
@@ -38,6 +39,8 @@ private static bool GetBoolOption(this AnalyzerConfigOptions options, string key
 
     internal static bool IsOutOfProcessTestAssembly(this AnalyzerConfigOptions options) => options.GetBoolOption(IsOutOfProcessTestAssemblyOption);
 
+    internal static string? TestFilter(this AnalyzerConfigOptions options) => options.TryGetValue(TestFilterOption, out string? filter) ? filter : null;
+
     internal static string? TestAssemblyRelativePath(this AnalyzerConfigOptions options) => options.TryGetValue(TestAssemblyRelativePathOption, out string? flavor) ? flavor : null;
 
     internal static string? TestDisplayName(this AnalyzerConfigOptions options) => options.TryGetValue(TestDisplayNameOption, out string? flavor) ? flavor : null;

src/tests/Common/XUnitWrapperGenerator/XUnitWrapperGenerator.cs

@@ -75,12 +75,18 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             .Collect()
             .Combine(outOfProcessTests.Collect())
             .Select((tests, ct) => tests.Left.AddRange(tests.Right))
-            .Combine(aliasMap)
             .Combine(context.AnalyzerConfigOptionsProvider)
+            .Select((data, ct) =>
+            {
+                var (tests, options) = data;
+                var filter = new XUnitWrapperLibrary.TestFilter(options.GlobalOptions.TestFilter() ?? "");
+                return (ImmutableArray.CreateRange(tests.Where(test => filter.ShouldRunTest($"{test.ContainingType}.{test.Method}", test.DisplayNameForFiltering, Array.Empty<string>()))), options);
+            })
+            .Combine(aliasMap)
             .Combine(assemblyName),
             static (context, data) =>
             {
-                var (((methods, aliasMap), configOptions), assemblyName) = data;
+                var (((methods, configOptions), aliasMap), assemblyName) = data;
 
                 bool referenceCoreLib = configOptions.GlobalOptions.ReferenceSystemPrivateCoreLib();
 
@@ -103,9 +109,10 @@ private static string GenerateFullTestRunner(ImmutableArray<ITestInfo> testInfos
     {
         // For simplicity, we'll use top-level statements for the generated Main method.
         StringBuilder builder = new();
-        ITestReporterWrapper reporter = new WrapperLibraryTestSummaryReporting("summary");
+        ITestReporterWrapper reporter = new WrapperLibraryTestSummaryReporting("summary", "filter");
         builder.AppendLine(string.Join("\n", aliasMap.Values.Where(alias => alias != "global").Select(alias => $"extern alias {alias};")));
 
+        builder.AppendLine("XUnitWrapperLibrary.TestFilter filter = args.Length != 0 ? new XUnitWrapperLibrary.TestFilter(args[0]) : null;");
         builder.AppendLine("XUnitWrapperLibrary.TestSummary summary = new();");
         builder.AppendLine("System.Diagnostics.Stopwatch stopwatch = new();");
 

src/tests/Common/XUnitWrapperGenerator/XUnitWrapperGenerator.csproj

@@ -12,4 +12,8 @@
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="$(MicrosoftCodeAnalysisCSharpVersion)" />
     <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="$(MicrosoftCodeAnalysisAnalyzersVersion)" />
   </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="../XUnitWrapperLibrary/TestFilter.cs" Link="TestFilter.cs" />
+  </ItemGroup>
 </Project>

src/tests/Common/XUnitWrapperGenerator/XUnitWrapperGenerator.props

@@ -8,6 +8,7 @@
     <!-- Properties that influence test harness generation -->
     <CompilerVisibleProperty Include="ReferenceSystemPrivateCoreLib" />
     <CompilerVisibleProperty Include="IsMergedTestRunnerAssembly" />
+    <CompilerVisibleProperty Include="TestFilter" />
     <CompilerVisibleItemMetadata Include="AdditionalFiles" MetadataName="IsOutOfProcessTestAssembly" />
     <CompilerVisibleItemMetadata Include="AdditionalFiles" MetadataName="TestAssemblyRelativePath" />
     <CompilerVisibleItemMetadata Include="AdditionalFiles" MetadataName="TestDisplayName" />

src/tests/Common/XUnitWrapperLibrary/TestFilter.cs

@@ -0,0 +1,103 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+namespace XUnitWrapperLibrary;
+
+public class TestFilter
+{
+    interface ISearchClause
+    {
+        bool IsMatch(string fullyQualifiedName, string displayName, string[] traits);
+    }
+
+    enum TermKind
+    {
+        FullyQualifiedName,
+        DisplayName
+    }
+    sealed class NameClause : ISearchClause
+    {
+        public NameClause(TermKind kind, string filter, bool substring)
+        {
+            Kind = kind;
+            Filter = filter;
+            Substring = substring;
+        }
+        public TermKind Kind { get; }
+        public string Filter { get; }
+        public bool Substring { get; }
+
+        public bool IsMatch(string fullyQualifiedName, string displayName, string[] traits)
+        {
+            string stringToSearch = Kind switch
+            {
+                TermKind.FullyQualifiedName => fullyQualifiedName,
+                TermKind.DisplayName => displayName,
+                _ => throw new InvalidOperationException()
+            };
+
+            if (Substring)
+            {
+                return stringToSearch.Contains(Filter);
+            }
+            return stringToSearch == Filter;
+        }
+    }
+
+    sealed class AndClause : ISearchClause
+    {
+        private ISearchClause _left;
+        private ISearchClause _right;
+
+        public AndClause(ISearchClause left, ISearchClause right)
+        {
+            _left = left;
+            _right = right;
+        }
+
+        public bool IsMatch(string fullyQualifiedName, string displayName, string[] traits) => _left.IsMatch(fullyQualifiedName, displayName, traits) && _right.IsMatch(fullyQualifiedName, displayName, traits);
+    }
+
+    sealed class OrClause : ISearchClause
+    {
+        private ISearchClause _left;
+        private ISearchClause _right;
+
+        public OrClause(ISearchClause left, ISearchClause right)
+        {
+            _left = left;
+            _right = right;
+        }
+
+        public bool IsMatch(string fullyQualifiedName, string displayName, string[] traits) => _left.IsMatch(fullyQualifiedName, displayName, traits) || _right.IsMatch(fullyQualifiedName, displayName, traits);
+    }
+
+    sealed class NotClause : ISearchClause
+    {
+        private ISearchClause _inner;
+
+        public NotClause(ISearchClause inner)
+        {
+            _inner = inner;
+        }
+
+        public bool IsMatch(string fullyQualifiedName, string displayName, string[] traits) => !_inner.IsMatch(fullyQualifiedName, displayName, traits);
+    }
+
+    private ISearchClause? _filter;
+
+    public TestFilter(string filterString)
+    {
+        if (filterString.IndexOfAny(new[] { '!', '(', ')', '~', '=' }) != -1)
+        {
+            throw new ArgumentException("Complex test filter expressions are not supported today. The only filters supported today are the simple form supported in 'dotnet test --filter' (substrings of the test's fully qualified name). If further filtering options are desired, file an issue on dotnet/runtime for support.", nameof(filterString));
+        }
+        _filter = new NameClause(TermKind.FullyQualifiedName, filterString, substring: true);
+    }
+
+    public bool ShouldRunTest(string fullyQualifiedName, string displayName, string[]? traits = null) => _filter is null ? true : _filter.IsMatch(fullyQualifiedName, displayName, traits ?? Array.Empty<string>());
+}