Add test cases

Author: kateinoigakukun

IntegrationTests/TestSuites/Sources/PrimaryTests/UnitTestUtils.swift

@@ -84,3 +84,20 @@ func expectString(_ value: JSValue, file: StaticString = #file, line: UInt = #li
         throw MessageError("Type of \(value) should be \"string\"", file: file, line: line, column: column)
     }
 }
+
+func expectThrow<T>(_ body: @autoclosure () throws -> T, file: StaticString = #file, line: UInt = #line, column: UInt = #column) throws -> Error {
+    do {
+        _ = try body()
+    } catch {
+        return error
+    }
+    throw MessageError("Expect to throw an exception", file: file, line: line, column: column)
+}
+
+func expectNotNil<T>(_ value: T?, file: StaticString = #file, line: UInt = #line, column: UInt = #column) throws {
+    switch value {
+    case .some: return
+    case .none:
+        throw MessageError("Expect a non-nil value", file: file, line: line, column: column)
+    }
+}

IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift

@@ -517,3 +517,57 @@ try test("JSValue accessor") {
     try expectEqual(globalObject1.prop_4[0], .number(3))
     try expectEqual(globalObject1.prop_4[1], .number(4))
 }
+
+try test("Exception") {
+    // ```js
+    // global.globalObject1 = {
+    //   ...
+    //   prop_9: {
+    //       func1: function () {
+    //           throw new Error();
+    //       },
+    //       func2: function () {
+    //           throw "String Error";
+    //       },
+    //       func3: function () {
+    //           throw 3.0
+    //       },
+    //   },
+    //   ...
+    // }
+    // ```
+    //
+
+    let globalObject1 = JSObject.global.globalObject1
+    let prop_9: JSValue = globalObject1.prop_9
+
+    // MARK: Throwing method calls
+    let error1 = try expectThrow(try prop_9.object!.throwing.func1!())
+    try expectEqual(error1 is JSValue, true)
+    let errorObject = JSError(from: error1 as! JSValue)
+    try expectNotNil(errorObject)
+
+    let error2 = try expectThrow(try prop_9.object!.throwing.func2!())
+    try expectEqual(error2 is JSValue, true)
+    let errorString = try expectString(error2 as! JSValue)
+    try expectEqual(errorString, "String Error")
+
+    let error3 = try expectThrow(try prop_9.object!.throwing.func3!())
+    try expectEqual(error3 is JSValue, true)
+    let errorNumber = try expectNumber(error3 as! JSValue)
+    try expectEqual(errorNumber, 3.0)
+
+    // MARK: Simple function calls
+    let error4 = try expectThrow(try prop_9.func1.function!.throws())
+    try expectEqual(error4 is JSValue, true)
+    let errorObject2 = JSError(from: error4 as! JSValue)
+    try expectNotNil(errorObject2)
+    
+    // MARK: Throwing constructor call
+    let Animal = JSObject.global.Animal.function!
+    _ = try Animal.throws.new("Tama", 3, true)
+    let ageError = try expectThrow(try Animal.throws.new("Tama", -3, true))
+    try expectEqual(ageError is JSValue, true)
+    let errorObject3 = JSError(from: ageError as! JSValue)
+    try expectNotNil(errorObject3)
+}

IntegrationTests/bin/primary-tests.js

@@ -36,9 +36,23 @@ global.globalObject1 = {
     },
     prop_7: 3.14,
     prop_8: [0, , 2, 3, , , 6],
+    prop_9: {
+        func1: function () {
+            throw new Error();
+        },
+        func2: function () {
+            throw "String Error";
+        },
+        func3: function () {
+            throw 3.0
+        },
+    },
 };
 
 global.Animal = function (name, age, isCat) {
+    if (age < 0) {
+        throw new Error("Invalid age " + age);
+    }
     this.name = name;
     this.age = age;
     this.bark = () => {

Sources/JavaScriptKit/FundamentalObjects/JSFunction.swift

@@ -50,6 +50,25 @@ public class JSFunction: JSObject {
         }
     }
 
+    /// A modifier to call this function as a throwing function
+    ///
+    ///
+    /// ```javascript
+    /// function validateAge(age) {
+    ///   if (age < 0) {
+    ///     throw new Error("Invalid age");
+    ///   }
+    /// }
+    /// ```
+    ///
+    /// ```swift
+    /// let validateAge = JSObject.global.validateAge.function!
+    /// try validateAge.throws(20)
+    /// ```
+    public var `throws`: JSThrowingFunction {
+        JSThrowingFunction(self)
+    }
+
     /// A variadic arguments version of `new`.
     public func new(_ arguments: ConvertibleToJSValue...) -> JSObject {
         new(arguments: arguments)
@@ -109,16 +128,16 @@ public class JSThrowingFunction {
                 let argv = bufferPointer.baseAddress
                 let argc = bufferPointer.count
 
-                var exceptionKind: JavaScriptValueKind = .invalid
+                var exceptionKind = JavaScriptValueKindAndFlags()
                 var exceptionPayload1 = JavaScriptPayload1()
                 var exceptionPayload2 = JavaScriptPayload2()
                 var resultObj = JavaScriptObjectRef()
                 _call_throwing_new(
                     self.base.id, argv, Int32(argc),
                     &resultObj, &exceptionKind, &exceptionPayload1, &exceptionPayload2
                 )
-                if exceptionKind != .invalid {
-                    let exception = RawJSValue(kind: exceptionKind, payload1: exceptionPayload1, payload2: exceptionPayload2)
+                if exceptionKind.isException {
+                    let exception = RawJSValue(kind: exceptionKind.kind, payload1: exceptionPayload1, payload2: exceptionPayload2)
                     return .failure(exception.jsValue())
                 }
                 return .success(JSObject(id: resultObj))

Sources/JavaScriptKit/FundamentalObjects/JSObject.swift

@@ -76,6 +76,27 @@ public class JSObject: Equatable {
         get { getJSValue(this: self, index: Int32(index)) }
         set { setJSValue(this: self, index: Int32(index), value: newValue) }
     }
+    
+    /// A modifier to call methods as throwing methods capturing `this`
+    ///
+    ///
+    /// ```javascript
+    /// const animal = {
+    ///   validateAge: function() {
+    ///     if (this.age < 0) {
+    ///       throw new Error("Invalid age");
+    ///     }
+    ///   }
+    /// }
+    /// ```
+    ///
+    /// ```swift
+    /// let animal = JSObject.global.animal.object!
+    /// try animal.throwing.validateAge!()
+    /// ```
+    public var `throwing`: JSThrowingObject {
+        JSThrowingObject(self)
+    }
 
     /// Return `true` if this value is an instance of the passed `constructor` function.
     /// - Parameter constructor: The constructor function to check.
@@ -113,3 +134,32 @@ public class JSObject: Equatable {
 extension JSObject: CustomStringConvertible {
     public var description: String { self.toString!().string! }
 }
+
+
+/// A `JSObject` wrapper that enables throwing method calls capturing `this`.
+/// Exceptions produced by JavaScript functions will be thrown as `JSValue`.
+@dynamicMemberLookup
+public class JSThrowingObject {
+    private let base: JSObject
+    public init(_ base: JSObject) {
+        self.base = base
+    }
+
+    /// Returns the `name` member method binding this object as `this` context.
+    /// - Parameter name: The name of this object's member to access.
+    /// - Returns: The `name` member method binding this object as `this` context.
+    @_disfavoredOverload
+    public subscript(_ name: String) -> ((ConvertibleToJSValue...) throws -> JSValue)? {
+        guard let function = base[name].function?.throws else { return nil }
+        return { [base] (arguments: ConvertibleToJSValue...) in
+            try function(this: base, arguments: arguments)
+        }
+    }
+
+    /// A convenience method of `subscript(_ name: String) -> ((ConvertibleToJSValue...) throws -> JSValue)?`
+    /// to access the member through Dynamic Member Lookup.
+    @_disfavoredOverload
+    public subscript(dynamicMember name: String) -> ((ConvertibleToJSValue...) throws -> JSValue)? {
+        self[name]
+    }
+}

Sources/JavaScriptKit/XcodeSupport.swift

@@ -70,7 +70,7 @@ import _CJavaScriptKit
         _: JavaScriptObjectRef,
         _: UnsafePointer<RawJSValue>!, _: Int32,
         _: UnsafeMutablePointer<JavaScriptObjectRef>!,
-        _: UnsafeMutablePointer<JavaScriptValueKind>!,
+        _: UnsafeMutablePointer<JavaScriptValueKindAndFlags>!,
         _: UnsafeMutablePointer<JavaScriptPayload1>!,
         _: UnsafeMutablePointer<JavaScriptPayload2>!
     ) { fatalError() }

Sources/_CJavaScriptKit/include/_CJavaScriptKit.h

@@ -214,7 +214,7 @@ __attribute__((__import_module__("javascript_kit"),
 extern void _call_throwing_new(const JavaScriptObjectRef ref,
                                const RawJSValue *argv, const int argc,
                                JavaScriptObjectRef *result_obj,
-                               JavaScriptValueKind *exception_kind,
+                               JavaScriptValueKindAndFlags *exception_kind,
                                JavaScriptPayload1 *exception_payload1,
                                JavaScriptPayload2 *exception_payload2);