refactor(napi): Cleanup tests (denoland#17347)

test_napi/src/array.rs

@@ -1,6 +1,8 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
-use napi_sys::Status::napi_ok;
+use crate::assert_napi_ok;
+use crate::napi_get_callback_info;
+use crate::napi_new_property;
 use napi_sys::ValueType::napi_number;
 use napi_sys::ValueType::napi_object;
 use napi_sys::*;
@@ -10,25 +12,23 @@ extern "C" fn test_array_new(
  env: napi_env,
  info: napi_callback_info,
 ) -> napi_value {
- let (args, argc, _) = crate::get_callback_info!(env, info, 1);
+ let (args, argc, _) = napi_get_callback_info!(env, info, 1);
  assert_eq!(argc, 1);
 
  let mut ty = -1;
- assert!(unsafe { napi_typeof(env, args[0], &mut ty) } == napi_ok);
+ assert_napi_ok!(napi_typeof(env, args[0], &mut ty));
  assert_eq!(ty, napi_object);
 
  let mut value: napi_value = ptr::null_mut();
- assert!(unsafe { napi_create_array(env, &mut value) } == napi_ok);
+ assert_napi_ok!(napi_create_array(env, &mut value));
 
  let mut length: u32 = 0;
- assert!(
- unsafe { napi_get_array_length(env, args[0], &mut length) } == napi_ok
- );
+ assert_napi_ok!(napi_get_array_length(env, args[0], &mut length));
 
  for i in 0..length {
  let mut e: napi_value = ptr::null_mut();
- assert!(unsafe { napi_get_element(env, args[0], i, &mut e) } == napi_ok);
- assert!(unsafe { napi_set_element(env, value, i, e) } == napi_ok);
+ assert_napi_ok!(napi_get_element(env, args[0], i, &mut e));
+ assert_napi_ok!(napi_set_element(env, value, i, e));
  }
 
  value
@@ -38,36 +38,36 @@ extern "C" fn test_array_new_with_length(
  env: napi_env,
  info: napi_callback_info,
 ) -> napi_value {
- let (args, argc, _) = crate::get_callback_info!(env, info, 1);
+ let (args, argc, _) = napi_get_callback_info!(env, info, 1);
  assert_eq!(argc, 1);
 
  let mut ty = -1;
- assert!(unsafe { napi_typeof(env, args[0], &mut ty) } == napi_ok);
+ assert_napi_ok!(napi_typeof(env, args[0], &mut ty));
  assert_eq!(ty, napi_number);
 
  let mut len: u32 = 0;
- assert!(unsafe { napi_get_value_uint32(env, args[0], &mut len) } == napi_ok);
+ assert_napi_ok!(napi_get_value_uint32(env, args[0], &mut len));
 
  let mut value: napi_value = ptr::null_mut();
- assert!(
- unsafe { napi_create_array_with_length(env, len as usize, &mut value) }
- == napi_ok
- );
+ assert_napi_ok!(napi_create_array_with_length(env, len as usize, &mut value));
 
  value
 }
 
 pub fn init(env: napi_env, exports: napi_value) {
  let properties = &[
- crate::new_property!(env, "test_array_new\0", test_array_new),
- crate::new_property!(
+ napi_new_property!(env, "test_array_new", test_array_new),
+ napi_new_property!(
  env,
- "test_array_new_with_length\0",
+ "test_array_new_with_length",
  test_array_new_with_length
  ),
  ];
 
- unsafe {
- napi_define_properties(env, exports, properties.len(), properties.as_ptr())
- };
+ assert_napi_ok!(napi_define_properties(
+ env,
+ exports,
+ properties.len(),
+ properties.as_ptr()
+ ));
 }

test_napi/src/arraybuffer.rs

@@ -1,35 +1,33 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
-use napi_sys::Status::napi_ok;
+use crate::assert_napi_ok;
+use crate::napi_get_callback_info;
+use crate::napi_new_property;
 use napi_sys::*;
 
 extern "C" fn test_detached(
  env: napi_env,
  info: napi_callback_info,
 ) -> napi_value {
- let (args, argc, _) = crate::get_callback_info!(env, info, 1);
+ let (args, argc, _) = napi_get_callback_info!(env, info, 1);
  assert_eq!(argc, 1);
 
  let mut value = false;
- assert!(
- unsafe { napi_is_detached_arraybuffer(env, args[0], &mut value) }
- == napi_ok
- );
+ assert_napi_ok!(napi_is_detached_arraybuffer(env, args[0], &mut value));
  assert!(!value);
- assert!(unsafe { napi_detach_arraybuffer(env, args[0]) } == napi_ok);
- assert!(
- unsafe { napi_is_detached_arraybuffer(env, args[0], &mut value) }
- == napi_ok
- );
+ assert_napi_ok!(napi_detach_arraybuffer(env, args[0]));
+ assert_napi_ok!(napi_is_detached_arraybuffer(env, args[0], &mut value));
  assert!(value);
  args[0]
 }
 
 pub fn init(env: napi_env, exports: napi_value) {
- let properties =
- &[crate::new_property!(env, "test_detached\0", test_detached)];
+ let properties = &[napi_new_property!(env, "test_detached", test_detached)];
 
- unsafe {
- napi_define_properties(env, exports, properties.len(), properties.as_ptr())
- };
+ assert_napi_ok!(napi_define_properties(
+ env,
+ exports,
+ properties.len(),
+ properties.as_ptr()
+ ));
 }

test_napi/src/async.rs

@@ -1,5 +1,8 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
+use crate::assert_napi_ok;
+use crate::napi_get_callback_info;
+use crate::napi_new_property;
 use napi_sys::Status::napi_ok;
 use napi_sys::ValueType::napi_function;
 use napi_sys::*;
@@ -31,82 +34,76 @@ unsafe extern "C" fn complete(
  assert!(!baton.func.is_null());
 
  let mut global: napi_value = ptr::null_mut();
- assert!(napi_get_global(env, &mut global) == napi_ok);
+ assert_napi_ok!(napi_get_global(env, &mut global));
 
  let mut callback: napi_value = ptr::null_mut();
- assert!(napi_get_reference_value(env, baton.func, &mut callback) == napi_ok);
+ assert_napi_ok!(napi_get_reference_value(env, baton.func, &mut callback));
 
  let mut _result: napi_value = ptr::null_mut();
- assert!(
- napi_call_function(env, global, callback, 0, ptr::null(), &mut _result)
- == napi_ok
- );
-
- assert!(napi_delete_reference(env, baton.func) == napi_ok);
- assert!(napi_delete_async_work(env, baton.task) == napi_ok);
+ assert_napi_ok!(napi_call_function(
+ env,
+ global,
+ callback,
+ 0,
+ ptr::null(),
+ &mut _result
+ ));
+
+ assert_napi_ok!(napi_delete_reference(env, baton.func));
+ assert_napi_ok!(napi_delete_async_work(env, baton.task));
 }
 
 extern "C" fn test_async_work(
  env: napi_env,
  info: napi_callback_info,
 ) -> napi_value {
- let (args, argc, _) = crate::get_callback_info!(env, info, 1);
+ let (args, argc, _) = napi_get_callback_info!(env, info, 1);
  assert_eq!(argc, 1);
 
  let mut ty = -1;
- assert!(unsafe { napi_typeof(env, args[0], &mut ty) } == napi_ok);
+ assert_napi_ok!(napi_typeof(env, args[0], &mut ty));
  assert_eq!(ty, napi_function);
 
  let mut resource_name: napi_value = ptr::null_mut();
- assert!(
- unsafe {
- napi_create_string_utf8(
- env,
- "test_async_resource\0".as_ptr() as *const c_char,
- usize::MAX,
- &mut resource_name,
- )
- } == napi_ok
- );
+ assert_napi_ok!(napi_create_string_utf8(
+ env,
+ "test_async_resource".as_ptr() as *const c_char,
+ usize::MAX,
+ &mut resource_name,
+ ));
 
  let mut async_work: napi_async_work = ptr::null_mut();
 
  let mut func: napi_ref = ptr::null_mut();
- assert!(
- unsafe { napi_create_reference(env, args[0], 1, &mut func) } == napi_ok
- );
+ assert_napi_ok!(napi_create_reference(env, args[0], 1, &mut func));
  let baton = Box::new(Baton {
  called: false,
  func,
  task: async_work,
  });
 
- assert!(
- unsafe {
- napi_create_async_work(
- env,
- ptr::null_mut(),
- resource_name,
- Some(execute),
- Some(complete),
- Box::into_raw(baton) as *mut c_void,
- &mut async_work,
- )
- } == napi_ok
- );
- assert!(unsafe { napi_queue_async_work(env, async_work) } == napi_ok);
+ assert_napi_ok!(napi_create_async_work(
+ env,
+ ptr::null_mut(),
+ resource_name,
+ Some(execute),
+ Some(complete),
+ Box::into_raw(baton) as *mut c_void,
+ &mut async_work,
+ ));
+ assert_napi_ok!(napi_queue_async_work(env, async_work));
 
  ptr::null_mut()
 }
 
 pub fn init(env: napi_env, exports: napi_value) {
- let properties = &[crate::new_property!(
- env,
- "test_async_work\0",
- test_async_work
- )];
+ let properties =
+ &[napi_new_property!(env, "test_async_work", test_async_work)];
 
- unsafe {
- napi_define_properties(env, exports, properties.len(), properties.as_ptr())
- };
+ assert_napi_ok!(napi_define_properties(
+ env,
+ exports,
+ properties.len(),
+ properties.as_ptr()
+ ));
 }