Migrate test fixtures to wrapper APIs

node-test/napi-compat-mode/src/array.zig

@@ -1,32 +1,22 @@
 const napi = @import("napi");
-const c = napi.napi_sys.napi_sys;
 
 pub fn testCreateArray(env: napi.Env) !napi.Array {
     return try napi.Array.Create(env);
 }
 
-pub fn testCreateArrayWithLength(env: napi.Env, len: u32) !c.napi_value {
-    var raw: c.napi_value = undefined;
-    const status = c.napi_create_array_with_length(env.raw, len, &raw);
-    if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
-    return raw;
+pub fn testCreateArrayWithLength(env: napi.Env, len: u32) !napi.Array {
+    return try napi.Array.CreateWithLength(env, len);
 }
 
 pub fn testSetElement(array: napi.Array, index: u32, value: napi.Object) !void {
-    const status = c.napi_set_element(array.env, array.raw, index, value.raw);
-    if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
+    var mutable_array = array;
+    try mutable_array.Set(index, value);
 }
 
 pub fn testHasElement(array: napi.Array, index: u32) !bool {
-    var result = false;
-    const status = c.napi_has_element(array.env, array.raw, index, &result);
-    if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
-    return result;
+    return try array.HasElement(index);
 }
 
 pub fn testDeleteElement(array: napi.Array, index: u32) !bool {
-    var result = false;
-    const status = c.napi_delete_element(array.env, array.raw, index, &result);
-    if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
-    return result;
+    return try array.DeleteElement(index);
 }

node-test/napi-compat-mode/src/either.zig

@@ -1,18 +1,14 @@
 const napi = @import("napi");
-const c = napi.napi_sys.napi_sys;
 
 const NumberOrString = union(enum) {
     number: i32,
     string: []const u8,
 };
 
-pub fn eitherNumberString(env: napi.Env, value: NumberOrString) !c.napi_value {
+pub fn eitherNumberString(env: napi.Env, value: NumberOrString) !napi.NapiValue {
     switch (value) {
         .number => |number| {
-            var raw: c.napi_value = undefined;
-            const status = c.napi_create_int32(env.raw, number + 100, &raw);
-            if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
-            return raw;
+            return napi.NapiValue.from_raw(env.raw, napi.Number.New(env, number + 100).raw);
         },
         .string => |string| {
             const prefix = "Either::B(";
@@ -25,10 +21,7 @@ pub fn eitherNumberString(env: napi.Env, value: NumberOrString) !c.napi_value {
             @memcpy(out[prefix.len .. prefix.len + string.len], string);
             @memcpy(out[prefix.len + string.len ..], suffix);
 
-            var raw: c.napi_value = undefined;
-            const status = c.napi_create_string_utf8(env.raw, out.ptr, out.len, &raw);
-            if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
-            return raw;
+            return napi.NapiValue.from_raw(env.raw, napi.String.New(env, out).raw);
         },
     }
 }

node-test/napi-compat-mode/src/function.zig

@@ -1,5 +1,4 @@
 const napi = @import("napi");
-const c = napi.napi_sys.napi_sys;
 
 pub fn testCallFunction(callback: napi.Function(struct { []const u8, []const u8 }, napi.Undefined)) !void {
     _ = try callback.Call(.{ "hello", "world" });
@@ -10,20 +9,14 @@ pub fn testCallFunctionWithRefArguments(callback: napi.Function(struct { []const
 }
 
 pub fn testCallFunctionError(callback: napi.Function(struct {}, napi.Undefined), error_callback: napi.Function([]const u8, napi.Undefined)) void {
-    var undefined_value: c.napi_value = undefined;
-    _ = c.napi_get_undefined(callback.env, &undefined_value);
-
-    var result: c.napi_value = undefined;
-    const call_status = c.napi_call_function(callback.env, undefined_value, callback.raw, 0, null, &result);
-    if (call_status != c.napi_ok) {
-        var pending = false;
-        _ = c.napi_is_exception_pending(callback.env, &pending);
-        if (pending) {
-            var exception: c.napi_value = undefined;
-            _ = c.napi_get_and_clear_last_exception(callback.env, &exception);
+    const env = napi.Env.from_raw(callback.env);
+    _ = callback.Call(.{}) catch {
+        if (env.isExceptionPending()) {
+            _ = env.getAndClearLastException() catch {};
         }
         _ = error_callback.Call("Testing") catch return;
-    }
+        return;
+    };
 }
 
 fn argumentsLength(_: i32) []const u8 {

node-test/napi-compat-mode/src/napi5/date.zig

@@ -1,5 +1,4 @@
 const napi = @import("napi");
-const c = napi.napi_sys.napi_sys;
 
 const DateCandidate = union(enum) {
     number: i32,
@@ -9,24 +8,14 @@ const DateCandidate = union(enum) {
 pub fn isDate(value: DateCandidate) bool {
     return switch (value) {
         .number => false,
-        .object => |object| blk: {
-            var result = false;
-            _ = c.napi_is_date(object.env, object.raw, &result);
-            break :blk result;
-        },
+        .object => |object| object.isDate(),
     };
 }
 
-pub fn createDate(env: napi.Env, value: f64) !c.napi_value {
-    var raw: c.napi_value = undefined;
-    const status = c.napi_create_date(env.raw, value, &raw);
-    if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
-    return raw;
+pub fn createDate(env: napi.Env, value: f64) !napi.Object {
+    return try env.createDate(value);
 }
 
 pub fn getDateValue(value: napi.Object) !f64 {
-    var result: f64 = 0;
-    const status = c.napi_get_date_value(value.env, value.raw, &result);
-    if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
-    return result;
+    return try value.dateValue();
 }

node-test/napi-compat-mode/src/napi7/arraybuffer.zig

@@ -1,14 +1,9 @@
 const napi = @import("napi");
-const c = napi.napi_sys.napi_sys;
 
 pub fn detachArrayBuffer(buffer: napi.ArrayBuffer) !void {
-    const status = c.napi_detach_arraybuffer(buffer.env, buffer.raw);
-    if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
+    try buffer.detach();
 }
 
 pub fn isDetachedArrayBuffer(buffer: napi.ArrayBuffer) !bool {
-    var result = false;
-    const status = c.napi_is_detached_arraybuffer(buffer.env, buffer.raw, &result);
-    if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
-    return result;
+    return try buffer.isDetached();
 }

node-test/napi-compat-mode/src/napi8/object.zig

@@ -1,14 +1,9 @@
 const napi = @import("napi");
-const c = napi.napi_sys.napi_sys;
 
-pub fn freezeObject(object: napi.Object) !c.napi_value {
-    const status = c.napi_object_freeze(object.env, object.raw);
-    if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
-    return object.raw;
+pub fn freezeObject(object: napi.Object) !napi.Object {
+    return try object.freeze();
 }
 
-pub fn sealObject(object: napi.Object) !c.napi_value {
-    const status = c.napi_object_seal(object.env, object.raw);
-    if (status != c.napi_ok) return napi.Error.fromStatus(napi.Status.New(status));
-    return object.raw;
+pub fn sealObject(object: napi.Object) !napi.Object {
+    return try object.seal();
 }

node-test/napi-compat-mode/src/napi_version.zig

@@ -1,8 +1,5 @@
 const napi = @import("napi");
-const c = napi.napi_sys.napi_sys;
 
 pub fn getNapiVersion(env: napi.Env) u32 {
-    var result: u32 = 0;
-    _ = c.napi_get_version(env.raw, &result);
-    return result;
+    return env.getNapiVersion();
 }

node-test/napi/src/values.zig

@@ -66,12 +66,6 @@ fn allocator() std.mem.Allocator {
     return napi.globalAllocator();
 }
 
-fn check(status: c.napi_status) !void {
-    if (status != c.napi_ok) {
-        return napi.Error.fromStatus(napi.Status.New(status));
-    }
-}
-
 fn concatRustString(input: []const u8) ![]u8 {
     return try std.fmt.allocPrint(allocator(), "{s} + Rust 🦀 string!", .{input});
 }
@@ -109,9 +103,7 @@ fn copyAs(comptime Dst: type, input: anytype) ![]Dst {
 }
 
 pub fn getNapiVersion(env: napi.Env) u32 {
-    var result: u32 = 0;
-    _ = c.napi_get_version(env.raw, &result);
-    return result;
+    return env.getNapiVersion();
 }
 
 pub fn add(left: i32, right: i32) i32 {
@@ -184,20 +176,20 @@ pub fn translatePoint(point: Point, dx: i32, dy: i32) Point {
     };
 }
 
-pub fn getMapping(env: napi.Env) !c.napi_value {
+pub fn getMapping(env: napi.Env) !napi.Object {
     const object = try napi.Object.Create(env);
     try object.Set("a", @as(i32, 101));
     try object.Set("b", @as(i32, 102));
     try object.Set("\x00c", @as(i32, 103));
-    return object.raw;
+    return object;
 }
 
 pub fn sumMapping(object: napi.Object) i32 {
     return object.Get("a", i32) + object.Get("b", i32) + object.Get("\x00c", i32);
 }
 
-pub fn indexmapPassthrough(object: napi.Object) c.napi_value {
-    return object.raw;
+pub fn indexmapPassthrough(object: napi.Object) napi.Object {
+    return object;
 }
 
 pub fn createNativeWrap(env: napi.Env, value: u32) !napi.Object {
@@ -279,16 +271,12 @@ pub fn createObj() Point {
     return .{ .x = 1, .y = 2 };
 }
 
-pub fn listObjKeys(env: napi.Env, object: napi.Object) !c.napi_value {
-    var raw: c.napi_value = undefined;
-    try check(c.napi_get_property_names(env.raw, object.raw, &raw));
-    return raw;
+pub fn listObjKeys(_: napi.Env, object: napi.Object) !napi.Array {
+    return try object.propertyNames();
 }
 
-pub fn getGlobal(env: napi.Env) !c.napi_value {
-    var raw: c.napi_value = undefined;
-    try check(c.napi_get_global(env.raw, &raw));
-    return raw;
+pub fn getGlobal(env: napi.Env) !napi.Object {
+    return try env.getGlobal();
 }
 
 pub fn getUndefined(env: napi.Env) napi.Undefined {
@@ -307,20 +295,14 @@ pub fn returnNull(env: napi.Env) napi.Null {
     return env.getNull();
 }
 
-pub fn createSymbol(env: napi.Env, description: []const u8) !c.napi_value {
-    const desc = napi.String.New(env, description);
-    var symbol: c.napi_value = undefined;
-    try check(c.napi_create_symbol(env.raw, desc.raw, &symbol));
-    return symbol;
+pub fn createSymbol(env: napi.Env, description: []const u8) !napi.NapiValue {
+    return try env.createSymbol(description);
 }
 
-pub fn setSymbolInObj(env: napi.Env, object: napi.Object) !c.napi_value {
-    const desc = napi.String.New(env, "native");
-    var symbol: c.napi_value = undefined;
-    try check(c.napi_create_symbol(env.raw, desc.raw, &symbol));
-    const value = napi.String.New(env, "symbol-value");
-    try check(c.napi_set_property(env.raw, object.raw, symbol, value.raw));
-    return object.raw;
+pub fn setSymbolInObj(env: napi.Env, object: napi.Object) !napi.Object {
+    const symbol = try env.createSymbol("native");
+    try object.SetValue(symbol, "symbol-value");
+    return object;
 }
 
 pub fn throwError() !void {
@@ -388,8 +370,8 @@ pub fn appendBuffer(env: napi.Env, input: napi.Buffer) !napi.Buffer {
     return try napi.Buffer.copy(env, out);
 }
 
-pub fn bufferPassThrough(input: napi.Buffer) c.napi_value {
-    return input.raw;
+pub fn bufferPassThrough(input: napi.Buffer) napi.Buffer {
+    return input;
 }
 
 pub fn createArraybuffer(env: napi.Env, len: u32) !napi.ArrayBuffer {
@@ -404,8 +386,8 @@ pub fn acceptArraybuffer(input: napi.ArrayBuffer) usize {
     return input.length();
 }
 
-pub fn arrayBufferPassThrough(input: napi.ArrayBuffer) c.napi_value {
-    return input.raw;
+pub fn arrayBufferPassThrough(input: napi.ArrayBuffer) napi.ArrayBuffer {
+    return input;
 }
 
 pub fn getBufferSlice(env: napi.Env, input: napi.Buffer, start: u32, end: u32) !napi.Buffer {
@@ -499,13 +481,11 @@ pub fn mutateArraybuffer(input: napi.ArrayBuffer) void {
     }
 }
 
-pub fn createUint8ClampedArrayFromData(env: napi.Env) !c.napi_value {
+pub fn createUint8ClampedArrayFromData(env: napi.Env) !napi.Uint8ClampedArray {
     var arraybuffer = try napi.ArrayBuffer.New(env, 3);
     @memcpy(arraybuffer.asSlice(), &[_]u8{ 1, 2, 255 });
 
-    var raw: c.napi_value = undefined;
-    try check(c.napi_create_typedarray(env.raw, c.napi_uint8_clamped_array, 3, arraybuffer.raw, 0, &raw));
-    return raw;
+    return try napi.Uint8ClampedArray.fromArrayBuffer(env, arraybuffer, 3, 0);
 }
 
 pub fn arrayBufferFromData(env: napi.Env) !napi.ArrayBuffer {
@@ -588,17 +568,13 @@ pub fn bigintFromI128(env: napi.Env) napi.BigInt {
     return napi.BigInt.New(env, @as(i128, -100));
 }
 
-pub fn eitherStringOrNumber(env: napi.Env, value: NumberOrString) !c.napi_value {
+pub fn eitherStringOrNumber(env: napi.Env, value: NumberOrString) !napi.NapiValue {
     switch (value) {
         .number => |number| {
-            var raw: c.napi_value = undefined;
-            try check(c.napi_create_int32(env.raw, number + 100, &raw));
-            return raw;
+            return napi.NapiValue.from_raw(env.raw, napi.Number.New(env, number + 100).raw);
         },
         .string => |string| {
-            var raw: c.napi_value = undefined;
-            try check(c.napi_create_string_utf8(env.raw, string.ptr, string.len, &raw));
-            return raw;
+            return napi.NapiValue.from_raw(env.raw, napi.String.New(env, string).raw);
         },
     }
 }
@@ -662,6 +638,7 @@ pub fn createMisalignedExternal(env: napi.Env) !c.napi_value {
 
     const byte_ptr: [*]u8 = @ptrCast(storage.ptr);
     var raw: c.napi_value = undefined;
+    // Intentionally bypass zig-napi to create a foreign misaligned external for negative tests.
     const status = c.napi_create_external(
         env.raw,
         @ptrCast(byte_ptr + 1),