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
|
import XCTest
@testable import WIT
class ParseTopTests: XCTestCase {
func testASTEmpty() throws {
var lexer = Lexer(cursor: .init(input: ""))
let ast = try SourceFileSyntax.parse(lexer: &lexer)
XCTAssertNil(ast.packageId)
XCTAssertEqual(ast.items.count, 0)
}
func testASTEndingWithNewline() throws {
var lexer = Lexer(cursor: .init(input: "\n"))
let ast = try SourceFileSyntax.parse(lexer: &lexer)
XCTAssertNil(ast.packageId)
XCTAssertEqual(ast.items.count, 0)
}
func testASTWithPackageId() throws {
var lexer = Lexer(cursor: .init(input: "package foo:bar"))
let ast = try SourceFileSyntax.parse(lexer: &lexer)
XCTAssertNotNil(ast.packageId)
}
func testASTWithItem() throws {
var lexer = Lexer(
cursor: .init(
input: """
interface x {}
world y {}
use z
"""))
let ast = try SourceFileSyntax.parse(lexer: &lexer)
XCTAssertEqual(ast.items.count, 3)
}
func testASTWithInvalidItem() throws {
var lexer = Lexer(cursor: .init(input: "."))
XCTAssertThrowsError(try SourceFileSyntax.parse(lexer: &lexer))
}
func parsePackageName(_ text: String) throws -> PackageNameSyntax {
var lexer = Lexer(cursor: .init(input: text))
return try PackageNameSyntax.parse(lexer: &lexer)
}
func testPackageName() throws {
let packageId = try parsePackageName("package foo:bar")
XCTAssertEqual(packageId.namespace.text, "foo")
XCTAssertEqual(packageId.name.text, "bar")
}
func testPackageNameWithVersion() throws {
let packageId = try parsePackageName("package foo:bar@1.0.0")
XCTAssertEqual(packageId.namespace.text, "foo")
XCTAssertEqual(packageId.name.text, "bar")
}
func testIdentifier() throws {
var lexer = Lexer(cursor: .init(input: "xyz"))
let id = try Identifier.parse(lexer: &lexer)
XCTAssertEqual(id.text, "xyz")
}
func testIdentifierEmpty() throws {
var lexer = Lexer(cursor: .init(input: ""))
XCTAssertThrowsError(try Identifier.parse(lexer: &lexer))
}
func testIdentifierExplicit() throws {
var lexer = Lexer(cursor: .init(input: "%abcd"))
let id = try Identifier.parse(lexer: &lexer)
XCTAssertEqual(id.text, "abcd")
}
func testIdentifierWithInvalidToken() throws {
var lexer = Lexer(cursor: .init(input: "."))
XCTAssertThrowsError(try Identifier.parse(lexer: &lexer))
}
func testDocuments() throws {
var lexer = Lexer(
cursor: .init(
input: """
// comment here
/* multi-line
comment */
"""))
let docs = try DocumentsSyntax.parse(lexer: &lexer)
XCTAssertEqual(docs.comments.count, 2)
XCTAssertEqual(
docs.comments,
[
"// comment here\n",
"""
/* multi-line
comment */
""",
])
}
func testDocumentsEmpty() throws {
var lexer = Lexer(cursor: .init(input: ""))
let docs = try DocumentsSyntax.parse(lexer: &lexer)
XCTAssertEqual(docs.comments.count, 0)
}
func testTopLevelUseAs() throws {
var lexer = Lexer(cursor: .init(input: "use abc as xyz"))
let use = try TopLevelUseSyntax.parse(lexer: &lexer, documents: .init(comments: []))
XCTAssertEqual(use.item.name.text, "abc")
XCTAssertEqual(use.asName?.text, "xyz")
}
func testUse() throws {
var lexer = Lexer(cursor: .init(input: "use abc.{x, y, z}"))
let use = try UseSyntax.parse(lexer: &lexer)
XCTAssertEqual(use.from.name.text, "abc")
XCTAssertEqual(use.names.map(\.name.text), ["x", "y", "z"])
XCTAssertEqual(use.names.map(\.asName?.text), [nil, nil, nil])
}
func testUseAs() throws {
var lexer = Lexer(cursor: .init(input: "use abc.{x as d, y as e, z}"))
let use = try UseSyntax.parse(lexer: &lexer)
XCTAssertEqual(use.from.name.text, "abc")
XCTAssertEqual(use.names.map(\.name.text), ["x", "y", "z"])
XCTAssertEqual(use.names.map(\.asName?.text), ["d", "e", nil])
}
func testUsePath() throws {
var lexer = Lexer(cursor: .init(input: "use ns1:pkg1/item1@1.0.0"))
let use = try TopLevelUseSyntax.parse(lexer: &lexer, documents: .init(comments: []))
XCTAssertEqual(use.item.name.text, "item1")
guard case let .package(id, _) = use.item else {
XCTFail("expected package but got \(use.item)")
return
}
XCTAssertEqual(id.namespace.text, "ns1")
XCTAssertEqual(id.name.text, "pkg1")
}
}
extension SourceFileSyntax {
static func parse(lexer: inout Lexer) throws -> SyntaxNode<SourceFileSyntax> {
try SourceFileSyntax.parse(lexer: &lexer, fileName: "test.wit")
}
}
|
