[Tests] Split to independent executables

Author: tonyfreeman

Package.swift

@@ -17,14 +17,30 @@ let package = Package(
             dependencies: []),
         .target(
             name: "V8",
-            dependencies: ["CV8", "Platform", "JavaScript"]),
-        .testTarget(
-            name: "V8Tests",
-            dependencies: ["Test", "V8"]),
+            dependencies: ["CV8", "Platform", "JavaScript"])
     ],
     cxxLanguageStandard: .cxx11
 )
 
+// MARK: - tests
+
+testTarget("V8") { test in
+    test("JavaScript")
+    test("JSValue")
+}
+
+func testTarget(_ target: String, task: ((String) -> Void) -> Void) {
+    task { test in addTest(target: target, name: test) }
+}
+
+func addTest(target: String, name: String) {
+    package.targets.append(
+        .executableTarget(
+            name: "Tests/\(target)/\(name)",
+            dependencies: ["Test", "V8"],
+            path: "Tests/\(target)/\(name)"))
+}
+
 // MARK: - custom package source
 
 #if canImport(ObjectiveC)

Tests/LinuxMain.swift

@@ -0,0 +1,85 @@
+import Test
+@testable import V8
+
+test.case("isUndefined") {
+    let context = JSContext()
+
+    let result = try context.evaluate("undefined")
+    expect(result.isUndefined)
+    expect(!result.isNull)
+    expect(!result.isBool)
+    expect(!result.isNumber)
+    expect(!result.isString)
+    expect(try result.toString() == "undefined")
+}
+
+test.case("isNull") {
+    let context = JSContext()
+    let result = try context.evaluate("null")
+    expect(!result.isUndefined)
+    expect(result.isNull)
+    expect(!result.isBool)
+    expect(!result.isNumber)
+    expect(!result.isString)
+    expect(try result.toString() == "null")
+}
+
+test.case("isBool") {
+    let context = JSContext()
+    let result = try context.evaluate("true")
+    expect(!result.isUndefined)
+    expect(!result.isNull)
+    expect(result.isBool)
+    expect(!result.isNumber)
+    expect(!result.isString)
+    expect(try result.toString() == "true")
+    // expect(result.toBool(), true)
+}
+
+test.case("isNumber") {
+    let context = JSContext()
+    let result = try context.evaluate("3.14")
+    expect(!result.isUndefined)
+    expect(!result.isNull)
+    expect(!result.isBool)
+    expect(result.isNumber)
+    expect(!result.isString)
+    expect(try result.toString() == "3.14")
+    // expect(try result.toDouble(), 3.14)
+}
+
+test.case("isString") {
+    let context = JSContext()
+    let result = try context.evaluate("'success'")
+    expect(!result.isUndefined)
+    expect(!result.isNull)
+    expect(!result.isBool)
+    expect(!result.isNumber)
+    expect(result.isString)
+    expect(try result.toString() == "success")
+}
+
+test.case("toInt()") {
+    let context = JSContext()
+    let result = try context.evaluate("40 + 2")
+    expect(try result.toInt() == 42)
+}
+
+test.case("toString()") {
+    let context = JSContext()
+    let result = try context.evaluate("40 + 2")
+    expect(try result.toString() == "42")
+}
+
+test.case("property") {
+    let context = JSContext()
+    let result = try context.evaluate("""
+        (function(){
+            return { property: 'test' }
+        })()
+        """)
+
+    expect(try result["property"]?.toString() == "test")
+}
+
+test.run()

Tests/V8/JSValue/main.swift

@@ -0,0 +1,111 @@
+import Test
+@testable import V8
+
+test.case("evaluate") {
+    let context = JSContext()
+    _ = try context.evaluate("40 + 2")
+}
+
+test.case("exception") {
+    let context = JSContext()
+    expect(throws: JSError("ReferenceError: x is not defined")) {
+        try context.evaluate("x()")
+    }
+    expect(throws: JSError("SyntaxError: Unexpected end of input")) {
+        try context.evaluate("{")
+    }
+}
+
+test.case("function") {
+    let context = JSContext()
+    try context.createFunction(name: "test") { (_) -> Value in
+        return .string("success")
+    }
+    let result = try context.evaluate("test()")
+    expect(try result.toString() == "success")
+}
+
+test.case("closure") {
+    let context = JSContext()
+
+    try context.createFunction(name: "testUndefined") {
+        return .undefined
+    }
+    let undefinedResult = try context.evaluate("testUndefined()")
+    expect(undefinedResult.isUndefined)
+
+    try context.createFunction(name: "testNull") {
+        return .null
+    }
+    let nullResult = try context.evaluate("testNull()")
+    expect(nullResult.isNull)
+
+    try context.createFunction(name: "testBool") {
+        return .bool(true)
+    }
+    let boolResult = try context.evaluate("testBool()")
+    expect(boolResult.isBool)
+
+    try context.createFunction(name: "testNumber") {
+        return .number(3.14)
+    }
+    let numberResult = try context.evaluate("testNumber()")
+    expect(numberResult.isNumber)
+
+    try context.createFunction(name: "testString") {
+        return .string("success")
+    }
+    let stringResult = try context.evaluate("testString()")
+    expect(stringResult.isString)
+}
+
+test.case("capture") {
+    let context = JSContext()
+
+    var captured = false
+    try context.createFunction(name: "test") { (_) -> Value in
+        captured = true
+        return .string("captured")
+    }
+    let result = try context.evaluate("test()")
+    expect(captured)
+    expect("\(result)" == "captured")
+}
+
+test.case("arguments") {
+    let context = JSContext()
+    try context.createFunction(name: "test") { (arguments) -> Void in
+        expect(arguments.count == 2)
+        expect(try arguments.first?.toString() == "one")
+        expect(try arguments.last?.toInt() == 42)
+    }
+    try context.evaluate("test('one', 42)")
+}
+
+test.case("persistent context") {
+    let context = JSContext()
+    try context.evaluate("result = 'success'")
+    expect(try context.evaluate("result").toString() == "success")
+
+    try context.createFunction(name: "test") { (arguments) -> Value in
+        return .string("test ok")
+    }
+
+    expect(try context.evaluate("result").toString() == "success")
+}
+
+test.case("sandbox") {
+    try {
+        let context = JSContext()
+        try context.evaluate("test = 'hello'")
+        let result = try context.evaluate("test")
+        expect(try result.toString() ==  "hello")
+    }()
+
+    let context = JSContext()
+    expect(throws: JSError("test is not defined")) {
+        try context.evaluate("test")
+    }
+}
+
+test.run()