Store a collection of patterns to match against in Configuration.TestFilter instead of chaining multiple pattern-matcher filters (#494)

This fixes a crash which can occur if there are many filter or skip
arguments passed to the testing library's entry point.

In this situation, before this fix, one `Configuration.TestFilter` was
created for each filter or skip argument and they were chained together
to form a tree using `combining(with:using:)`. Then, they were applied
to a test graph recursively. If this tree was deep due to having many
filter or skip arguments chained together, the recursion could exceed
the stack and cause a crash.

The fix is to change `Configuration.TestFilter.Kind.pattern` so that it
can store multiple patterns to match against instead of just one. This
makes it more aligned with the other cases in its enum, which also store
collections, and prevents the crash since it typically results in much
shallower filter trees.

### Result:

Crash is resolved, validated by a new unit test.

### Checklist:

- [x] Code and documentation should follow the style of the [Style
Guide](https://github.com/apple/swift-testing/blob/main/Documentation/StyleGuide.md).
- [x] If public symbols are renamed or modified, DocC references should
be updated.

Author: stmontgomery

Sources/Testing/EntryPoints/EntryPoint.swift

@@ -429,9 +429,7 @@ public func configurationForEntryPoint(from args: __CommandLineArguments_v0) thr
     guard #available(_regexAPI, *) else {
       throw _EntryPointError.featureUnavailable("The `\(label)' option is not supported on this OS version.")
     }
-    return try regexes.lazy
-      .map { try Configuration.TestFilter(membership: membership, matching: $0) }
-      .reduce(into: .unfiltered) { $0.combine(with: $1, using: .or) }
+    return try Configuration.TestFilter(membership: membership, matchingAnyOf: regexes)
   }
   filters.append(try testFilter(forRegularExpressions: args.filter, label: "--filter", membership: .including))
   filters.append(try testFilter(forRegularExpressions: args.skip, label: "--skip", membership: .excluding))

Sources/Testing/Running/Configuration.TestFilter.swift

@@ -54,9 +54,9 @@ extension Configuration {
       /// The test filter contains a pattern to predicate test IDs against.
       ///
       /// - Parameters:
-      ///   - pattern: The pattern to predicate test IDs against.
+      ///   - patterns: The patterns to predicate test IDs against.
       ///   - membership: How to interpret the result when predicating tests.
-      case pattern(_ pattern: String, membership: Membership)
+      case patterns(_ patterns: [String], membership: Membership)
 
       /// The test filter is a combination of other test filter kinds.
       ///
@@ -126,21 +126,23 @@ extension Configuration.TestFilter {
   ///
   /// - Parameters:
   ///   - membership: How to interpret the result when predicating tests.
-  ///   - pattern: The pattern, expressed as a `Regex`-compatible regular
-  ///     expression, to match test IDs against.
+  ///   - patterns: The patterns, expressed as a `Regex`-compatible regular
+  ///     expressions, to match test IDs against.
   @available(_regexAPI, *)
-  init(membership: Membership, matching pattern: String) throws {
-    // Validate the regular expression by attempting to initialize a `Regex`
+  init(membership: Membership, matchingAnyOf patterns: some Sequence<String>) throws {
+    // Validate each regular expression by attempting to initialize a `Regex`
     // representing it, but do not preserve it. This type only represents
     // the pattern in the abstract, and is not responsible for actually
     // applying it to a test graph — that happens later during planning.
     //
     // Performing this validation here currently makes such errors easier to
     // surface when using the SwiftPM entry point. But longer-term, we should
     // make the planning phase throwing and propagate errors from there instead.
-    _ = try Regex(pattern)
+    for pattern in patterns {
+      _ = try Regex(pattern)
+    }
 
-    self.init(_kind: .pattern(pattern, membership: membership))
+    self.init(_kind: .patterns(Array(patterns), membership: membership))
   }
 
   /// Initialize this instance to include tests with a given set of tags.
@@ -248,15 +250,15 @@ extension Configuration.TestFilter.Kind {
             test.tags.isSuperset(of: tags)
           }
         }, membership: membership)
-      case let .pattern(pattern, membership):
+      case let .patterns(patterns, membership):
         guard #available(_regexAPI, *) else {
           throw SystemError(description: "Filtering by regular expression matching is unavailable")
         }
 
-        nonisolated(unsafe) let regex = try Regex(pattern)
+        nonisolated(unsafe) let regexes = try patterns.map(Regex.init)
         return .function({ test in
           let id = String(describing: test.id)
-          return id.contains(regex)
+          return regexes.contains { id.contains($0) }
         }, membership: membership)
       case let .combination(lhs, rhs, op):
         return try .combination(lhs.operation, rhs.operation, op)

Tests/TestingTests/ABIEntryPointTests.swift

@@ -20,6 +20,35 @@ private import _TestingInternals
 @Suite("ABI entry point tests")
 struct ABIEntryPointTests {
   @Test func v0() async throws {
+    var arguments = __CommandLineArguments_v0()
+    arguments.filter = ["NonExistentTestThatMatchesNothingHopefully"]
+    arguments.experimentalEventStreamVersion = 0
+    arguments.verbosity = .min
+
+    let result = try await _invokeEntryPointV0(passing: arguments) { recordJSON in
+      let record = try! JSON.decode(ABIv0.Record.self, from: recordJSON)
+      _ = record.version
+    }
+
+    #expect(result == EXIT_SUCCESS)
+  }
+
+  @Test("v0 entry point with a large number of filter arguments")
+  func v0_manyFilters() async throws {
+    var arguments = __CommandLineArguments_v0()
+    arguments.filter = (1...100).map { "NonExistentTestThatMatchesNothingHopefully_\($0)" }
+    arguments.experimentalEventStreamVersion = 0
+    arguments.verbosity = .min
+
+    let result = try await _invokeEntryPointV0(passing: arguments)
+
+    #expect(result == EXIT_SUCCESS)
+  }
+
+  private func _invokeEntryPointV0(
+    passing arguments: __CommandLineArguments_v0,
+    recordHandler: @escaping @Sendable (_ recordJSON: UnsafeRawBufferPointer) -> Void = { _ in }
+  ) async throws -> CInt {
 #if !os(Linux) && !SWT_NO_DYNAMIC_LINKING
     // Get the ABI entry point by dynamically looking it up at runtime.
     //
@@ -38,11 +67,6 @@ struct ABIEntryPointTests {
       abiEntryPoint.deallocate()
     }
 
-    // Construct arguments and convert them to JSON.
-    var arguments = __CommandLineArguments_v0()
-    arguments.filter = ["NonExistentTestThatMatchesNothingHopefully"]
-    arguments.experimentalEventStreamVersion = 0
-    arguments.verbosity = .min
     let argumentsJSON = try JSON.withEncoding(of: arguments) { argumentsJSON in
       let result = UnsafeMutableRawBufferPointer.allocate(byteCount: argumentsJSON.count, alignment: 1)
       result.copyMemory(from: argumentsJSON)
@@ -53,13 +77,7 @@ struct ABIEntryPointTests {
     }
 
     // Call the entry point function.
-    let result = try await abiEntryPoint.pointee(.init(argumentsJSON)) { recordJSON in
-      let record = try! JSON.decode(ABIv0.Record.self, from: recordJSON)
-      _ = record.version
-    }
-
-    // Validate expectations.
-    #expect(result == EXIT_SUCCESS)
+    return try await abiEntryPoint.pointee(.init(argumentsJSON), recordHandler)
   }
 }
 #endif