Migrate to swift testing

Except in engine tests.

Author: pdil

CHANGELOG.md

@@ -2,8 +2,11 @@
 
 ### Improvements
 * Commands and responses are now logged using their own synchronous queue to prevent unreadable output when commands and responses were sent simultaneously.
-* `setLoggingEnabled(loggingEnabled:)` has been renamed `set(loggingEnabled:)`
+* `setLoggingEnabled(loggingEnabled:)` has been renamed `set(loggingEnabled:) async`
   * The original function remains but is deprecated.
+* Change default `coreCount` in `Engine.start()` to **one less** than the core count (minimum of 1).
+  * This allows a free core for other processing tasks in a multicore environment.
+  * Can still be changed with the `coreCount` parameter if desired.
 
 # ChessKitEngine 0.6.0
 Released Friday, May 30, 2025.

Sources/ChessKitEngine/Engine.swift

@@ -89,15 +89,12 @@ public final class Engine: Sendable {
   /// before you can ask the engine to perform any work.
   ///
   /// - parameter coreCount: The number of processor cores to use for engine
-  /// calculation. The default value is `nil` which uses the number of
-  /// cores available on the device.
+  /// calculation. The default value is `nil` which uses one less than
+  /// the number of cores available on the device.
   /// - parameter multipv: The number of lines the engine should return,
   /// sent via the `"MultiPV"` UCI option.
   ///
-  public func start(
-    coreCount: Int? = nil,
-    multipv: Int = 1
-  ) async {
+  public func start(coreCount: Int? = nil, multipv: Int = 1) async {
     // Setup async stream response if not already set.
     await engineConfigurationActor.setAsyncStream()
 
@@ -155,18 +152,18 @@ public final class Engine: Sendable {
   ///
   @available(*, deprecated, renamed: "set(loggingEnabled:)")
   public func setLoggingEnabled(_ loggingEnabled: Bool) {
-    set(loggingEnabled: loggingEnabled)
+    Task {
+      await set(loggingEnabled: loggingEnabled)
+    }
   }
 
   /// Enable printing logs to console.
   ///
   /// - parameter loggingEnabled: If set to `true`, engine commands and responses
   ///   will be logged to the console. The default value is `false`.
   ///
-  public func set(loggingEnabled: Bool) {
-    Task {
-      await engineConfigurationActor.set(loggingEnabled: loggingEnabled)
-    }
+  public func set(loggingEnabled: Bool) async {
+    await engineConfigurationActor.set(loggingEnabled: loggingEnabled)
   }
 
   // MARK: Private functions
@@ -201,12 +198,10 @@ public final class Engine: Sendable {
         if await !self.isRunning {
           if parsed == .readyok {
             await self.performInitialSetup(
-              coreCount: coreCount ?? ProcessInfo.processInfo.processorCount,
+              coreCount: coreCount ?? min(1, ProcessInfo.processInfo.processorCount - 1),
               multipv: multipv
             )
-          } else if let next = EngineCommand.nextSetupLoopCommand(
-            given: parsed
-          ) {
+          } else if let next = EngineCommand.nextSetupLoopCommand(given: parsed) {
             await self.send(command: next)
           }
         }
@@ -263,7 +258,9 @@ fileprivate actor EngineConfiguration: Sendable {
   init(loggingEnabled: Bool = false) {
     self.loggingEnabled = loggingEnabled
 
-    Task { await setAsyncStream() }
+    Task {
+      await setAsyncStream()
+    }
   }
 
   func set(loggingEnabled: Bool) async {

Sources/ChessKitEngine/EngineResponse/EngineResponseParser.swift

@@ -3,9 +3,7 @@
 //  ChessKitEngine
 //
 
-class EngineResponseParser {
-
-  private init() {}
+enum EngineResponseParser {
 
   static func parse(response: String) -> EngineResponse? {
     let tokens = response.split { $0.isWhitespace || $0.isNewline }.map(String.init)

Tests/ChessKitEngineTests/EngineCommandPositionTests.swift

@@ -3,53 +3,47 @@
 //  ChessKitEngineTests
 //
 
-import XCTest
 @testable import ChessKitEngine
+import Testing
 
-class EngineCommandPositionTests: XCTestCase {
+struct EngineCommandPositionTests {
 
-  func testPositionStringRawValue() {
+  @Test func positionStringRawValue() {
     let p = EngineCommand.PositionString.startpos
-    XCTAssertEqual(p.rawValue, "startpos")
+    #expect(p.rawValue == "startpos")
 
     let fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
     let f = EngineCommand.PositionString.fen(fen)
-    XCTAssertEqual(f.rawValue, "fen \(fen)")
+    #expect(f.rawValue == "fen \(fen)")
   }
 
-  func testPositionStringRawValueInit() {
-    XCTAssertEqual(
-      EngineCommand.PositionString(rawValue: "startpos"),
-      .startpos
-    )
+  @Test func positionStringRawValueInit() {
+    #expect(EngineCommand.PositionString(rawValue: "startpos") == .startpos)
 
     let fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
-    XCTAssertEqual(
-      EngineCommand.PositionString(rawValue: "fen \(fen)"),
-      .fen(fen)
-    )
+    #expect(EngineCommand.PositionString(rawValue: "fen \(fen)") == .fen(fen))
   }
 
-  func testInvalidFENPositionStrings() {
+  @Test func invalidFENPositionStrings() {
     let fen1 = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
-    XCTAssertNil(EngineCommand.PositionString(rawValue: "fen \(fen1)"))
+    #expect(EngineCommand.PositionString(rawValue: "fen \(fen1)") == nil)
 
     let fen2 = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w"
-    XCTAssertNil(EngineCommand.PositionString(rawValue: "fen \(fen2)"))
+    #expect(EngineCommand.PositionString(rawValue: "fen \(fen2)") == nil)
 
     let fen3 = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq"
-    XCTAssertNil(EngineCommand.PositionString(rawValue: "fen \(fen3)"))
+    #expect(EngineCommand.PositionString(rawValue: "fen \(fen3)") == nil)
 
     let fen4 = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq -"
-    XCTAssertNil(EngineCommand.PositionString(rawValue: "fen \(fen4)"))
+    #expect(EngineCommand.PositionString(rawValue: "fen \(fen4)") == nil)
 
     let fen5 = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0"
-    XCTAssertNil(EngineCommand.PositionString(rawValue: "fen \(fen5)"))
+    #expect(EngineCommand.PositionString(rawValue: "fen \(fen5)") == nil)
   }
 
-  func testInvalidPositionString() {
-    XCTAssertNil(EngineCommand.PositionString(rawValue: "invalid"))
-    XCTAssertNil(EngineCommand.PositionString(rawValue: ""))
+  @Test func invalidPositionString() {
+    #expect(EngineCommand.PositionString(rawValue: "invalid") == nil)
+    #expect(EngineCommand.PositionString(rawValue: "") == nil)
   }
 
 }

Tests/ChessKitEngineTests/EngineCommandTests.swift

@@ -3,71 +3,62 @@
 //  ChessKitEngineTests
 //
 
-import XCTest
 @testable import ChessKitEngine
+import Testing
 
-class EngineCommandTests: XCTestCase {
+struct EngineCommandTests {
 
-  func testDebugCommand() {
+  @Test func debugCommand() {
     let debugOn = EngineCommand.debug(on: true)
-    XCTAssertEqual(debugOn.rawValue, "debug on")
+    #expect(debugOn.rawValue == "debug on")
 
     let debugOff = EngineCommand.debug(on: false)
-    XCTAssertEqual(debugOff.rawValue, "debug off")
+    #expect(debugOff.rawValue == "debug off")
   }
 
-  func testUciCommand() {
-    XCTAssertEqual(EngineCommand.uci.rawValue, "uci")
+  @Test func uciCommand() {
+    #expect(EngineCommand.uci.rawValue == "uci")
   }
 
-  func testIsReadyCommand() {
-    XCTAssertEqual(EngineCommand.isready.rawValue, "isready")
+  @Test func isReadyCommand() {
+    #expect(EngineCommand.isready.rawValue == "isready")
   }
 
-  func testSetOptionCommand() {
+  @Test func setOptionCommand() {
     let setOption1 = EngineCommand.setoption(id: "name", value: "val")
-    XCTAssertEqual(
-      setOption1.rawValue,
-      "setoption name name value val"
-    )
+    #expect(setOption1.rawValue == "setoption name name value val")
 
     let setOption2 = EngineCommand.setoption(id: "name")
-    XCTAssertEqual(
-      setOption2.rawValue,
-      "setoption name name"
-    )
+    #expect(setOption2.rawValue == "setoption name name")
   }
 
-  func testUciNewGameCommand() {
-    XCTAssertEqual(EngineCommand.ucinewgame.rawValue, "ucinewgame")
+  @Test func uciNewGameCommand() {
+    #expect(EngineCommand.ucinewgame.rawValue == "ucinewgame")
   }
 
-  func testPositionCommand() {
-    XCTAssertEqual(
+  @Test func positionCommand() {
+    #expect(
       EngineCommand.position(
         .startpos,
         moves: ["e2e4", "c7c6"]
-      ).rawValue,
-      "position startpos moves e2e4 c7c6"
+      ).rawValue == "position startpos moves e2e4 c7c6"
     )
 
-    XCTAssertEqual(
+    #expect(
       EngineCommand.position(
         .fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")
-      ).rawValue,
-      "position fen rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+      ).rawValue == "position fen rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
     )
 
-    XCTAssertEqual(
+    #expect(
       EngineCommand.position(
         .fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"),
         moves: ["e2e4", "c7c6"]
-      ).rawValue,
-      "position fen rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 moves e2e4 c7c6"
+      ).rawValue == "position fen rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 moves e2e4 c7c6"
     )
   }
 
-  func testGoCommand() {
+  @Test func goCommand() {
     let go = EngineCommand.go(
       searchmoves: ["e2e4", "c7c6"],
       ponder: true,
@@ -83,22 +74,22 @@ class EngineCommandTests: XCTestCase {
       infinite: false
     )
 
-    XCTAssertEqual(go.rawValue, "go searchmoves e2e4 c7c6 ponder wtime 5 btime 5 winc 2 binc 2 movestogo 10 depth 15 nodes 100 mate 2 movetime 3")
+    #expect(go.rawValue == "go searchmoves e2e4 c7c6 ponder wtime 5 btime 5 winc 2 binc 2 movestogo 10 depth 15 nodes 100 mate 2 movetime 3")
 
     let goInfinite = EngineCommand.go(infinite: true)
-    XCTAssertEqual(goInfinite.rawValue, "go infinite")
+    #expect(goInfinite.rawValue == "go infinite")
   }
 
-  func testStopCommand() {
-    XCTAssertEqual(EngineCommand.stop.rawValue, "stop")
+  @Test func stopCommand() {
+    #expect(EngineCommand.stop.rawValue == "stop")
   }
 
-  func testPonderhitCommand() {
-    XCTAssertEqual(EngineCommand.ponderhit.rawValue, "ponderhit")
+  @Test func ponderhitCommand() {
+    #expect(EngineCommand.ponderhit.rawValue == "ponderhit")
   }
 
-  func testQuitCommand() {
-    XCTAssertEqual(EngineCommand.quit.rawValue, "quit")
+  @Test func quitCommand() {
+    #expect(EngineCommand.quit.rawValue == "quit")
   }
 
 }

Tests/ChessKitEngineTests/EngineResponseInfoTests.swift

@@ -3,13 +3,44 @@
 //  ChessKitEngineTests
 //
 
-import XCTest
 @testable import ChessKitEngine
+import Testing
 
-class EngineResponseInfoTests: XCTestCase {
+struct EngineResponseInfoTests {
 
-  func testStringConversion() {
-    let input = EngineResponse.Info(
+  @Test func subscripts() {
+    #expect(sampleInput["depth"] as? Int == sampleInput.depth)
+    #expect(sampleInput["seldepth"] as? Int == sampleInput.seldepth)
+    #expect(sampleInput["time"] as? Int == sampleInput.time)
+    #expect(sampleInput["nodes"] as? Int == sampleInput.nodes)
+    #expect(sampleInput["pv"] as? [String] == sampleInput.pv)
+    #expect(sampleInput["multipv"] as? Int == sampleInput.multipv)
+    #expect(sampleInput["score"] as? EngineResponse.Info.Score == sampleInput.score)
+    #expect(sampleInput["currmove"] as? String == sampleInput.currmove)
+    #expect(sampleInput["currmovenumber"] as? Int == sampleInput.currmovenumber)
+    #expect(sampleInput["hashfull"] as? Double == sampleInput.hashfull)
+    #expect(sampleInput["nps"] as? Int == sampleInput.nps)
+    #expect(sampleInput["tbhits"] as? Int == sampleInput.tbhits)
+    #expect(sampleInput["sbhits"] as? Int == sampleInput.sbhits)
+    #expect(sampleInput["cpuload"] as? Int == sampleInput.cpuload)
+    #expect(sampleInput["string"] as? String == sampleInput.string)
+    #expect(sampleInput["refutation"] as? [String] == sampleInput.refutation)
+    #expect(sampleInput["currline"] as? EngineResponse.Info.CurrLine == sampleInput.currline)
+
+  }
+
+  @Test func stringConversion() {
+    let output =
+      " <depth> 1 <seldepth> 0 <time> 1 <nodes> 10 <pv> e2e4 e7e5 g1f3 <multipv> 2 <score> <cp> 8.37 <mate> -4 <upperbound> <currmove> e2e4 <currmovenumber> 3 <hashfull> 4.56 <nps> 8 <tbhits> 7 <sbhits> 8 <cpuload> 9 <string> This is a test string with real tokens inserted such as pv and nodes and score lowerbound. <refutation> c7c5 d2d4 <currline> 4 d2d4 g8f6 c2c4 e7e6"
+
+    #expect(String(describing: sampleInput) == output)
+  }
+
+}
+
+private extension EngineResponseInfoTests {
+  var sampleInput: EngineResponse.Info {
+    EngineResponse.Info(
       depth: 1,
       seldepth: 0,
       time: 1,
@@ -35,11 +66,5 @@ class EngineResponseInfoTests: XCTestCase {
         moves: ["d2d4", "g8f6", "c2c4", "e7e6"]
       )
     )
-
-    let output =
-      " <depth> 1 <seldepth> 0 <time> 1 <nodes> 10 <pv> e2e4 e7e5 g1f3 <multipv> 2 <score> <cp> 8.37 <mate> -4 <upperbound> <currmove> e2e4 <currmovenumber> 3 <hashfull> 4.56 <nps> 8 <tbhits> 7 <sbhits> 8 <cpuload> 9 <string> This is a test string with real tokens inserted such as pv and nodes and score lowerbound. <refutation> c7c5 d2d4 <currline> 4 d2d4 g8f6 c2c4 e7e6"
-
-    XCTAssertEqual(String(describing: input), output)
   }
-
 }