Merge pull request #1127 from stmontgomery/main-6.2-merge

Merge 'main' branch to 'release/6.2'

Author: stmontgomery

.github/ISSUE_TEMPLATE/01-bug-report.yml

@@ -9,7 +9,7 @@
 name: 🪲 Report a bug
 description: >
   Report a deviation from expected or documented behavior.
-labels: [bug, triage-needed]
+labels: [bug]
 body:
   - type: markdown
     attributes:

.github/ISSUE_TEMPLATE/02-change-request.yml

@@ -9,7 +9,7 @@
 name: 🌟 Request a change
 description: >
   Request a feature, API, improvement, or other change.
-labels: [enhancement, triage-needed]
+labels: [enhancement]
 body:
   - type: markdown
     attributes:

Documentation/CMake.md

@@ -59,21 +59,38 @@ endif()
 ## Add an entry point
 
 You must include a source file in your test executable target with a
-`@main` entry point. The following example uses the SwiftPM entry point:
+`@main` entry point. The example main below requires the experimental
+`Extern` feature. The function `swt_abiv0_getEntryPoint` is exported
+from the swift-testing dylib. As such, its declaration could instead
+be written in a C header file with its own `module.modulemap`, or
+the runtime address could be obtained via
+[`dlsym()`](https://pubs.opengroup.org/onlinepubs/9799919799/functions/dlsym.html) or
+[`GetProcAddress()`](https://learn.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getprocaddress).
 
 ```swift
-import Testing
+typealias EntryPoint = @convention(thin) @Sendable (_ configurationJSON: UnsafeRawBufferPointer?, _ recordHandler: @escaping @Sendable (_ recordJSON: UnsafeRawBufferPointer) -> Void) async throws -> Bool
+
+@_extern(c, "swt_abiv0_getEntryPoint")
+func swt_abiv0_getEntryPoint() -> UnsafeRawPointer
 
 @main struct Runner {
-    static func main() async {
-        await Testing.__swiftPMEntryPoint() as Never
+    static func main() async throws {
+        nonisolated(unsafe) let configurationJSON: UnsafeRawBufferPointer? = nil
+        let recordHandler: @Sendable (UnsafeRawBufferPointer) -> Void = { _ in }
+
+        let entryPoint = unsafeBitCast(swt_abiv0_getEntryPoint(), to: EntryPoint.self)
+
+        if try await entryPoint(configurationJSON, recordHandler) {
+            exit(EXIT_SUCCESS)
+        } else {
+            exit(EXIT_FAILURE)
+        }
     }
 }
 ```
 
-> [!WARNING]
-> The entry point is expected to change to an entry point designed for other
-> build systems prior to the initial stable release of Swift Testing.
+For more information on the input configuration and output records of the ABI entry
+point, refer to the [ABI documentation](ABI/JSON.md).
 
 ## Integrate with CTest
 

Package.swift

@@ -288,6 +288,8 @@ extension Array where Element == PackageDescription.SwiftSetting {
       // new-enough toolchain.
       .enableExperimentalFeature("AllowUnsafeAttribute"),
 
+      .enableUpcomingFeature("InferIsolatedConformances"),
+
       // When building as a package, the macro plugin always builds as an
       // executable rather than a library.
       .define("SWT_NO_LIBRARY_MACRO_PLUGINS"),

Sources/CMakeLists.txt

@@ -66,7 +66,7 @@ if(SwiftTesting_MACRO STREQUAL "<auto>")
   if(NOT SwiftTesting_BuildMacrosAsExecutables)
     if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
       set(SwiftTesting_MACRO_PATH "${SwiftTesting_MACRO_INSTALL_PREFIX}/lib/swift/host/plugins/testing/libTestingMacros.dylib")
-    elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux" or CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD")
+    elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux" OR CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD")
       set(SwiftTesting_MACRO_PATH "${SwiftTesting_MACRO_INSTALL_PREFIX}/lib/swift/host/plugins/libTestingMacros.so")
     elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
       set(SwiftTesting_MACRO_PATH "${SwiftTesting_MACRO_INSTALL_PREFIX}/bin/TestingMacros.dll")

Sources/Testing/Events/Recorder/Event.HumanReadableOutputRecorder.swift

@@ -36,7 +36,7 @@ extension Event {
 
     /// A type that contains mutable context for
     /// ``Event/ConsoleOutputRecorder``.
-    private struct _Context {
+    fileprivate struct Context {
       /// The instant at which the run started.
       var runStartInstant: Test.Clock.Instant?
 
@@ -51,6 +51,17 @@ extension Event {
       /// The number of test suites started or skipped during the run.
       var suiteCount = 0
 
+      /// An enumeration describing the various keys which can be used in a test
+      /// data graph for an output recorder.
+      enum TestDataKey: Hashable {
+        /// A string key, typically containing one key from the key path
+        /// representation of a ``Test/ID`` instance.
+        case string(String)
+
+        /// A test case ID.
+        case testCaseID(Test.Case.ID)
+      }
+
       /// A type describing data tracked on a per-test basis.
       struct TestData {
         /// The instant at which the test started.
@@ -62,18 +73,15 @@ extension Event {
 
         /// The number of known issues recorded for the test.
         var knownIssueCount = 0
-        
-        /// The number of test cases for the test.
-        var testCasesCount = 0
       }
 
       /// Data tracked on a per-test basis.
-      var testData = Graph<String, TestData?>()
+      var testData = Graph<TestDataKey, TestData?>()
     }
 
     /// This event recorder's mutable context about events it has received,
     /// which may be used to inform how subsequent events are written.
-    private var _context = Locked(rawValue: _Context())
+    private var _context = Locked(rawValue: Context())
 
     /// Initialize a new human-readable event recorder.
     ///
@@ -128,7 +136,9 @@ extension Event.HumanReadableOutputRecorder {
   ///   - graph: The graph to walk while counting issues.
   ///
   /// - Returns: A tuple containing the number of issues recorded in `graph`.
-  private func _issueCounts(in graph: Graph<String, Event.HumanReadableOutputRecorder._Context.TestData?>?) -> (errorIssueCount: Int, warningIssueCount: Int, knownIssueCount: Int, totalIssueCount: Int, description: String) {
+  private func _issueCounts(
+    in graph: Graph<Event.HumanReadableOutputRecorder.Context.TestDataKey, Event.HumanReadableOutputRecorder.Context.TestData?>?
+  ) -> (errorIssueCount: Int, warningIssueCount: Int, knownIssueCount: Int, totalIssueCount: Int, description: String) {
     guard let graph else {
       return (0, 0, 0, 0, "")
     }
@@ -241,6 +251,7 @@ extension Event.HumanReadableOutputRecorder {
       0
     }
     let test = eventContext.test
+    let keyPath = eventContext.keyPath
     let testName = if let test {
       if let displayName = test.displayName {
         if verbosity > 0 {
@@ -271,7 +282,7 @@ extension Event.HumanReadableOutputRecorder {
 
       case .testStarted:
         let test = test!
-        context.testData[test.id.keyPathRepresentation] = .init(startInstant: instant)
+        context.testData[keyPath] = .init(startInstant: instant)
         if test.isSuite {
           context.suiteCount += 1
         } else {
@@ -287,23 +298,17 @@ extension Event.HumanReadableOutputRecorder {
         }
 
       case let .issueRecorded(issue):
-        let id: [String] = if let test {
-          test.id.keyPathRepresentation
-        } else {
-          []
-        }
-        var testData = context.testData[id] ?? .init(startInstant: instant)
+        var testData = context.testData[keyPath] ?? .init(startInstant: instant)
         if issue.isKnown {
           testData.knownIssueCount += 1
         } else {
           let issueCount = testData.issueCount[issue.severity] ?? 0
           testData.issueCount[issue.severity] = issueCount + 1
         }
-        context.testData[id] = testData
+        context.testData[keyPath] = testData
 
       case .testCaseStarted:
-        let test = test!
-        context.testData[test.id.keyPathRepresentation]?.testCasesCount += 1
+        context.testData[keyPath] = .init(startInstant: instant)
 
       default:
         // These events do not manipulate the context structure.
@@ -384,13 +389,12 @@ extension Event.HumanReadableOutputRecorder {
 
     case .testEnded:
       let test = test!
-      let id = test.id
-      let testDataGraph = context.testData.subgraph(at: id.keyPathRepresentation)
+      let testDataGraph = context.testData.subgraph(at: keyPath)
       let testData = testDataGraph?.value ?? .init(startInstant: instant)
       let issues = _issueCounts(in: testDataGraph)
       let duration = testData.startInstant.descriptionOfDuration(to: instant)
-      let testCasesCount = if test.isParameterized {
-        " with \(testData.testCasesCount.counting("test case"))"
+      let testCasesCount = if test.isParameterized, let testDataGraph {
+        " with \(testDataGraph.children.count.counting("test case"))"
       } else {
         ""
       }
@@ -517,15 +521,37 @@ extension Event.HumanReadableOutputRecorder {
         break
       }
 
+      let status = verbosity > 0 ? " started" : ""
+
       return [
         Message(
           symbol: .default,
-          stringValue: "Passing \(arguments.count.counting("argument")) \(testCase.labeledArguments(includingQualifiedTypeNames: verbosity > 0)) to \(testName)"
+          stringValue: "Test case passing \(arguments.count.counting("argument")) \(testCase.labeledArguments(includingQualifiedTypeNames: verbosity > 0)) to \(testName)\(status) started."
         )
       ]
 
     case .testCaseEnded:
-      break
+      guard verbosity > 0, let testCase = eventContext.testCase, testCase.isParameterized, let arguments = testCase.arguments else {
+        break
+      }
+
+      let testDataGraph = context.testData.subgraph(at: keyPath)
+      let testData = testDataGraph?.value ?? .init(startInstant: instant)
+      let issues = _issueCounts(in: testDataGraph)
+      let duration = testData.startInstant.descriptionOfDuration(to: instant)
+
+      let message = if issues.errorIssueCount > 0 {
+        Message(
+          symbol: .fail,
+          stringValue: "Test case passing \(arguments.count.counting("argument")) \(testCase.labeledArguments(includingQualifiedTypeNames: verbosity > 0)) to \(testName) failed after \(duration)\(issues.description)."
+        )
+      } else {
+        Message(
+          symbol: .pass(knownIssueCount: issues.knownIssueCount),
+          stringValue: "Test case passing \(arguments.count.counting("argument")) \(testCase.labeledArguments(includingQualifiedTypeNames: verbosity > 0)) to \(testName) passed after \(duration)\(issues.description)."
+        )
+      }
+      return [message]
 
     case let .iterationEnded(index):
       guard let iterationStartInstant = context.iterationStartInstant else {
@@ -542,6 +568,7 @@ extension Event.HumanReadableOutputRecorder {
 
     case .runEnded:
       let testCount = context.testCount
+      let suiteCount = context.suiteCount
       let issues = _issueCounts(in: context.testData)
       let runStartInstant = context.runStartInstant ?? instant
       let duration = runStartInstant.descriptionOfDuration(to: instant)
@@ -550,14 +577,14 @@ extension Event.HumanReadableOutputRecorder {
         [
           Message(
             symbol: .fail,
-            stringValue: "Test run with \(testCount.counting("test")) failed after \(duration)\(issues.description)."
+            stringValue: "Test run with \(testCount.counting("test")) in \(suiteCount.counting("suite")) failed after \(duration)\(issues.description)."
           )
         ]
       } else {
         [
           Message(
             symbol: .pass(knownIssueCount: issues.knownIssueCount),
-            stringValue: "Test run with \(testCount.counting("test")) passed after \(duration)\(issues.description)."
+            stringValue: "Test run with \(testCount.counting("test")) in \(suiteCount.counting("suite")) passed after \(duration)\(issues.description)."
           )
         ]
       }
@@ -567,6 +594,31 @@ extension Event.HumanReadableOutputRecorder {
   }
 }
 
+extension Test.ID {
+  /// The key path in a test data graph representing this test ID.
+  fileprivate var keyPath: some Collection<Event.HumanReadableOutputRecorder.Context.TestDataKey> {
+    keyPathRepresentation.map { .string($0) }
+  }
+}
+
+extension Event.Context {
+  /// The key path in a test data graph representing this event this context is
+  /// associated with, including its test and/or test case IDs.
+  fileprivate var keyPath: some Collection<Event.HumanReadableOutputRecorder.Context.TestDataKey> {
+    var keyPath = [Event.HumanReadableOutputRecorder.Context.TestDataKey]()
+
+    if let test {
+      keyPath.append(contentsOf: test.id.keyPath)
+
+      if let testCase {
+        keyPath.append(.testCaseID(testCase.id))
+      }
+    }
+
+    return keyPath
+  }
+}
+
 // MARK: - Codable
 
 extension Event.HumanReadableOutputRecorder.Message: Codable {}

Sources/Testing/Running/Configuration.TestFilter.swift

@@ -514,7 +514,7 @@ extension Configuration.TestFilter.Kind {
 
 /// A protocol representing a value which can be filtered using
 /// ``Configuration/TestFilter-swift.struct``.
-private protocol _FilterableItem {
+private protocol _FilterableItem: Sendable {
   /// The test this item represents.
   var test: Test { get }
 

Sources/Testing/SourceAttribution/CustomTestStringConvertible.swift

@@ -42,9 +42,9 @@
 /// the default description of a value may not be adequately descriptive:
 ///
 /// ```
-/// ◇ Passing argument food → .paella to isDelicious(_:)
-/// ◇ Passing argument food → .oden to isDelicious(_:)
-/// ◇ Passing argument food → .ragu to isDelicious(_:)
+/// ◇ Test case passing 1 argument food → .paella to isDelicious(_:) started.
+/// ◇ Test case passing 1 argument food → .oden to isDelicious(_:) started.
+/// ◇ Test case passing 1 argument food → .ragu to isDelicious(_:) started.
 /// ```
 ///
 /// By adopting ``CustomTestStringConvertible``, customized descriptions can be
@@ -69,9 +69,9 @@
 /// ``testDescription`` property:
 ///
 /// ```
-/// ◇ Passing argument food → paella valenciana to isDelicious(_:)
-/// ◇ Passing argument food → おでん to isDelicious(_:)
-/// ◇ Passing argument food → ragù alla bolognese to isDelicious(_:)
+/// ◇ Test case passing 1 argument food → paella valenciana to isDelicious(_:) started.
+/// ◇ Test case passing 1 argument food → おでん to isDelicious(_:) started.
+/// ◇ Test case passing 1 argument food → ragù alla bolognese to isDelicious(_:) started.
 /// ```
 ///
 /// ## See Also