Fix: Signal Handling System and Live Failure Reporting

Author: tienquocbui

Sources/Testing/CMakeLists.txt

@@ -81,6 +81,7 @@ add_library(Testing
   Support/GetSymbol.swift
   Support/Graph.swift
   Support/JSON.swift
+  Support/LiveUpdatingLine.swift
   Support/Locked.swift
   Support/Locked+Platform.swift
   Support/Versions.swift

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

@@ -98,10 +98,11 @@ extension Event {
     private let _context = Locked(rawValue: HierarchyContext())
 
     /// Initialize the hierarchical console output recorder.
-    public init(options: Options = Options(), writingUsing write: @escaping @Sendable (String) -> Void) {
-      self.options = options
-      self.write = write
-    }
+      public init(options: Options = Options(), writingUsing write: @escaping @Sendable (String) -> Void) {
+    self.options = options
+    self.write = write
+    Self.setupSignalHandlers()
+  }
   }
 }
 
@@ -124,6 +125,8 @@ extension Event.AdvancedConsoleOutputRecorder {
     }
 
     private static let _livePhaseState = Locked(rawValue: LivePhaseState())
+    @MainActor private static var _signalHandler: (any DispatchSourceSignal)?
+    @MainActor private static var _hasActiveRecorder: Bool = false
 
     private func updateLiveStats(event: Event, context: Event.Context) {
         Self._livePhaseState.withLock { state in
@@ -497,6 +500,7 @@ extension Event.AdvancedConsoleOutputRecorder {
     }
 
     renderCompleteHierarchy()
+    Self.cleanupSignalHandlers()
   }
 
   private func renderCompleteHierarchy() {
@@ -911,6 +915,54 @@ extension Event.AdvancedConsoleOutputRecorder {
       return false
     }
   }
+  
+  // MARK: - Signal Handling
+  
+  private static func setupSignalHandlers() {
+    Task { @MainActor in
+      // Only set up the signal handler once
+      guard Self._signalHandler == nil else { return }
+      
+      Self._hasActiveRecorder = true
+      
+      #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+      let signalType = SIGINFO
+      #else
+      let signalType = SIGUSR1
+      #endif
+      
+      signal(signalType, SIG_IGN) // Ignore default handler
+      
+      let signalSource = DispatchSource.makeSignalSource(signal: signalType, queue: .main)
+      signalSource.setEventHandler {
+        Self.printGlobalOnDemandStatus()
+      }
+      signalSource.resume()
+      Self._signalHandler = signalSource
+    }
+  }
+  
+  @MainActor private static func printGlobalOnDemandStatus() {
+    guard _hasActiveRecorder else {
+      try? FileHandle.stderr.write("\nNo active test recorder found.\n")
+      return
+    }
+    
+    let (total, completed, passed, failed, warnings, known, skipped) = _livePhaseState.withLock { state in
+      (max(state.totalTests, state.completedTests), state.completedTests, state.passed, 
+       state.failed, state.warnings, state.knownIssues, state.skipped)
+    }
+    
+    let statusMsg = "STATUS: [\(completed)/\(total)] | ✓ \(passed) | ✗ \(failed) | ? \(warnings) | ~ \(known) | → \(skipped)"
+    
+    try? FileHandle.stderr.write("\n\(statusMsg)\n")
+  }
+  
+  private static func cleanupSignalHandlers() {
+    Task { @MainActor in
+      Self._hasActiveRecorder = false
+    }
+  }
 }
 
 // MARK: - Extensions

Sources/Testing/Support/LiveUpdatingLine.swift

@@ -0,0 +1,31 @@
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for Swift project authors
+//
+
+/// Prints a string to the console by overwriting the current line without creating a new line.
+/// This is ideal for creating single-line, live-updating progress bars or status indicators.
+///
+/// - Parameter text: The text to display on the current line
+///
+/// ## Technical Details
+/// - Uses carriage return (`\r`) to move cursor to beginning of current line
+/// - Uses ANSI escape code (`\u{001B}[2K`) to clear the entire line
+/// - Does not append a newline character, allowing the line to be overwritten again
+///
+/// ## Example Usage
+/// ```swift
+/// printLiveUpdatingLine("Processing... 25%")
+/// // Later...
+/// printLiveUpdatingLine("Processing... 50%")
+/// // Later...
+/// printLiveUpdatingLine("Processing... 100%")
+/// ```
+public func printLiveUpdatingLine(_ text: String) {
+    print("\r\u{001B}[2K\(text)", terminator: "")
+} 

Tests/TestingTests/HierarchicalOutputDemo.swift

@@ -8,58 +8,39 @@
 // See https://swift.org/CONTRIBUTORS.txt for Swift project authors
 //
 
-@testable @_spi(ForToolsIntegrationOnly) import Testing
+import Testing
 import Foundation
 
-@Suite("HierarchicalOutputDemoSuite")
-struct HierarchicalOutputDemoSuite {
-  
-  @Test("passingTest")
-  func passingTest() {
-    #expect(1 + 1 == 2)
-  }
-  
-  @Test("anotherPassingTest")
-  func anotherPassingTest() {
-    #expect(true == true)
-  }
-  
-  @Test("failingTest")
-  func failingTest() {
-    #expect(1 + 1 == 3)
-  }
-  
-  static func shouldSkipTest() -> Bool {
-    // This will always return false (i.e., should skip), but is evaluated at runtime
-    return ProcessInfo.processInfo.environment["NEVER_SET_ENV_VAR"] != nil
-  }
-  
-  @Test("skippedTest", .enabled { shouldSkipTest() })
-  func skippedTest() {
-    #expect(1 + 1 == 2)
-  }
-  
-  @Test("anotherSkippedTest", .disabled { !shouldSkipTest() })
-  func anotherSkippedTest() {
-    #expect(true == true)
-  }
-}
+@Suite("Hierarchical Output Demo - Progress Bar Test")
+struct HierarchicalOutputDemo {
 
-@Suite("AnotherTestSuite")
-struct AnotherTestSuite {
-  
-  @Test("quickTest")
-  func quickTest() {
-    #expect(2 + 2 == 4)
-  }
-  
-  @Test("slightlySlowerTest")
-  func slightlySlowerTest() {
-    #expect(3 + 3 == 6)
-  }
-  
-  @Test("skipInAnotherSuite", .enabled { HierarchicalOutputDemoSuite.shouldSkipTest() })
-  func skipInAnotherSuite() {
-    #expect(1 + 1 == 2)
-  }
+    @Test("Slow Test 1")
+    func slowTest1() async throws {
+        try await Task.sleep(nanoseconds: 2_000_000_000) // 2 seconds
+        #expect(1 + 1 == 2)
+    }
+
+    @Test("Slow Test 2")  
+    func slowTest2() async throws {
+        try await Task.sleep(nanoseconds: 2_500_000_000) // 2.5 seconds
+        #expect(2 + 2 == 4)
+    }
+
+    @Test("Slow Test 3")
+    func slowTest3() async throws {
+        try await Task.sleep(nanoseconds: 1_800_000_000) // 1.8 seconds
+        #expect(3 + 3 == 6)
+    }
+
+    @Test("Slow Test 4")
+    func slowTest4() async throws {
+        try await Task.sleep(nanoseconds: 2_200_000_000) // 2.2 seconds
+        #expect(4 + 4 == 8)
+    }
+
+    @Test("Slow Test 5")
+    func slowTest5() async throws {
+        try await Task.sleep(nanoseconds: 1_500_000_000) // 1.5 seconds
+        #expect(5 + 5 == 10)
+    }
 } 

Tests/TestingTests/ProgressBarVisibilityDemo.swift

@@ -0,0 +1,48 @@
+import Testing
+import Foundation
+
+@Suite("Progress Bar Visibility Demo - Watch the progress bar update!", .serialized)
+struct ProgressBarVisibilityDemo {
+    
+    @Test("Slow Test 1 - 2 seconds")
+    func slowTest1() async throws {
+        try await Task.sleep(nanoseconds: 2_000_000_000) // 2 seconds
+        #expect(1 + 1 == 2)
+    }
+    
+    @Test("Slow Test 2 - 3 seconds") 
+    func slowTest2() async throws {
+        try await Task.sleep(nanoseconds: 3_000_000_000) // 3 seconds
+        #expect(2 + 2 == 4)
+    }
+    
+    @Test("Failing Slow Test - 2.5 seconds")
+    func failingSlowTest() async throws {
+        try await Task.sleep(nanoseconds: 2_500_000_000) // 2.5 seconds
+        #expect(1 + 1 == 3, "This test will fail after waiting 2.5 seconds")
+    }
+    
+    @Test("Slow Test 3 - 4 seconds")
+    func slowTest3() async throws {
+        try await Task.sleep(nanoseconds: 4_000_000_000) // 4 seconds
+        #expect(3 + 3 == 6)
+    }
+    
+    @Test("Another Failing Test - 1.5 seconds")
+    func anotherFailingTest() async throws {
+        try await Task.sleep(nanoseconds: 1_500_000_000) // 1.5 seconds
+        #expect(2 + 2 == 5, "Another failure after 1.5 seconds")
+    }
+    
+    @Test("Slow Test 4 - 3.5 seconds")
+    func slowTest4() async throws {
+        try await Task.sleep(nanoseconds: 3_500_000_000) // 3.5 seconds
+        #expect(4 + 4 == 8)
+    }
+    
+    @Test("Final Slow Test - 2 seconds")
+    func finalSlowTest() async throws {
+        try await Task.sleep(nanoseconds: 2_000_000_000) // 2 seconds
+        #expect(5 + 5 == 10)
+    }
+} 

Tests/TestingTests/QuickProgressBarDemo.swift

@@ -0,0 +1,36 @@
+import Testing
+import Foundation
+
+@Suite("Quick Progress Bar Demo - 10 seconds total", .serialized)
+struct QuickProgressBarDemo {
+    
+    @Test("Test 1 - 1.5s")
+    func test1() async throws {
+        try await Task.sleep(nanoseconds: 1_500_000_000) // 1.5 seconds
+        #expect(1 + 1 == 2)
+    }
+    
+    @Test("Test 2 - 2s") 
+    func test2() async throws {
+        try await Task.sleep(nanoseconds: 2_000_000_000) // 2 seconds
+        #expect(2 + 2 == 4)
+    }
+    
+    @Test("FAILING Test - 1s")
+    func failingTest() async throws {
+        try await Task.sleep(nanoseconds: 1_000_000_000) // 1 second
+        #expect(1 + 1 == 3, "This will fail!")
+    }
+    
+    @Test("Test 3 - 2.5s")
+    func test3() async throws {
+        try await Task.sleep(nanoseconds: 2_500_000_000) // 2.5 seconds
+        #expect(3 + 3 == 6)
+    }
+    
+    @Test("Test 4 - 3s")
+    func test4() async throws {
+        try await Task.sleep(nanoseconds: 3_000_000_000) // 3 seconds
+        #expect(4 + 4 == 8)
+    }
+}