other: Added tests for InvalidErrorBindingTypeError and catch-all catch blocks

Author: Luna-Klatzer

test/module/core/core-functionality/try-catch.test.ts

@@ -6,6 +6,42 @@ import { ScriptTarget } from "typescript";
 import { testPrintOutput } from "../index";
 
 describe("Try-Catch Statements", () => {
+	it("should be able to catch all errors using default catch", async () => {
+		const fileContent = `var x: num = 4; try { x = 5; } catch (_) { x = 6; } print(x);`;
+		const instance: KipperCompileResult = await compiler.compile(fileContent, { target: defaultTarget });
+
+		assert.isDefined(instance.programCtx);
+		assert.deepEqual(instance.programCtx!!.errors, [], "Expected no compilation errors");
+
+		const written = instance.write();
+		assert.include(
+			written,
+			`try\n{\n  x = 5;\n}\ncatch (__kipper_e)\n{\n  if (true) {\n    const _ = __kipper_e;\n    x = 6;\n  }\n}`,
+			"Invalid TypeScript code (Expected different output)",
+		);
+
+		const jsCode = ts.transpile(instance.write(), { target: ScriptTarget.ES2015 });
+		testPrintOutput((message: any) => assert.equal(message, "5", "Expected different output"), jsCode);
+	});
+
+	it("should be able to catch all errors using any catch", async () => {
+		const fileContent = `var x: num = 4; try { x = 5; } catch (e: any) { x = 6; } print(x);`;
+		const instance: KipperCompileResult = await compiler.compile(fileContent, { target: defaultTarget });
+
+		assert.isDefined(instance.programCtx);
+		assert.deepEqual(instance.programCtx!!.errors, [], "Expected no compilation errors");
+
+		const written = instance.write();
+		assert.include(
+			written,
+			`try\n{\n  x = 5;\n}\ncatch (__kipper_e)\n{\n  if (true) {\n    const e = __kipper_e;\n    x = 6;\n  }\n}`,
+			"Invalid TypeScript code (Expected different output)",
+		);
+
+		const jsCode = ts.transpile(instance.write(), { target: ScriptTarget.ES2015 });
+		testPrintOutput((message: any) => assert.equal(message, "5", "Expected different output"), jsCode);
+	});
+
 	it("should be able to catch errors using try-catch", async () => {
 		const fileContent = `class CustomError {} var x: num = 4; try { x = 5; } catch (e: CustomError) { x = 6; } print(x);`;
 		const instance: KipperCompileResult = await compiler.compile(fileContent, { target: defaultTarget });

test/module/core/errors/type-errors/invalid-error-binding-type.ts

@@ -0,0 +1,70 @@
+import type { KipperCompileResult, KipperError } from "@kipper/core";
+import { KipperCompiler } from "@kipper/core";
+import { defaultConfig, ensureTracebackDataExists } from "../index";
+import { assert } from "chai";
+
+describe("InvalidErrorBindingTypeError", () => {
+	describe("Error", () => {
+		it("num error binding", async () => {
+			try {
+				await new KipperCompiler().compile("try {} catch (e: num) {}", defaultConfig);
+			} catch (e) {
+				assert.equal((<KipperError>e).constructor.name, "InvalidErrorBindingTypeError", "Expected different error");
+				assert.equal((<KipperError>e).name, "TypeError", "Expected different error");
+				ensureTracebackDataExists(<KipperError>e);
+				return;
+			}
+			assert.fail("Expected 'InvalidErrorBindingTypeError'");
+		});
+
+		it("interface error binding", async () => {
+			try {
+				await new KipperCompiler().compile("interface A {}; try {} catch (e: A) {}", defaultConfig);
+			} catch (e) {
+				assert.equal((<KipperError>e).constructor.name, "InvalidErrorBindingTypeError", "Expected different error");
+				assert.equal((<KipperError>e).name, "TypeError", "Expected different error");
+				ensureTracebackDataExists(<KipperError>e);
+				return;
+			}
+			assert.fail("Expected 'InvalidErrorBindingTypeError'");
+		});
+	});
+
+	describe("No Error", () => {
+		it("no error type", async () => {
+			let result: KipperCompileResult | undefined = undefined;
+			try {
+				result = await new KipperCompiler().compile("try {} catch (e) {}", defaultConfig);
+			} catch (e) {
+				assert.fail(`Expected no '${(<KipperError>e).name}'`);
+			}
+			assert.isDefined(result, "Expected defined compilation result");
+			assert.isDefined(result?.programCtx, "Expected programCtx to be defined");
+			assert.isFalse(result?.programCtx?.hasFailed, "Expected no errors");
+		});
+
+		it("any error binding", async () => {
+			let result: KipperCompileResult | undefined = undefined;
+			try {
+				result = await new KipperCompiler().compile("try {} catch (e: any) {}", defaultConfig);
+			} catch (e) {
+				assert.fail(`Expected no '${(<KipperError>e).name}'`);
+			}
+			assert.isDefined(result, "Expected defined compilation result");
+			assert.isDefined(result?.programCtx, "Expected programCtx to be defined");
+			assert.isFalse(result?.programCtx?.hasFailed, "Expected no errors");
+		});
+
+		it("class error binding", async () => {
+			let result: KipperCompileResult | undefined = undefined;
+			try {
+				result = await new KipperCompiler().compile("class A {}; try {} catch (e: A) {}", defaultConfig);
+			} catch (e) {
+				assert.fail(`Expected no '${(<KipperError>e).name}'`);
+			}
+			assert.isDefined(result, "Expected defined compilation result");
+			assert.isDefined(result?.programCtx, "Expected programCtx to be defined");
+			assert.isFalse(result?.programCtx?.hasFailed, "Expected no errors");
+		});
+	});
+});