11import Foundation
2- import Synchronization
32
43#if DEBUG
54
65 /// A mock logger implementation for testing purposes.
76 ///
87 /// `MockLogBackend` captures all log calls in memory and provides various inspection methods
9- /// to verify logging behavior in unit tests. It's thread-safe using `Synchronization.Mutex`
8+ /// to verify logging behavior in unit tests. It's thread-safe using NSLock
109 /// and only available in DEBUG builds.
1110 ///
1211 /// ## Features
13- /// - Thread-safe log capture using Swift 6 Synchronization framework
12+ /// - Thread-safe log capture using NSLock for cross-platform compatibility
1413 /// - Comprehensive inspection methods for testing assertions
1514 /// - Async waiting capabilities for testing concurrent logging
1615 /// - Pattern matching and sequence verification
17- /// - Available on all platforms that support Swift 6
16+ /// - Available on all platforms (iOS 13+, macOS 10.15+, Linux)
1817 ///
1918 /// ## Usage
2019 /// ```swift
2120 /// let mockLogger = MockLogBackend()
2221 /// mockLogger.info("Test message")
2322 ///
2423 /// // Verify logging behavior
25- /// XCTAssertTrue (mockLogger.hasInfoLogs)
26- /// XCTAssertEqual (mockLogger.logCount(for: .info), 1)
27- /// XCTAssertTrue (mockLogger.hasLog(level: .info, containing: "Test"))
24+ /// #expect (mockLogger.hasInfoLogs == true )
25+ /// #expect (mockLogger.logCount(for: .info) == 1)
26+ /// #expect (mockLogger.hasLog(level: .info, containing: "Test") == true )
2827 /// ```
29- @available ( macOS 15 . 0 , iOS 18 . 0 , watchOS 11 . 0 , tvOS 18 . 0 , visionOS 2 . 0 , * )
30- public final class MockLogBackend : LoggerManagerProtocol {
28+ public final class MockLogBackend : LoggerManagerProtocol , @unchecked Sendable {
3129 /// Thread-safe storage for captured log calls
32- private let _logCalls : Mutex < [ ( level: LogLevel , message: String ) ] > = . init( [ ] )
30+ private var _logCalls : [ ( level: LogLevel , message: String ) ] = [ ]
31+ private let lock = NSLock ( )
3332
3433 /// Returns all captured log calls as an array of (level, message) tuples.
3534 /// This property is thread-safe and returns a snapshot of all logs at the time of access.
3635 public var logCalls : [ ( level: LogLevel , message: String ) ] {
37- _logCalls. withLock { $0 }
36+ lock. lock ( )
37+ defer { lock. unlock ( ) }
38+ return _logCalls
3839 }
3940
4041 /// Initializes a new MockLogBackend instance.
@@ -50,15 +51,19 @@ import Synchronization
5051 /// - function: The function name (metadata, not stored)
5152 /// - line: The line number (metadata, not stored)
5253 public func log( _ message: String , level: LogLevel , file: String , function: String , line: Int ) {
53- _logCalls. withLock { $0. append ( ( level: level, message: message) ) }
54+ lock. lock ( )
55+ defer { lock. unlock ( ) }
56+ _logCalls. append ( ( level: level, message: message) )
5457 }
5558
5659 // MARK: - Test Helper Methods
5760
5861 /// Clears all captured log entries.
5962 /// This method is thread-safe and removes all previously captured logs.
6063 public func clearLogs( ) {
61- _logCalls. withLock { $0. removeAll ( ) }
64+ lock. lock ( )
65+ defer { lock. unlock ( ) }
66+ _logCalls. removeAll ( )
6267 }
6368
6469 /// Checks if there's a log entry with the specified level containing the given substring.
@@ -68,54 +73,69 @@ import Synchronization
6873 /// - substring: The substring to search for in log messages
6974 /// - Returns: `true` if a matching log entry is found, `false` otherwise
7075 public func hasLog( level: LogLevel , containing substring: String ) -> Bool {
71- _logCalls. withLock { $0. contains { $0. level == level && $0. message. contains ( substring) } }
76+ lock. lock ( )
77+ defer { lock. unlock ( ) }
78+ return _logCalls. contains { $0. level == level && $0. message. contains ( substring) }
7279 }
7380
7481 /// Returns all log messages for a specific log level.
7582 ///
7683 /// - Parameter level: The log level to filter by
7784 /// - Returns: An array of log messages matching the specified level
7885 public func getLogMessages( for level: LogLevel ) -> [ String ] {
79- _logCalls. withLock { $0. filter { $0. level == level } . map ( \. message) }
86+ lock. lock ( )
87+ defer { lock. unlock ( ) }
88+ return _logCalls. filter { $0. level == level } . map ( \. message)
8089 }
8190
8291 /// Returns the most recently captured log entry.
8392 ///
8493 /// - Returns: A tuple containing the level and message of the last log, or `nil` if no logs exist
8594 public func getLastLog( ) -> ( level: LogLevel , message: String ) ? {
86- _logCalls. withLock { $0. last }
95+ lock. lock ( )
96+ defer { lock. unlock ( ) }
97+ return _logCalls. last
8798 }
8899 }
89100
90101 // MARK: - Convenience Extensions
91102
92- @available ( macOS 15 . 0 , iOS 18 . 0 , watchOS 11 . 0 , tvOS 18 . 0 , visionOS 2 . 0 , * )
93103 extension MockLogBackend {
94104 // MARK: - Quick Log Level Checks
95105
96106 /// Returns `true` if any error-level logs have been captured.
97107 public var hasErrorLogs : Bool {
98- _logCalls. withLock { $0. contains { $0. level == . error } }
108+ lock. lock ( )
109+ defer { lock. unlock ( ) }
110+ return _logCalls. contains { $0. level == . error }
99111 }
100112
101113 /// Returns `true` if any warning-level logs have been captured.
102114 public var hasWarningLogs : Bool {
103- _logCalls. withLock { $0. contains { $0. level == . warning } }
115+ lock. lock ( )
116+ defer { lock. unlock ( ) }
117+ return _logCalls. contains { $0. level == . warning }
104118 }
105119
106120 /// Returns `true` if any info-level logs have been captured.
107121 public var hasInfoLogs : Bool {
108- _logCalls. withLock { $0. contains { $0. level == . info } }
122+ lock. lock ( )
123+ defer { lock. unlock ( ) }
124+ return _logCalls. contains { $0. level == . info }
109125 }
110126
111127 /// Returns `true` if any debug-level logs have been captured.
112128 public var hasDebugLogs : Bool {
113- _logCalls. withLock { $0. contains { $0. level == . debug } }
129+ lock. lock ( )
130+ defer { lock. unlock ( ) }
131+ return _logCalls. contains { $0. level == . debug }
114132 }
115133
116134 /// Returns all captured log messages as an array of strings, regardless of level.
117135 public var allLogMessages : [ String ] {
118- _logCalls. withLock { $0. map ( \. message) }
136+ lock. lock ( )
137+ defer { lock. unlock ( ) }
138+ return _logCalls. map ( \. message)
119139 }
120140
121141 // MARK: - Advanced Testing Methods
@@ -125,15 +145,19 @@ import Synchronization
125145 /// - Parameter level: The log level to count
126146 /// - Returns: The number of logs at the specified level
127147 public func logCount( for level: LogLevel ) -> Int {
128- _logCalls. withLock { $0. count ( where: { $0. level == level } ) }
148+ lock. lock ( )
149+ defer { lock. unlock ( ) }
150+ return _logCalls. count ( where: { $0. level == level } )
129151 }
130152
131153 /// Verifies that the captured log sequence exactly matches the expected levels.
132154 ///
133155 /// - Parameter expectedLevels: The expected sequence of log levels
134156 /// - Returns: `true` if the actual log sequence matches the expected sequence exactly
135157 public func verifyLogSequence( _ expectedLevels: [ LogLevel ] ) -> Bool {
136- let actualLevels = _logCalls. withLock { $0. map ( \. level) }
158+ lock. lock ( )
159+ defer { lock. unlock ( ) }
160+ let actualLevels = _logCalls. map ( \. level)
137161 return actualLevels == expectedLevels
138162 }
139163
@@ -163,18 +187,21 @@ import Synchronization
163187
164188 /// Returns the total number of captured logs across all levels.
165189 public var totalLogCount : Int {
166- _logCalls. withLock { $0. count }
190+ lock. lock ( )
191+ defer { lock. unlock ( ) }
192+ return _logCalls. count
167193 }
168194
169195 /// Verifies that the last N captured logs match the expected level sequence.
170196 ///
171197 /// - Parameter expectedLevels: The expected sequence of the most recent log levels
172198 /// - Returns: `true` if the last N logs match the expected sequence, `false` otherwise
173199 public func verifyLastLogs( _ expectedLevels: [ LogLevel ] ) -> Bool {
174- let logs = _logCalls. withLock { $0 }
175- guard logs. count >= expectedLevels. count else { return false }
200+ lock. lock ( )
201+ defer { lock. unlock ( ) }
202+ guard _logCalls. count >= expectedLevels. count else { return false }
176203
177- let lastLogs = Array ( logs . suffix ( expectedLevels. count) )
204+ let lastLogs = Array ( _logCalls . suffix ( expectedLevels. count) )
178205 return lastLogs. map ( \. level) == expectedLevels
179206 }
180207
@@ -196,7 +223,9 @@ import Synchronization
196223 /// let hasErrorCode = mockLogger.hasLogMatching(level: .error) { $0.contains("ERR_404") }
197224 /// ```
198225 public func hasLogMatching( level: LogLevel , pattern: ( String ) -> Bool ) -> Bool {
199- _logCalls. withLock { $0. contains { $0. level == level && pattern ( $0. message) } }
226+ lock. lock ( )
227+ defer { lock. unlock ( ) }
228+ return _logCalls. contains { $0. level == level && pattern ( $0. message) }
200229 }
201230 }
202231
0 commit comments