1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
import CoreGraphics
import Testing
@testable import Map
struct MapTests {
@Test func testMapParserWithEmptyInput() async throws {
let result = MapParser.parse(content: "")
#expect(result.vertices.isEmpty)
#expect(result.edges.isEmpty)
#expect(result.notes.isEmpty)
#expect(result.inertias.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 testMapParserWithInertia() async throws {
let content = """
Node A (10, 20)
[Inertia] Node A
"""
let result = MapParser.parse(content: content)
#expect(result.inertias.count == 1)
let inertia = result.inertias.first!
#expect(inertia.position.x == 10.0)
#expect(inertia.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
[Inertia] 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.inertias.count == 1)
#expect(result.opportunities.count == 1)
#expect(result.groups.count == 1)
#expect(result.stages[0] == 25.0)
#expect(result.stages[1] == 75.0)
}
}
|
