diff options
| -rw-r--r-- | cli/napi/js_native_api.rs | 69 | ||||
| -rw-r--r-- | test_napi/src/typedarray.rs | 113 | ||||
| -rw-r--r-- | test_napi/typedarray_test.js | 26 |
3 files changed, 190 insertions, 18 deletions
diff --git a/cli/napi/js_native_api.rs b/cli/napi/js_native_api.rs index f58bd3004..c2f3a1122 100644 --- a/cli/napi/js_native_api.rs +++ b/cli/napi/js_native_api.rs @@ -1375,7 +1375,9 @@ fn napi_get_arraybuffer_info( if !data.is_null() { *data = get_array_buffer_ptr(buf); } - *length = buf.byte_length(); + if !length.is_null() { + *length = buf.byte_length(); + } Ok(()) } @@ -1409,7 +1411,9 @@ fn napi_get_buffer_info( if !data.is_null() { *data = get_array_buffer_ptr(abuf); } - *length = abuf.byte_length(); + if !length.is_null() { + *length = abuf.byte_length(); + } Ok(()) } @@ -1649,22 +1653,59 @@ fn napi_get_reference_value( #[napi_sym::napi_sym] fn napi_get_typedarray_info( env: *mut Env, - value: napi_value, - data: *mut *mut u8, + typedarray: napi_value, + type_: *mut napi_typedarray_type, length: *mut usize, + data: *mut *mut c_void, + arraybuffer: *mut napi_value, + byte_offset: *mut usize, ) -> Result { let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?; - let value = transmute::<napi_value, v8::Local<v8::Value>>(value); - let buf = v8::Local::<v8::TypedArray>::try_from(value).unwrap(); - let buffer_name = v8::String::new(&mut env.scope(), "buffer").unwrap(); - let abuf = v8::Local::<v8::ArrayBuffer>::try_from( - buf.get(&mut env.scope(), buffer_name.into()).unwrap(), - ) - .unwrap(); - if !data.is_null() { - *data = get_array_buffer_ptr(abuf); + let value = transmute::<napi_value, v8::Local<v8::Value>>(typedarray); + let array = v8::Local::<v8::TypedArray>::try_from(value) + .ok() + .ok_or(Error::InvalidArg)?; + + if !type_.is_null() { + if value.is_int8_array() { + *type_ = napi_int8_array; + } else if value.is_uint8_array() { + *type_ = napi_uint8_array; + } else if value.is_uint8_clamped_array() { + *type_ = napi_uint8_clamped_array; + } else if value.is_int16_array() { + *type_ = napi_int16_array; + } else if value.is_uint16_array() { + *type_ = napi_uint16_array; + } else if value.is_int32_array() { + *type_ = napi_int32_array; + } else if value.is_uint32_array() { + *type_ = napi_uint32_array; + } else if value.is_float32_array() { + *type_ = napi_float32_array; + } else if value.is_float64_array() { + *type_ = napi_float64_array; + } } - *length = abuf.byte_length(); + + if !length.is_null() { + *length = array.length(); + } + + if !data.is_null() || !arraybuffer.is_null() { + let buf = array.buffer(&mut env.scope()).unwrap(); + if !data.is_null() { + *data = get_array_buffer_ptr(buf) as *mut c_void; + } + if !arraybuffer.is_null() { + *arraybuffer = buf.into(); + } + } + + if !byte_offset.is_null() { + *byte_offset = array.byte_offset(); + } + Ok(()) } diff --git a/test_napi/src/typedarray.rs b/test_napi/src/typedarray.rs index 034757dd0..fed63773e 100644 --- a/test_napi/src/typedarray.rs +++ b/test_napi/src/typedarray.rs @@ -1,12 +1,116 @@ // 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 core::ffi::c_void; -use napi_sys::TypedarrayType::uint8_array; +use napi_sys::Status::napi_ok; +use napi_sys::TypedarrayType; +use napi_sys::ValueType::napi_number; +use napi_sys::ValueType::napi_object; use napi_sys::*; use std::ptr; +extern "C" fn test_multiply( + env: napi_env, + info: napi_callback_info, +) -> napi_value { + let (args, argc, _) = napi_get_callback_info!(env, info, 2); + assert_eq!(argc, 2); + + let mut ty = -1; + assert_napi_ok!(napi_typeof(env, args[0], &mut ty)); + assert_eq!(ty, napi_object); + + let input_array = args[0]; + let mut is_typed_array = false; + assert!( + unsafe { napi_is_typedarray(env, input_array, &mut is_typed_array) } + == napi_ok + ); + + let mut ty = -1; + assert_napi_ok!(napi_typeof(env, args[1], &mut ty)); + assert_eq!(ty, napi_number); + + let mut multiplier: f64 = 0.0; + assert_napi_ok!(napi_get_value_double(env, args[1], &mut multiplier)); + + let mut ty = -1; + let mut input_buffer = ptr::null_mut(); + let mut byte_offset = 0; + let mut length = 0; + + assert_napi_ok!(napi_get_typedarray_info( + env, + input_array, + &mut ty, + &mut length, + ptr::null_mut(), + &mut input_buffer, + &mut byte_offset, + )); + + let mut data = ptr::null_mut(); + let mut byte_length = 0; + + assert_napi_ok!(napi_get_arraybuffer_info( + env, + input_buffer, + &mut data, + &mut byte_length + )); + + let mut output_buffer = ptr::null_mut(); + let mut output_ptr = ptr::null_mut(); + assert_napi_ok!(napi_create_arraybuffer( + env, + byte_length, + &mut output_ptr, + &mut output_buffer, + )); + + let mut output_array: napi_value = ptr::null_mut(); + assert_napi_ok!(napi_create_typedarray( + env, + ty, + length, + output_buffer, + byte_offset, + &mut output_array, + )); + + if ty == TypedarrayType::uint8_array { + let input_bytes = unsafe { (data as *mut u8).offset(byte_offset as isize) }; + let output_bytes = output_ptr as *mut u8; + for i in 0..length { + unsafe { + *output_bytes.offset(i as isize) = + (*input_bytes.offset(i as isize) as f64 * multiplier) as u8; + } + } + } else if ty == TypedarrayType::float64_array { + let input_doubles = + unsafe { (data as *mut f64).offset(byte_offset as isize) }; + let output_doubles = output_ptr as *mut f64; + for i in 0..length { + unsafe { + *output_doubles.offset(i as isize) = + *input_doubles.offset(i as isize) * multiplier; + } + } + } else { + assert_napi_ok!(napi_throw_error( + env, + ptr::null(), + "Typed array was of a type not expected by test.".as_ptr() as *const i8, + )); + return ptr::null_mut(); + } + + output_array +} + extern "C" fn test_external( env: napi_env, _info: napi_callback_info, @@ -25,7 +129,7 @@ extern "C" fn test_external( let mut typedarray: napi_value = ptr::null_mut(); assert_napi_ok!(napi_create_typedarray( env, - uint8_array, + TypedarrayType::uint8_array, external.len(), arraybuffer, 0, @@ -37,7 +141,10 @@ extern "C" fn test_external( } pub fn init(env: napi_env, exports: napi_value) { - let properties = &[napi_new_property!(env, "test_external", test_external)]; + let properties = &[ + napi_new_property!(env, "test_external", test_external), + napi_new_property!(env, "test_multiply", test_multiply), + ]; assert_napi_ok!(napi_define_properties( env, diff --git a/test_napi/typedarray_test.js b/test_napi/typedarray_test.js index 3cd084dc8..f9b346626 100644 --- a/test_napi/typedarray_test.js +++ b/test_napi/typedarray_test.js @@ -1,9 +1,33 @@ // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. -import { assertEquals, loadTestLibrary } from "./common.js"; +import { assert, assertEquals, loadTestLibrary } from "./common.js"; const typedarray = loadTestLibrary(); +Deno.test("napi typedarray uint8", function () { + const byteArray = new Uint8Array([0, 1, 2]); + assertEquals(byteArray.length, 3); + + const byteResult = typedarray.test_multiply(byteArray, 3); + assert(byteResult instanceof Uint8Array); + assertEquals(byteResult.length, 3); + assertEquals(byteResult[0], 0); + assertEquals(byteResult[1], 3); + assertEquals(byteResult[2], 6); +}); + +Deno.test("napi typedarray float64", function () { + const doubleArray = new Float64Array([0.0, 1.1, 2.2]); + assertEquals(doubleArray.length, 3); + + const doubleResult = typedarray.test_multiply(doubleArray, -3); + assert(doubleResult instanceof Float64Array); + assertEquals(doubleResult.length, 3); + assertEquals(doubleResult[0], -0); + assertEquals(Math.round(10 * doubleResult[1]) / 10, -3.3); + assertEquals(Math.round(10 * doubleResult[2]) / 10, -6.6); +}); + Deno.test("napi typedarray external", function () { assertEquals( new Uint8Array(typedarray.test_external()), |