🚨 updated Parser tests

Author: igorkulman

PascalInterpreter/PascalInterpreter/FatalError.swift

@@ -11,9 +11,9 @@ import Foundation
 /**
  Taken from https://medium.com/@marcosantadev/how-to-test-fatalerror-in-swift-e1be9ff11a29
  */
-/*func fatalError(_ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) -> Never {
+func fatalError(_ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) -> Never {
     FatalErrorUtil.fatalErrorClosure(message(), file, line)
-}*/
+}
 
 struct FatalErrorUtil {
 

PascalInterpreter/PascalInterpreterTests/ParserTests.swift

@@ -373,12 +373,20 @@ class ParserTests: XCTestCase {
             """
 
         let parser = Parser(program)
-        _ = parser.parse()
+        let result = parser.parse()
+        let compound = Compound(children: [Assignment(left: Variable(name: "result"), right: FunctionCall(name: "Factorial", actualParameters: [Number.integer(6)])), NoOp()])
+        let resultDeclaration = VariableDeclaration(variable: Variable(name: "result"), type: VariableType(type: .integer))
+        let ifelse = IfElse(condition: Condition(type: .greaterThan, leftSide: Variable(name: "number"), rightSide: Number.integer(1)), trueExpression: Assignment(left: Variable(name: "Factorial"), right: BinaryOperation(left: Variable(name: "number"), operation: .mult, right: FunctionCall(name: "Factorial", actualParameters: [BinaryOperation(left: Variable(name: "number"), operation: .minus, right: Number.integer(1))]))), falseExpression: Assignment(left: Variable(name: "Factorial"), right: Number.integer(1)))
+        let factorialBlock = Block(declarations: [], compound: Compound(children: [ifelse]))
+        let factorialDeclarion = Function(name: "Factorial", params: [Param(name: "number", type: VariableType(type: .integer))], block: factorialBlock, returnType: VariableType(type: .integer))
+        let block = Block(declarations: [resultDeclaration, factorialDeclarion], compound: compound)
+        let node = Program(name: "Main", block: block)
+        XCTAssertEqual(result, node)
     }
 
     func testProgramWithStringConstants() {
         let program =
-        """
+            """
             program Main;
             var s: String;
                 a: Boolean;
@@ -390,6 +398,10 @@ class ParserTests: XCTestCase {
             """
 
         let parser = Parser(program)
-        _ = parser.parse()
+        let result = parser.parse()
+        let compound = Compound(children: [Assignment(left: Variable(name: "s"), right: "Test"), Assignment(left: Variable(name: "a"), right: false), FunctionCall(name: "writeln", actualParameters: [Variable(name:"s"), Variable(name:"a")]), NoOp()])
+        let block = Block(declarations: [VariableDeclaration(variable: Variable(name: "s"), type: VariableType(type: .string)), VariableDeclaration(variable: Variable(name: "a"), type: VariableType(type: .boolean))], compound: compound)
+        let node = Program(name: "Main", block: block)
+        XCTAssertEqual(result, node)
     }
 }

PascalInterpreter/PascalInterpreterTests/XCTestCase+FatalError.swift

@@ -87,7 +87,7 @@ func XCTAssertEqual(_ left: AST, _ right: AST) {
         XCTAssert(left.name == right.name)
         XCTAssertEqual(left.block, right.block)
         XCTAssert(left.params.count == right.params.count)
-        if left.params.count > 0 {
+        if left.params.count > 0 && left.params.count == right.params.count {
             for i in 0 ... left.params.count - 1 {
                 XCTAssertEqual(left.params[i], right.params[i])
             }
@@ -130,6 +130,10 @@ func XCTAssertEqual(_ left: AST, _ right: AST) {
         if let leftFalse = left.falseExpression, let rightFalse = right.falseExpression {
             XCTAssertEqual(leftFalse, rightFalse)
         }
+    case let (left as String, right as String):
+        XCTAssert(left == right)
+    case let (left as Bool, right as Bool):
+        XCTAssert(left == right)
     default:
         XCTFail("\(left) and \(right) are not equal")
     }