[assert] adjust assert message

honghaoz · Oct 10, 2024 · f34b999 · f34b999
1 parent 492b9a6
commit f34b999
Show file tree

Hide file tree

Showing 5 changed files with 183 additions and 32 deletions.
diff --git a/packages/ChouTi/Sources/ChouTi/Concurrency/AssertOnMainThread.swift b/packages/ChouTi/Sources/ChouTi/Concurrency/AssertOnMainThread.swift
@@ -30,28 +30,56 @@
 
 import Foundation
 
+/// Assert current thread is main thread.
+/// - Parameters:
+///   - message: The message to show when assertion fails.
 @inlinable
 @inline(__always)
-public func assertOnMainThread(_ message: @autoclosure () -> String = String(),
+public func assertOnMainThread(_ message: @autoclosure () -> String? = nil,
                                file: StaticString = #fileID,
                                line: UInt = #line,
                                column: UInt = #column,
                                function: StaticString = #function)
 {
   #if DEBUG
-  ChouTi.assert(Thread.isMainThread, "Should be on main thread. Current thread: \(Thread.current). Current queue label: \"\(DispatchQueue.currentQueueLabel)\". Message: \"\(message())\".", file: file, line: line, column: column, function: function)
+  ChouTi.assert(
+    Thread.isMainThread,
+    "Should be on main thread. Message: \"\(message() ?? "")\"",
+    metadata: [
+      "thread": "\(Thread.current)",
+      "queue": "\(DispatchQueue.currentQueueLabel)",
+    ],
+    file: file,
+    line: line,
+    column: column,
+    function: function
+  )
   #endif
 }
 
+/// Assert current thread is **NOT** main thread.
+/// - Parameters:
+///   - message: The message to show when assertion fails.
 @inlinable
 @inline(__always)
-public func assertNotOnMainThread(_ message: @autoclosure () -> String = String(),
+public func assertNotOnMainThread(_ message: @autoclosure () -> String? = nil,
                                   file: StaticString = #fileID,
                                   line: UInt = #line,
                                   column: UInt = #column,
                                   function: StaticString = #function)
 {
   #if DEBUG
-  ChouTi.assert(!Thread.isMainThread, "Should NOT be on main thread. Current thread: \(Thread.current). Current queue label: \"\(DispatchQueue.currentQueueLabel)\". Message: \"\(message())\".", file: file, line: line, column: column, function: function)
+  ChouTi.assert(
+    !Thread.isMainThread,
+    "Should NOT be on main thread. Message: \"\(message() ?? "")\"",
+    metadata: [
+      "thread": "\(Thread.current)",
+      "queue": "\(DispatchQueue.currentQueueLabel)",
+    ],
+    file: file,
+    line: line,
+    column: column,
+    function: function
+  )
   #endif
 }
diff --git a/packages/ChouTi/Sources/ChouTi/Concurrency/GCD/AssertOnQueue.swift b/packages/ChouTi/Sources/ChouTi/Concurrency/GCD/AssertOnQueue.swift
@@ -37,15 +37,26 @@ import Foundation
 @inlinable
 @inline(__always)
 public func assertOnQueue(_ queue: DispatchQueue,
-                          _ message: @autoclosure () -> String = String(),
+                          _ message: @autoclosure () -> String? = nil,
                           file: StaticString = #fileID,
                           line: UInt = #line,
                           column: UInt = #column,
                           function: StaticString = #function)
 {
   #if DEBUG
-  ChouTi.assert(DispatchQueue.isOnQueue(queue, file: file, line: line, column: column), "Should be on queue: \(queue.label). Current queue label: \"\(DispatchQueue.currentQueueLabel)\". Message: \(message())", file: file, line: line, column: column, function: function)
-  dispatchPrecondition(condition: .onQueue(queue))
+  ChouTi.assert(
+    DispatchQueue.isOnQueue(queue, file: file, line: line, column: column),
+    "Should be on queue: \(queue.label). Message: \"\(message() ?? "")\"",
+    metadata: [
+      "queue": "\(DispatchQueue.currentQueueLabel)",
+      "thread": "\(Thread.current)",
+    ],
+    file: file,
+    line: line,
+    column: column,
+    function: function
+  )
+  // dispatchPrecondition(condition: .onQueue(queue))
   #endif
 }
 
@@ -56,14 +67,25 @@ public func assertOnQueue(_ queue: DispatchQueue,
 @inlinable
 @inline(__always)
 public func assertNotOnQueue(_ queue: DispatchQueue,
-                             _ message: @autoclosure () -> String = String(),
+                             _ message: @autoclosure () -> String? = nil,
                              file: StaticString = #fileID,
                              line: UInt = #line,
                              column: UInt = #column,
                              function: StaticString = #function)
 {
   #if DEBUG
-  ChouTi.assert(!DispatchQueue.isOnQueue(queue, file: file, line: line, column: column), "Should be NOT on queue: \(queue.label). Current queue label: \"\(DispatchQueue.currentQueueLabel)\". Message: \(message())", file: file, line: line, column: column, function: function)
+  ChouTi.assert(
+    !DispatchQueue.isOnQueue(queue, file: file, line: line, column: column),
+    "Should NOT be on queue: \(queue.label). Message: \"\(message() ?? "")\"",
+    metadata: [
+      "queue": "\(DispatchQueue.currentQueueLabel)",
+      "thread": "\(Thread.current)",
+    ],
+    file: file,
+    line: line,
+    column: column,
+    function: function
+  )
   // not sure why the below doesn't work.
   // dispatchPrecondition(condition: .notOnQueue(queue))
   #endif
@@ -74,14 +96,25 @@ public func assertNotOnQueue(_ queue: DispatchQueue,
 ///   - message: The message to show when assertion fails.
 @inlinable
 @inline(__always)
-public func assertOnCooperativeQueue(_ message: @autoclosure () -> String = String(),
+public func assertOnCooperativeQueue(_ message: @autoclosure () -> String? = nil,
                                      file: StaticString = #fileID,
                                      line: UInt = #line,
                                      column: UInt = #column,
                                      function: StaticString = #function)
 {
   #if DEBUG
-  ChouTi.assert(DispatchQueue.isOnCooperativeQueue(), "Should be on cooperative queue. Current thread: \(Thread.current). Current queue label: \"\(DispatchQueue.currentQueueLabel)\". Message: \"\(message())\".", file: file, line: line, column: column, function: function)
+  ChouTi.assert(
+    DispatchQueue.isOnCooperativeQueue(),
+    "Should be on cooperative queue. Message: \"\(message() ?? "")\"",
+    metadata: [
+      "queue": "\(DispatchQueue.currentQueueLabel)",
+      "thread": "\(Thread.current)",
+    ],
+    file: file,
+    line: line,
+    column: column,
+    function: function
+  )
   #endif
 }
 
@@ -90,13 +123,24 @@ public func assertOnCooperativeQueue(_ message: @autoclosure () -> String = Stri
 ///   - message: The message to show when assertion fails.
 @inlinable
 @inline(__always)
-public func assertNotOnCooperativeQueue(_ message: @autoclosure () -> String = String(),
+public func assertNotOnCooperativeQueue(_ message: @autoclosure () -> String? = nil,
                                         file: StaticString = #fileID,
                                         line: UInt = #line,
                                         column: UInt = #column,
                                         function: StaticString = #function)
 {
   #if DEBUG
-  ChouTi.assert(!DispatchQueue.isOnCooperativeQueue(), "Should NOT be on cooperative queue. Current thread: \(Thread.current). Current queue label: \"\(DispatchQueue.currentQueueLabel)\". Message: \"\(message())\".", file: file, line: line, column: column, function: function)
+  ChouTi.assert(
+    !DispatchQueue.isOnCooperativeQueue(),
+    "Should NOT be on cooperative queue. Message: \"\(message() ?? "")\"",
+    metadata: [
+      "queue": "\(DispatchQueue.currentQueueLabel)",
+      "thread": "\(Thread.current)",
+    ],
+    file: file,
+    line: line,
+    column: column,
+    function: function
+  )
   #endif
 }
diff --git a/packages/ChouTi/Tests/ChouTiTests/Box/OptionalBoxTests.swift b/packages/ChouTi/Tests/ChouTiTests/Box/OptionalBoxTests.swift
@@ -174,7 +174,7 @@ class OptionalBoxTests: XCTestCase {
 //                box2 = OptionalBox<Int>.none
 //              }
 //
-//              it("should be not equal") {
+//              it("should not be equal") {
 //                expect(box) != box2
 //              }
 //            }
@@ -184,7 +184,7 @@ class OptionalBoxTests: XCTestCase {
 //                box2 = OptionalBox<Int>.some(200)
 //              }
 //
-//              it("should be not equal") {
+//              it("should not be equal") {
 //                expect(box) != box2
 //              }
 //            }
@@ -220,7 +220,7 @@ class OptionalBoxTests: XCTestCase {
 //                box2 = .notSet
 //              }
 //
-//              it("should be not equal") {
+//              it("should not be equal") {
 //                expect(box) != box2
 //              }
 //            }
@@ -240,7 +240,7 @@ class OptionalBoxTests: XCTestCase {
 //                box2 = OptionalBox<Int>.some(200)
 //              }
 //
-//              it("should be not equal") {
+//              it("should not be equal") {
 //                expect(box) != box2
 //              }
 //            }
@@ -286,7 +286,7 @@ class OptionalBoxTests: XCTestCase {
 //                box2 = .notSet
 //              }
 //
-//              it("should be not equal") {
+//              it("should not be equal") {
 //                expect(box) != box2
 //              }
 //            }
@@ -296,7 +296,7 @@ class OptionalBoxTests: XCTestCase {
 //                box2 = OptionalBox<Int>.none
 //              }
 //
-//              it("should be not equal") {
+//              it("should not be equal") {
 //                expect(box) != box2
 //              }
 //            }
@@ -317,7 +317,7 @@ class OptionalBoxTests: XCTestCase {
 //                  box2 = OptionalBox<Int>.some(102)
 //                }
 //
-//                it("should be not equal") {
+//                it("should not be equal") {
 //                  expect(box) != box2
 //                }
 //              }

diff --git a/packages/ChouTi/Tests/ChouTiTests/Concurrency/AssertOnMainThreadTests.swift b/packages/ChouTi/Tests/ChouTiTests/Concurrency/AssertOnMainThreadTests.swift
@@ -51,11 +51,21 @@ class AssertOnMainThreadTests: XCTestCase {
 
     queue.async {
       Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
-        expect(message.contains("Should be on main thread. Current thread: <NSThread:")) == true
+        expect(message) == "Should be on main thread. Message: \"\""
+        expect(metadata["thread"]) == "\(Thread.current)"
+        expect(metadata["queue"]) == "test-queue"
       }
       assertOnMainThread()
       Assert.resetTestAssertionFailureHandler()
 
+      Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
+        expect(message) == "Should be on main thread. Message: \"Test message\""
+        expect(metadata["thread"]) == "\(Thread.current)"
+        expect(metadata["queue"]) == "test-queue"
+      }
+      assertOnMainThread("Test message")
+      Assert.resetTestAssertionFailureHandler()
+
       expectation.fulfill()
     }
 
@@ -64,11 +74,21 @@ class AssertOnMainThreadTests: XCTestCase {
 
   func test_assertNotOnMainThread() {
     Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
-      expect(message.contains("Should NOT be on main thread. Current thread: <"), message) == true
+      expect(message) == "Should NOT be on main thread. Message: \"\""
+      expect(metadata["thread"]) == "\(Thread.current)"
+      expect(metadata["queue"]) == "com.apple.main-thread"
     }
     assertNotOnMainThread()
     Assert.resetTestAssertionFailureHandler()
 
+    Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
+      expect(message) == "Should NOT be on main thread. Message: \"Test message\""
+      expect(metadata["thread"]) == "\(Thread.current)"
+      expect(metadata["queue"]) == "com.apple.main-thread"
+    }
+    assertNotOnMainThread("Test message")
+    Assert.resetTestAssertionFailureHandler()
+
     let expectation = expectation(description: "on background thread")
 
     queue.async {

diff --git a/packages/ChouTi/Tests/ChouTiTests/Concurrency/GCD/AssertOnQueueTests.swift b/packages/ChouTi/Tests/ChouTiTests/Concurrency/GCD/AssertOnQueueTests.swift
@@ -35,45 +35,104 @@ import ChouTi
 class AssertOnQueueTests: XCTestCase {
 
   func test_assertOnQueue() {
-    let queue = DispatchQueue.make(label: "test")
+    let queue = DispatchQueue.make(label: "queue")
+    let queue2 = DispatchQueue.make(label: "queue2")
     queue.sync {
       assertOnQueue(queue)
       assertOnQueue(queue, "should be on queue")
+
+      // no message
+      Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
+        expect(message) == "Should be on queue: queue2. Message: \"\""
+        expect(metadata["queue"]) == "queue"
+        expect(metadata["thread"]) == "\(Thread.current)"
+      }
+      assertOnQueue(queue2)
+      Assert.resetTestAssertionFailureHandler()
+
+      // with message
+      Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
+        expect(message) == "Should be on queue: queue2. Message: \"Test message\""
+        expect(metadata["queue"]) == "queue"
+        expect(metadata["thread"]) == "\(Thread.current)"
+      }
+      assertOnQueue(queue2, "Test message")
+      Assert.resetTestAssertionFailureHandler()
     }
   }
 
   func test_assertNotOnQueue() {
-    let queue = DispatchQueue.make(label: "test")
+    let queue = DispatchQueue.make(label: "queue")
+    let queue2 = DispatchQueue.make(label: "queue2")
     queue.sync {
-      assertNotOnQueue(.main)
-    }
+      assertNotOnQueue(queue2)
+      assertNotOnQueue(queue2, "should not be on queue")
 
-    Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
-      expect(message) == #"Should be NOT on queue: com.apple.main-thread. Current queue label: "com.apple.main-thread". Message: Hey"#
+      // no message
+      Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
+        expect(message) == "Should NOT be on queue: queue. Message: \"\""
+        expect(metadata["queue"]) == "queue"
+        expect(metadata["thread"]) == "\(Thread.current)"
+      }
+      assertNotOnQueue(queue)
+      Assert.resetTestAssertionFailureHandler()
+
+      // with message
+      Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
+        expect(message) == "Should NOT be on queue: queue. Message: \"Test message\""
+        expect(metadata["queue"]) == "queue"
+        expect(metadata["thread"]) == "\(Thread.current)"
+      }
+      assertNotOnQueue(queue, "Test message")
+      Assert.resetTestAssertionFailureHandler()
     }
-    assertNotOnQueue(.main, "Hey")
-    Assert.resetTestAssertionFailureHandler()
   }
 
   func test_assertOnCooperativeQueue() {
     Task {
       assertOnCooperativeQueue()
     }
+
+    // no message
     Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
-      expect(message.contains("Should be on cooperative queue. Current thread:")) == true
+      expect(message) == "Should be on cooperative queue. Message: \"\""
+      expect(metadata["queue"]) == "com.apple.main-thread"
+      expect(metadata["thread"]) == "\(Thread.current)"
     }
     assertOnCooperativeQueue()
     Assert.resetTestAssertionFailureHandler()
+
+    // with message
+    Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
+      expect(message) == "Should be on cooperative queue. Message: \"Test message\""
+      expect(metadata["queue"]) == "com.apple.main-thread"
+      expect(metadata["thread"]) == "\(Thread.current)"
+    }
+    assertOnCooperativeQueue("Test message")
+    Assert.resetTestAssertionFailureHandler()
   }
 
   func test_assertNotOnCooperativeQueue() {
     let expectation = expectation(description: "")
     Task {
+      // no message
       Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
-        expect(message.contains("Should NOT be on cooperative queue. Current thread: ")) == true
+        expect(message) == "Should NOT be on cooperative queue. Message: \"\""
+        expect(metadata["queue"]) == "\(DispatchQueue.currentQueueLabel)"
+        expect(metadata["thread"]) == "\(Thread.current)"
       }
       assertNotOnCooperativeQueue()
       Assert.resetTestAssertionFailureHandler()
+
+      // with message
+      Assert.setTestAssertionFailureHandler { message, metadata, file, line, column in
+        expect(message) == "Should NOT be on cooperative queue. Message: \"Test message\""
+        expect(metadata["queue"]) == "\(DispatchQueue.currentQueueLabel)"
+        expect(metadata["thread"]) == "\(Thread.current)"
+      }
+      assertNotOnCooperativeQueue("Test message")
+      Assert.resetTestAssertionFailureHandler()
+
       expectation.fulfill()
     }