Skip to content

Commit a4529dd

Browse files
igorkulmanigorkulman
committed
🚨 better tests
1 parent a4ab256 commit a4529dd

File tree

5 files changed

+79
-21
lines changed

5 files changed

+79
-21
lines changed

‎PascalInterpreter/PascalInterpreter/Interpreter/Value.swift‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ enum Value {
1414
}
1515

1616
extension Value: Equatable {
17-
static func ==(lhs: Value, rhs: Value) -> Bool {
17+
static func == (lhs: Value, rhs: Value) -> Bool {
1818
switch (lhs, rhs) {
1919
case let (.number(left), .number(right)):
2020
return left == right

‎PascalInterpreter/PascalInterpreter/Semantic analyzer/SemanticAnalyzer.swift‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -92,6 +92,20 @@ public class SemanticAnalyzer: Visitor {
9292
guard let variableSymbol = procedure.params[i] as? VariableSymbol, variableSymbol.type is BuiltInTypeSymbol else {
9393
fatalError("Procedure declared with wrong parameters '\(call.name)'")
9494
}
95+
96+
switch variableSymbol.type {
97+
case let builtIn as BuiltInTypeSymbol:
98+
if let constant = call.actualParameters[i] as? Number {
99+
switch (builtIn.name, constant) {
100+
case ("INTEGER", .real):
101+
fatalError("Cannot assing Real to Integer parameter in procedure call '\(procedure.name)'")
102+
default:
103+
break
104+
}
105+
}
106+
default:
107+
fatalError("Variable type \(variableSymbol.name) in procedure \(procedure.name) cannot be of type \(variableSymbol.type)")
108+
}
95109
}
96110
}
97111
}

‎PascalInterpreter/PascalInterpreter/Semantic analyzer/Visitor.swift‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -60,9 +60,9 @@ extension Visitor {
6060
case let call as ProcedureCall:
6161
visit(call: call)
6262
case let condition as Condition:
63-
break
63+
visit(condition: condition)
6464
case let ifElse as IfElse:
65-
break
65+
visit(ifElse: ifElse)
6666
default:
6767
fatalError("Unsupported node type \(node)")
6868
}

‎PascalInterpreter/PascalInterpreterTests/SemanticAnalyzerTests.swift‎

Lines changed: 58 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,15 @@ class SemanticAnalyzerTests: XCTestCase {
3434
let node = parser.parse()
3535

3636
let analyzer = SemanticAnalyzer()
37-
analyzer.analyze(node: node)
37+
let state = analyzer.analyze(node: node)
38+
XCTAssert(state.keys.count == 1)
39+
XCTAssert(state["global"] != nil)
40+
XCTAssert(state["global"]!.level == 1)
41+
XCTAssert(state["global"]!.lookup("y") != nil)
42+
XCTAssert(state["global"]!.lookup("a") != nil)
43+
XCTAssert(state["global"]!.lookup("b") != nil)
44+
XCTAssert(state["global"]!.lookup("number") != nil)
45+
XCTAssert(state["global"]!.lookup("c") == nil)
3846
}
3947

4048
func testSemanticAnalyzerAssignUndeclaredVariable() {
@@ -59,7 +67,7 @@ class SemanticAnalyzerTests: XCTestCase {
5967

6068
let analyzer = SemanticAnalyzer()
6169
expectFatalError(expectedMessage: "Symbol(indetifier) not found 'x'") {
62-
analyzer.analyze(node: node)
70+
_ = analyzer.analyze(node: node)
6371
}
6472
}
6573

@@ -79,7 +87,7 @@ class SemanticAnalyzerTests: XCTestCase {
7987

8088
let analyzer = SemanticAnalyzer()
8189
expectFatalError(expectedMessage: "Symbol(indetifier) not found 'y'") {
82-
analyzer.analyze(node: node)
90+
_ = analyzer.analyze(node: node)
8391
}
8492
}
8593

@@ -100,7 +108,7 @@ class SemanticAnalyzerTests: XCTestCase {
100108

101109
let analyzer = SemanticAnalyzer()
102110
expectFatalError(expectedMessage: "Duplicate identifier 'y' found") {
103-
analyzer.analyze(node: node)
111+
_ = analyzer.analyze(node: node)
104112
}
105113
}
106114

@@ -125,7 +133,19 @@ class SemanticAnalyzerTests: XCTestCase {
125133
let node = parser.parse()
126134

127135
let analyzer = SemanticAnalyzer()
128-
analyzer.analyze(node: node)
136+
let state = analyzer.analyze(node: node)
137+
XCTAssert(state.keys.count == 2)
138+
XCTAssert(state["global"] != nil)
139+
XCTAssert(state["global"]!.level == 1)
140+
XCTAssert(state["global"]!.lookup("x") != nil)
141+
XCTAssert(state["global"]!.lookup("y") != nil)
142+
XCTAssert(state["global"]!.lookup("a") == nil)
143+
XCTAssert(state.keys.count == 2)
144+
XCTAssert(state["Alpha"] != nil)
145+
XCTAssert(state["Alpha"]!.level == 2)
146+
XCTAssert(state["Alpha"]!.lookup("x") != nil)
147+
XCTAssert(state["Alpha"]!.lookup("y") != nil)
148+
XCTAssert(state["Alpha"]!.lookup("a") != nil)
129149
}
130150

131151
func testSemanticAnalyzerUndeclaredProcedure() {
@@ -150,7 +170,7 @@ class SemanticAnalyzerTests: XCTestCase {
150170

151171
let analyzer = SemanticAnalyzer()
152172
expectFatalError(expectedMessage: "Symbol(procedure) not found 'Beta'") {
153-
analyzer.analyze(node: node)
173+
_ = analyzer.analyze(node: node)
154174
}
155175
}
156176

@@ -175,7 +195,19 @@ class SemanticAnalyzerTests: XCTestCase {
175195
let node = parser.parse()
176196

177197
let analyzer = SemanticAnalyzer()
178-
analyzer.analyze(node: node)
198+
let state = analyzer.analyze(node: node)
199+
XCTAssert(state.keys.count == 2)
200+
XCTAssert(state["global"] != nil)
201+
XCTAssert(state["global"]!.level == 1)
202+
XCTAssert(state["global"]!.lookup("x") != nil)
203+
XCTAssert(state["global"]!.lookup("y") != nil)
204+
XCTAssert(state["global"]!.lookup("a") == nil)
205+
XCTAssert(state.keys.count == 2)
206+
XCTAssert(state["Alpha"] != nil)
207+
XCTAssert(state["Alpha"]!.level == 2)
208+
XCTAssert(state["Alpha"]!.lookup("x") != nil)
209+
XCTAssert(state["Alpha"]!.lookup("y") != nil)
210+
XCTAssert(state["Alpha"]!.lookup("a") == nil)
179211
}
180212

181213
func testSemanticAnalyzerProcedureUndeclaredVariable() {
@@ -200,13 +232,13 @@ class SemanticAnalyzerTests: XCTestCase {
200232

201233
let analyzer = SemanticAnalyzer()
202234
expectFatalError(expectedMessage: "Symbol(indetifier) not found 'b'") {
203-
analyzer.analyze(node: node)
235+
_ = analyzer.analyze(node: node)
204236
}
205237
}
206238

207239
func testSemanticAnalyzerProcedureCallWithoutParameter() {
208240
let program =
209-
"""
241+
"""
210242
program Main;
211243
var x, y: real;
212244
@@ -226,13 +258,13 @@ class SemanticAnalyzerTests: XCTestCase {
226258

227259
let analyzer = SemanticAnalyzer()
228260
expectFatalError(expectedMessage: "Procedure called with wrong number of parameters 'Alpha'") {
229-
analyzer.analyze(node: node)
261+
_ = analyzer.analyze(node: node)
230262
}
231263
}
232264

233265
func testSemanticAnalyzerProcedureCallWithParameter() {
234266
let program =
235-
"""
267+
"""
236268
program Main;
237269
var x, y: real;
238270
@@ -251,12 +283,24 @@ class SemanticAnalyzerTests: XCTestCase {
251283
let node = parser.parse()
252284

253285
let analyzer = SemanticAnalyzer()
254-
analyzer.analyze(node: node)
286+
let state = analyzer.analyze(node: node)
287+
XCTAssert(state.keys.count == 2)
288+
XCTAssert(state["global"] != nil)
289+
XCTAssert(state["global"]!.level == 1)
290+
XCTAssert(state["global"]!.lookup("x") != nil)
291+
XCTAssert(state["global"]!.lookup("y") != nil)
292+
XCTAssert(state["global"]!.lookup("a") == nil)
293+
XCTAssert(state.keys.count == 2)
294+
XCTAssert(state["Alpha"] != nil)
295+
XCTAssert(state["Alpha"]!.level == 2)
296+
XCTAssert(state["Alpha"]!.lookup("x") != nil)
297+
XCTAssert(state["Alpha"]!.lookup("y") != nil)
298+
XCTAssert(state["Alpha"]!.lookup("a") != nil)
255299
}
256300

257301
func testSemanticAnalyzerProcedureCallWithParameterWrongType() {
258302
let program =
259-
"""
303+
"""
260304
program Main;
261305
var x, y: real;
262306
@@ -276,7 +320,7 @@ class SemanticAnalyzerTests: XCTestCase {
276320

277321
let analyzer = SemanticAnalyzer()
278322
expectFatalError(expectedMessage: "Cannot assing Real to Integer parameter in procedure call 'Alpha'") {
279-
analyzer.analyze(node: node)
323+
_ = analyzer.analyze(node: node)
280324
}
281325
}
282326
}

‎PascalInterpreter/PascalInterpreterTests/XCTestCase+FatalError.swift‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,7 @@ func XCTAssertEqual(_ left: AST, _ right: AST) {
5858
XCTAssertEqual(left.compound, right.compound)
5959
case let (left as Compound, right as Compound):
6060
XCTAssert(left.children.count == right.children.count)
61-
if left.children.count > 0 {
61+
if left.children.count > 0 && left.children.count == right.children.count {
6262
for i in 0 ... left.children.count - 1 {
6363
XCTAssertEqual(left.children[i], right.children[i])
6464
}
@@ -94,7 +94,7 @@ func XCTAssertEqual(_ left: AST, _ right: AST) {
9494
case let (left as ProcedureCall, right as ProcedureCall):
9595
XCTAssert(left.name == right.name)
9696
XCTAssert(left.actualParameters.count == right.actualParameters.count)
97-
if left.actualParameters.count > 0 {
97+
if left.actualParameters.count > 0 && left.actualParameters.count == right.actualParameters.count {
9898
for i in 0 ... left.actualParameters.count - 1 {
9999
XCTAssertEqual(left.actualParameters[i], right.actualParameters[i])
100100
}
@@ -110,9 +110,9 @@ func XCTAssertEqual(_ left: AST, _ right: AST) {
110110
XCTAssertEqual(left.trueExpression, right.trueExpression)
111111
switch (left.falseExpression == nil, right.falseExpression == nil) {
112112
case (true, false):
113-
XCTFail("\(left.falseExpression) and \(right.falseExpression) are not equal")
113+
XCTFail("\(String(describing: left.falseExpression)) and \(String(describing: right.falseExpression)) are not equal")
114114
case (false, true):
115-
XCTFail("\(left.falseExpression) and \(right.falseExpression) are not equal")
115+
XCTFail("\(String(describing: left.falseExpression)) and \(String(describing: right.falseExpression)) are not equal")
116116
default:
117117
break
118118
}

0 commit comments

Comments
 (0)