From 3c13f56c2009a9e103bd87d5416887f7260c3126 Mon Sep 17 00:00:00 2001
From: Paolo Di Lorenzo <dilorenzo@hey.com>
Date: Sat, 3 Aug 2024 12:14:24 -0400
Subject: [PATCH] Improve parser tests

---
 .../ChessKit/Parsers/PGNParser+Regex.swift    | 11 +--
 Sources/ChessKit/Parsers/PGNParser.swift      | 84 ++++++++-----------
 .../Parsers/EngineLANParserTests.swift        | 28 +++++--
 .../Parsers/PGNParserTests.swift              | 36 +++-----
 .../PGNParserPerformanceTests.swift           | 27 ++++++
 .../ChessKitTests/Utilities/SampleGames.swift | 28 +++++++
 6 files changed, 132 insertions(+), 82 deletions(-)
 create mode 100644 Tests/ChessKitTests/Performance/PGNParserPerformanceTests.swift
 create mode 100644 Tests/ChessKitTests/Utilities/SampleGames.swift

diff --git a/Sources/ChessKit/Parsers/PGNParser+Regex.swift b/Sources/ChessKit/Parsers/PGNParser+Regex.swift
index 9342439..becb0f3 100644
--- a/Sources/ChessKit/Parsers/PGNParser+Regex.swift
+++ b/Sources/ChessKit/Parsers/PGNParser+Regex.swift
@@ -6,21 +6,22 @@
 extension PGNParser {
 
     /// Contains useful regex strings for PGN parsing.
-    struct Regex {
+    struct Pattern {
         // tag pair components
         static let tags = #"\[[^\]]+\]"#
         static let tagPair = #"\[([^"]+?)\s"([^"]+)"\]"#
 
+        // move text
+        static let moveText = #"\d{1,}\.{1,3}\s?(([Oo0]-[Oo0](-[Oo0])?|[KQRBN]?[a-h]?[1-8]?x?[a-h][1-8](\=[QRBN])?[+#]?)([\?!]{1,2})?(\s?\$\d)?(\s?\{.+?\})?(\s(1-0|0-1|1\/2-1\/2))?\s?){1,2}"#
+        static let moveNumber = #"^\d{1,}"#
+        static let singleMove = "(\(castle)?|\(move)?)(\\s?\(annotation))?(\\s?\(comment))?"
+
         // move pair components
         static let castle = #"[Oo0]-[Oo0](-[Oo0])"#
         static let move = #"[KQRBN]?[a-h]?[1-8]?x?[a-h][1-8](\=[QRBN])?[+#]"#
         static let annotation = #"\$\d"#
         static let comment = #"\{.+?\}"#
         static let result = #"(1-0|0-1|1\/2-1\/2)"#
-
-        static let full = #"\d{1,}\.{1,3}\s?(([Oo0]-[Oo0](-[Oo0])?|[KQRBN]?[a-h]?[1-8]?x?[a-h][1-8](\=[QRBN])?[+#]?)([\?!]{1,2})?(\s?\$\d)?(\s?\{.+?\})?(\s(1-0|0-1|1\/2-1\/2))?\s?){1,2}"#
-
-        static let moveNumber = #"^\d{1,}"#
     }
 
 }
diff --git a/Sources/ChessKit/Parsers/PGNParser.swift b/Sources/ChessKit/Parsers/PGNParser.swift
index 6d8a458..2804cb2 100644
--- a/Sources/ChessKit/Parsers/PGNParser.swift
+++ b/Sources/ChessKit/Parsers/PGNParser.swift
@@ -5,15 +5,8 @@
 
 import Foundation
 
-/// Positional assessments.
-// periphery:ignore
-enum PositionAnnotation {
-    // <TBD>
-}
-
 /// Parses and converts the Portable Game Notation (PGN)
 /// of a chess game.
-///
 public enum PGNParser {
 
     /// Contains the contents of a single parsed move pair.
@@ -58,44 +51,43 @@ public enum PGNParser {
 
         // tags
 
-        let tags: [(String, String)]? = try? NSRegularExpression(pattern: Regex.tags)
+        let tags: [(String, String)]? = try? NSRegularExpression(pattern: Pattern.tags)
             .matches(in: processedPGN, range: range)
             .map {
                 NSString(string: pgn).substring(with: $0.range)
                     .trimmingCharacters(in: .whitespacesAndNewlines)
             }
-
             .compactMap { tag in
-            let tagRange = NSRange(0..<tag.utf16.count)
-
-            let matches = try? NSRegularExpression(pattern: Regex.tagPair)
-                .matches(in: tag, range: tagRange)
-
-            if let matches,
-               matches.count >= 1,
-               matches[0].numberOfRanges >= 3 {
-                let key = matches[0].range(at: 1)
-                let value = matches[0].range(at: 2)
-
-                return (
-                    NSString(string: tag).substring(with: key)
-                        .trimmingCharacters(in: .whitespacesAndNewlines),
-                    NSString(string: tag).substring(with: value)
-                        .trimmingCharacters(in: .whitespacesAndNewlines)
-                )
-            } else {
-                return nil
+                let tagRange = NSRange(0..<tag.utf16.count)
+
+                let matches = try? NSRegularExpression(pattern: Pattern.tagPair)
+                    .matches(in: tag, range: tagRange)
+
+                if let matches,
+                   matches.count >= 1,
+                   matches[0].numberOfRanges >= 3 {
+                    let key = matches[0].range(at: 1)
+                    let value = matches[0].range(at: 2)
+
+                    return (
+                        NSString(string: tag).substring(with: key)
+                            .trimmingCharacters(in: .whitespacesAndNewlines),
+                        NSString(string: tag).substring(with: value)
+                            .trimmingCharacters(in: .whitespacesAndNewlines)
+                    )
+                } else {
+                    return nil
+                }
             }
-        }
 
         let parsedTags = parsed(tags: Dictionary<String, String>(tags ?? []) { a, _ in a })
 
         // movetext
 
-        let moves: [String]
+        let moveText: [String]
 
         do {
-            moves = try NSRegularExpression(pattern: Regex.full)
+            moveText = try NSRegularExpression(pattern: Pattern.moveText)
                 .matches(in: processedPGN, range: range)
                 .map {
                     NSString(string: pgn).substring(with: $0.range)
@@ -105,18 +97,16 @@ public enum PGNParser {
             return nil
         }
 
-        let parsedMoves = moves.compactMap { move -> ParsedMove? in
+        let parsedMoves = moveText.compactMap { move -> ParsedMove? in
             let range = NSRange(0..<move.utf16.count)
 
-            guard let moveNumberRange = move.range(of: Regex.moveNumber, options: .regularExpression),
+            guard let moveNumberRange = move.range(of: Pattern.moveNumber, options: .regularExpression),
                   let moveNumber = Int(move[moveNumberRange])
             else {
                 return nil
             }
 
-            let singleMoveRegex = "(\(Regex.castle)?|\(Regex.move)?)(\\s?\(Regex.annotation))?(\\s?\(Regex.comment))?"
-
-            guard let m = try? NSRegularExpression(pattern: singleMoveRegex)
+            guard let m = try? NSRegularExpression(pattern: Pattern.singleMove)
                 .matches(in: move, range: range)
                 .map({ NSString(string: move).substring(with: $0.range) }),
                   m.count >= 1 && m.count <= 2
@@ -124,16 +114,16 @@ public enum PGNParser {
                 return nil
             }
 
-            let whiteAnnotation = try? NSRegularExpression(pattern: Regex.annotation)
+            let whiteAnnotation = try? NSRegularExpression(pattern: Pattern.annotation)
                 .matches(in: m[0], range: NSRange(0..<m[0].utf16.count))
-                .map {
-                    Move.Assessment(rawValue: NSString(string: m[0]).substring(with: $0.range)) ?? .null
+                .compactMap {
+                    Move.Assessment(rawValue: NSString(string: m[0]).substring(with: $0.range))
                 }
                 .first ?? .null
 
-            let whiteComment = try? NSRegularExpression(pattern: Regex.comment)
+            let whiteComment = try? NSRegularExpression(pattern: Pattern.comment)
                 .matches(in: m[0], range: NSRange(0..<m[0].utf16.count))
-                .map {
+                .compactMap {
                     NSString(string: m[0]).substring(with: $0.range)
                         .replacingOccurrences(of: "{", with: "")
                         .replacingOccurrences(of: "}", with: "")
@@ -144,16 +134,16 @@ public enum PGNParser {
             var blackComment: String?
 
             if m.count == 2 {
-                blackAnnotation = try? NSRegularExpression(pattern: Regex.annotation)
+                blackAnnotation = try? NSRegularExpression(pattern: Pattern.annotation)
                     .matches(in: m[1], range: NSRange(0..<m[1].utf16.count))
-                    .map {
-                        Move.Assessment(rawValue: NSString(string: m[1]).substring(with: $0.range)) ?? .null
+                    .compactMap {
+                        Move.Assessment(rawValue: NSString(string: m[1]).substring(with: $0.range))
                     }
                     .first ?? .null
 
-                blackComment = try? NSRegularExpression(pattern: Regex.comment)
+                blackComment = try? NSRegularExpression(pattern: Pattern.comment)
                     .matches(in: m[1], range: NSRange(0..<m[1].utf16.count))
-                    .map {
+                    .compactMap {
                         NSString(string: m[1]).substring(with: $0.range)
                             .replacingOccurrences(of: "{", with: "")
                             .replacingOccurrences(of: "}", with: "")
@@ -161,7 +151,7 @@ public enum PGNParser {
                     .first ?? ""
             }
 
-            let result = try? NSRegularExpression(pattern: Regex.result)
+            let result = try? NSRegularExpression(pattern: Pattern.result)
                 .matches(in: move, range: range)
                 .map {
                     NSString(string: move).substring(with: $0.range)
diff --git a/Tests/ChessKitTests/Parsers/EngineLANParserTests.swift b/Tests/ChessKitTests/Parsers/EngineLANParserTests.swift
index 5b8603b..4066fd5 100644
--- a/Tests/ChessKitTests/Parsers/EngineLANParserTests.swift
+++ b/Tests/ChessKitTests/Parsers/EngineLANParserTests.swift
@@ -8,14 +8,30 @@ import XCTest
 
 class EngineLANParserTests: XCTestCase {
 
+    func testCapture() {
+        let position = Position(fen: "8/8/8/4p3/3P4/8/8/8 w - - 0 1")!
+        let move = EngineLANParser.parse(move: "d4e5", for: .white, in: position)
+
+        let capturedPiece = Piece(.pawn, color: .black, square: .e5)
+        XCTAssertEqual(move?.result, .capture(capturedPiece))
+    }
+
     func testCastling() {
-        let p1 = Position(fen: "r3k3/8/8/8/8/8/8/4K2R w Kq - 0 1")!
-        let shortCastle = EngineLANParser.parse(move: "e1g1", for: .white, in: p1)
-        XCTAssertEqual(shortCastle?.result, .castle(.wK))
+        let p1 = Position(fen: "8/8/8/8/8/8/8/4K2R w KQ - 0 1")!
+        let wShortCastle = EngineLANParser.parse(move: "e1g1", for: .white, in: p1)
+        XCTAssertEqual(wShortCastle?.result, .castle(.wK))
+
+        let p2 = Position(fen: "8/8/8/8/8/8/8/R3K3 w KQ - 0 1")!
+        let wLongCastle = EngineLANParser.parse(move: "e1c1", for: .white, in: p2)
+        XCTAssertEqual(wLongCastle?.result, .castle(.wQ))
+
+        let p3 = Position(fen: "4k2r/8/8/8/8/8/8/8 b kq - 0 1")!
+        let bShortCastle = EngineLANParser.parse(move: "e8g8", for: .black, in: p3)
+        XCTAssertEqual(bShortCastle?.result, .castle(.bK))
 
-        let p2 = Position(fen: "r3k3/8/8/8/8/8/8/5RK1 b q - 0 1")!
-        let longCastle = EngineLANParser.parse(move: "e8c8", for: .black, in: p2)
-        XCTAssertEqual(longCastle?.result, .castle(.bQ))
+        let p4 = Position(fen: "r3k3/8/8/8/8/8/8/8 b kq - 0 1")!
+        let bLongCastle = EngineLANParser.parse(move: "e8c8", for: .black, in: p4)
+        XCTAssertEqual(bLongCastle?.result, .castle(.bQ))
     }
 
     func testPromotion() {
diff --git a/Tests/ChessKitTests/Parsers/PGNParserTests.swift b/Tests/ChessKitTests/Parsers/PGNParserTests.swift
index 7307800..3930141 100644
--- a/Tests/ChessKitTests/Parsers/PGNParserTests.swift
+++ b/Tests/ChessKitTests/Parsers/PGNParserTests.swift
@@ -8,35 +8,15 @@ import XCTest
 
 class PGNParserTests: XCTestCase {
 
-    private let pgn =
-        """
-        [Event "F/S Return Match"]
-        [Site "Belgrade, Serbia JUG"]
-        [Date "1992.11.04"]
-        [Round "29"]
-        [White "Fischer, Robert J."]
-        [Black "Spassky, Boris V."]
-        [Result "1/2-1/2"]
-
-        1. e4 $4 e5 2. Nf3 Nc6 3. Bb5 a6 {This opening is called the Ruy Lopez.}
-        4. Ba4 Nf6 5. O-O Be7 6. Re1 b5 7. Bb3 d6 8. c3 O-O 9. h3 Nb8 10. d4 Nbd7
-        11. c4 c6 12. cxb5 axb5 13. Nc3 Bb7 14. Bg5 b4 15. Nb1 h6 16. Bh4 c5 17. dxe5
-        Nxe4 18. Bxe7 Qxe7 19. exd6 Qf6 20. Nbd2 Nxd6 21. Nc4 Nxc4 22. Bxc4 Nb6
-        23. Ne5 Rae8 24. Bxf7+ Rxf7 25. Nxf7 Rxe1+ 26. Qxe1 Kxf7 27. Qe3 Qg5 28. Qxg5
-        hxg5 29. b3 Ke6 30. a3 Kd6 31. axb4 cxb4 32. Ra5 Nd5 33. f3 Bc8 34. Kf2 Bf5
-        35. Ra7 g6 36. Ra6+ Kc5 37. Ke1 Nf4 38. g3 Nxh3 39. Kd2 Kb5 40. Rd6 Kc5 41. Ra6
-        Nf2 42. g4 Bd3 43. Re6 1/2-1/2
-        """
-
     func testGameFromPGN() {
-        let game = PGNParser.parse(game: pgn)
-        let gameFromPGN = Game(pgn: pgn)
+        let game = PGNParser.parse(game: Game.fischerSpassky)
+        let gameFromPGN = Game(pgn: Game.fischerSpassky)
 
         XCTAssertEqual(game, gameFromPGN)
     }
 
     func testTagParsing() {
-        let game = PGNParser.parse(game: pgn)
+        let game = PGNParser.parse(game: Game.fischerSpassky)
 
         // tags
         XCTAssertEqual(game?.tags.event, "F/S Return Match")
@@ -49,7 +29,7 @@ class PGNParserTests: XCTestCase {
     }
 
     func testMoveTextParsing() {
-        let game = PGNParser.parse(game: pgn)
+        let game = PGNParser.parse(game: Game.fischerSpassky)
 
         // starting position + 85 ply
         XCTAssertEqual(game?.positions.keys.count, 86)
@@ -58,10 +38,18 @@ class PGNParserTests: XCTestCase {
             number: 1,
             color: .white
         )]?.assessment, .blunder)
+        XCTAssertEqual(game?.moves[.init(
+            number: 1,
+            color: .black
+        )]?.assessment, .brilliant)
         XCTAssertEqual(game?.moves[.init(
             number: 3,
             color: .black
         )]?.comment, "This opening is called the Ruy Lopez.")
+        XCTAssertEqual(game?.moves[.init(
+            number: 4,
+            color: .white
+        )]?.comment, "test comment")
         XCTAssertEqual(game?.moves[.init(
             number: 10,
             color: .white
diff --git a/Tests/ChessKitTests/Performance/PGNParserPerformanceTests.swift b/Tests/ChessKitTests/Performance/PGNParserPerformanceTests.swift
new file mode 100644
index 0000000..3b263f5
--- /dev/null
+++ b/Tests/ChessKitTests/Performance/PGNParserPerformanceTests.swift
@@ -0,0 +1,27 @@
+//
+//  PGNParserPerformanceTests.swift
+//  ChessKit
+//
+
+@testable import ChessKit
+import XCTest
+
+final class PGNParserPerformanceTests: XCTestCase {
+
+    func testBoardPerformance() {
+        measure(
+            metrics: [
+                XCTClockMetric(),
+                XCTCPUMetric(),
+                XCTMemoryMetric()
+            ],
+            block: parsePGN
+        )
+    }
+
+    private func parsePGN() {
+        let parsedGame = PGNParser.parse(game: Game.fischerSpassky)
+        XCTAssertNotNil(parsedGame)
+    }
+
+}
diff --git a/Tests/ChessKitTests/Utilities/SampleGames.swift b/Tests/ChessKitTests/Utilities/SampleGames.swift
new file mode 100644
index 0000000..4619854
--- /dev/null
+++ b/Tests/ChessKitTests/Utilities/SampleGames.swift
@@ -0,0 +1,28 @@
+//
+//  SampleGames.swift
+//  ChessKit
+//
+
+@testable import struct ChessKit.Game
+
+extension Game {
+    static let fischerSpassky =
+        """
+        [Event "F/S Return Match"]
+        [Site "Belgrade, Serbia JUG"]
+        [Date "1992.11.04"]
+        [Round "29"]
+        [White "Fischer, Robert J."]
+        [Black "Spassky, Boris V."]
+        [Result "1/2-1/2"]
+        
+        1. e4 $4 e5 $3 2. Nf3 Nc6 3. Bb5 a6 {This opening is called the Ruy Lopez.}
+        4. Ba4 {test comment} Nf6 5. O-O Be7 6. Re1 b5 7. Bb3 d6 8. c3 O-O 9. h3 Nb8 10. d4 Nbd7
+        11. c4 c6 12. cxb5 axb5 13. Nc3 Bb7 14. Bg5 b4 15. Nb1 h6 16. Bh4 c5 17. dxe5
+        Nxe4 18. Bxe7 Qxe7 19. exd6 Qf6 20. Nbd2 Nxd6 21. Nc4 Nxc4 22. Bxc4 Nb6
+        23. Ne5 Rae8 24. Bxf7+ Rxf7 25. Nxf7 Rxe1+ 26. Qxe1 Kxf7 27. Qe3 Qg5 28. Qxg5
+        hxg5 29. b3 Ke6 30. a3 Kd6 31. axb4 cxb4 32. Ra5 Nd5 33. f3 Bc8 34. Kf2 Bf5
+        35. Ra7 g6 36. Ra6+ Kc5 37. Ke1 Nf4 38. g3 Nxh3 39. Kd2 Kb5 40. Rd6 Kc5 41. Ra6
+        Nf2 42. g4 Bd3 43. Re6 1/2-1/2
+        """
+}