1 files changed, 160 insertions, 2 deletions
diff --git a/MapTests/MapTests.swift b/MapTests/MapTests.swift
index 5a8f781..0dbf63b 100644
--- a/MapTests/MapTests.swift
+++ b/MapTests/MapTests.swift
@@ -1,11 +1,169 @@
+import CoreGraphics
 import Testing
 
 @testable import Map
 
 struct MapTests {
 
-  @Test func testExample() async throws {
-    // Write your test here and use APIs like `#expect(...)` to check expected conditions.
+  @Test func testMapParserWithEmptyInput() async throws {
+    let result = MapParser.parse(content: "")
+    #expect(result.vertices.isEmpty)
+    #expect(result.edges.isEmpty)
+    #expect(result.notes.isEmpty)
+    #expect(result.blockers.isEmpty)
+    #expect(result.opportunities.isEmpty)
+    #expect(result.groups.isEmpty)
+  }
+
+  @Test func testMapParserWithSingleVertex() async throws {
+    let content = "Node A (10, 20)"
+    let result = MapParser.parse(content: content)
+
+    #expect(result.vertices.count == 1)
+    let vertex = result.vertices.first!
+    #expect(vertex.label == "Node A")
+    #expect(vertex.position.x == 10.0)
+    #expect(vertex.position.y == 20.0)
+    #expect(vertex.shape == .circle)
+  }
+
+  @Test func testMapParserWithVertexWithShape() async throws {
+    let content = "Node B (30, 40) [square]"
+    let result = MapParser.parse(content: content)
+
+    #expect(result.vertices.count == 1)
+    let vertex = result.vertices.first!
+    #expect(vertex.label == "Node B")
+    #expect(vertex.position.x == 30.0)
+    #expect(vertex.position.y == 40.0)
+    #expect(vertex.shape == .square)
+  }
+
+  @Test func testMapParserWithEdge() async throws {
+    let content = """
+      Node A (10, 20)
+      Node B (30, 40)
+      Node A -- Node B
+      """
+    let result = MapParser.parse(content: content)
+
+    #expect(result.vertices.count == 2)
+    #expect(result.edges.count == 1)
+    let edge = result.edges.first!
+    #expect(edge.origin.x == 10.0)
+    #expect(edge.origin.y == 20.0)
+    #expect(edge.destination.x == 30.0)
+    #expect(edge.destination.y == 40.0)
+    #expect(edge.arrowhead == false)
+  }
+
+  @Test func testMapParserWithArrowEdge() async throws {
+    let content = """
+      Node A (10, 20)
+      Node B (30, 40)
+      Node A -> Node B
+      """
+    let result = MapParser.parse(content: content)
+
+    #expect(result.edges.count == 1)
+    let edge = result.edges.first!
+    #expect(edge.arrowhead == true)
+  }
+
+  @Test func testMapParserWithNote() async throws {
+    let content = "[Note] (50, 60) This is a test note"
+    let result = MapParser.parse(content: content)
+
+    #expect(result.notes.count == 1)
+    let note = result.notes.first!
+    #expect(note.position.x == 50.0)
+    #expect(note.position.y == 60.0)
+    #expect(note.text == "This is a test note")
+  }
+
+  @Test func testMapParserWithBlocker() async throws {
+    let content = """
+      Node A (10, 20)
+      [Blocker] Node A
+      """
+    let result = MapParser.parse(content: content)
+
+    #expect(result.blockers.count == 1)
+    let blocker = result.blockers.first!
+    #expect(blocker.position.x == 10.0)
+    #expect(blocker.position.y == 20.0)
+  }
+
+  @Test func testMapParserWithOpportunity() async throws {
+    let content = """
+      Node A (10, 20)
+      [Evolution] Node A +15
+      """
+    let result = MapParser.parse(content: content)
+
+    #expect(result.opportunities.count == 1)
+    let opportunity = result.opportunities.first!
+    #expect(opportunity.origin.x == 10.0)
+    #expect(opportunity.origin.y == 20.0)
+    #expect(opportunity.destination.x == 25.0)
+    #expect(opportunity.destination.y == 20.0)
+  }
+
+  @Test func testMapParserWithGroup() async throws {
+    let content = """
+      Node A (10, 20)
+      Node B (30, 40)
+      Node C (50, 60)
+      [Group] Node A, Node B, Node C
+      """
+    let result = MapParser.parse(content: content)
+
+    #expect(result.groups.count == 1)
+    let group = result.groups.first!
+    #expect(group.count == 3)
+    #expect(group.map { $0.label }.contains("Node A"))
+    #expect(group.map { $0.label }.contains("Node B"))
+    #expect(group.map { $0.label }.contains("Node C"))
+  }
+
+  @Test func testMapParserWithStages() async throws {
+    let content = """
+      [I] 15
+      [II] 35
+      [III] 80
+      """
+    let result = MapParser.parse(content: content)
+
+    #expect(result.stages.count == 3)
+    #expect(result.stages[0] == 15.0)
+    #expect(result.stages[1] == 35.0)
+    #expect(result.stages[2] == 80.0)
+  }
+
+  @Test func testMapParserWithComplexMap() async throws {
+    let content = """
+      Node A (10, 20)
+      Node B (30, 40) [square]
+      Node C (50, 60)
+      Node A -> Node B
+      Node B -- Node C
+      [Note] (70, 80) Complex map example
+      [Blocker] Node A
+      [Evolution] Node B +10
+      [Group] Node A, Node C
+      [I] 25
+      [II] 75
+      """
+    let result = MapParser.parse(content: content)
+
+    #expect(result.vertices.count == 3)
+    #expect(result.edges.count == 2)
+    #expect(result.notes.count == 1)
+    #expect(result.blockers.count == 1)
+    #expect(result.opportunities.count == 1)
+    #expect(result.groups.count == 1)
+    #expect(result.stages[0] == 25.0)
+    #expect(result.stages[1] == 75.0)
   }
 
 }