summaryrefslogtreecommitdiff
path: root/test_napi
diff options
context:
space:
mode:
Diffstat (limited to 'test_napi')
-rw-r--r--test_napi/bigint_test.js63
-rw-r--r--test_napi/src/bigint.rs205
-rw-r--r--test_napi/src/lib.rs2
-rw-r--r--test_napi/tests/napi_tests.rs2
4 files changed, 272 insertions, 0 deletions
diff --git a/test_napi/bigint_test.js b/test_napi/bigint_test.js
new file mode 100644
index 000000000..8d05f957d
--- /dev/null
+++ b/test_napi/bigint_test.js
@@ -0,0 +1,63 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+import { assertEquals, assertThrows, loadTestLibrary } from "./common.js";
+
+const bi = loadTestLibrary();
+
+Deno.test("cases", function () {
+ const cases = [
+ 0n,
+ -0n,
+ 1n,
+ -1n,
+ 100n,
+ 2121n,
+ -1233n,
+ 986583n,
+ -976675n,
+ 98765432213456789876546896323445679887645323232436587988766545658n,
+ -4350987086545760976737453646576078997096876957864353245245769809n,
+ ];
+
+ for (const num of cases) {
+ if (num > -(2n ** 63n) && num < 2n ** 63n) {
+ assertEquals(bi.testInt64(num), num);
+ assertEquals(bi.isLossless(num, true), true);
+ } else {
+ assertEquals(bi.isLossless(num, true), false);
+ }
+
+ if (num >= 0 && num < 2n ** 64n) {
+ assertEquals(bi.testUint64(num), num);
+ assertEquals(bi.isLossless(num, false), true);
+ } else {
+ assertEquals(bi.isLossless(num, false), false);
+ }
+
+ assertEquals(bi.testWords(num), num);
+ }
+});
+
+Deno.test(
+ // TODO(bartlomieju): fix this test
+ { ignore: true },
+ function tooBigBigInt() {
+ assertThrows(
+ () => bi.createTooBigBigInt(),
+ Error,
+ "Invalid argument",
+ );
+ },
+);
+
+Deno.test(
+ // TODO(bartlomieju): fix this test
+ { ignore: true },
+ function exceptionForwarding() {
+ assertThrows(
+ () => bi.makeBigIntWordsThrow(),
+ Error,
+ "Maximum BigInt size exceeded",
+ );
+ },
+);
diff --git a/test_napi/src/bigint.rs b/test_napi/src/bigint.rs
new file mode 100644
index 000000000..e901e342a
--- /dev/null
+++ b/test_napi/src/bigint.rs
@@ -0,0 +1,205 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+use crate::assert_napi_ok;
+use crate::cstr;
+use crate::napi_get_callback_info;
+use crate::napi_new_property;
+use napi_sys::Status::napi_pending_exception;
+use napi_sys::ValueType::napi_bigint;
+use napi_sys::*;
+use std::ptr;
+
+extern "C" fn is_lossless(
+ 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 is_signed = false;
+ assert_napi_ok!(napi_get_value_bool(env, args[1], &mut is_signed));
+
+ let mut lossless = false;
+
+ if is_signed {
+ let mut input: i64 = 0;
+ assert_napi_ok!(napi_get_value_bigint_int64(
+ env,
+ args[0],
+ &mut input,
+ &mut lossless
+ ));
+ } else {
+ let mut input: u64 = 0;
+ assert_napi_ok!(napi_get_value_bigint_uint64(
+ env,
+ args[0],
+ &mut input,
+ &mut lossless
+ ));
+ }
+
+ let mut output: napi_value = ptr::null_mut();
+ assert_napi_ok!(napi_get_boolean(env, lossless, &mut output));
+
+ output
+}
+
+extern "C" fn test_int64(
+ env: napi_env,
+ info: napi_callback_info,
+) -> napi_value {
+ let (args, _argc, _) = napi_get_callback_info!(env, info, 2);
+
+ let mut ty = -1;
+ assert_napi_ok!(napi_typeof(env, args[0], &mut ty));
+ assert_eq!(ty, napi_bigint);
+
+ let mut input: i64 = 0;
+ let mut lossless = false;
+ assert_napi_ok!(napi_get_value_bigint_int64(
+ env,
+ args[0],
+ &mut input,
+ &mut lossless
+ ));
+
+ let mut output: napi_value = ptr::null_mut();
+ assert_napi_ok!(napi_create_bigint_int64(env, input, &mut output));
+
+ output
+}
+
+extern "C" fn test_uint64(
+ env: napi_env,
+ info: napi_callback_info,
+) -> napi_value {
+ let (args, _argc, _) = napi_get_callback_info!(env, info, 2);
+
+ let mut ty = -1;
+ assert_napi_ok!(napi_typeof(env, args[0], &mut ty));
+ assert_eq!(ty, napi_bigint);
+
+ let mut input: u64 = 0;
+ let mut lossless = false;
+ assert_napi_ok!(napi_get_value_bigint_uint64(
+ env,
+ args[0],
+ &mut input,
+ &mut lossless
+ ));
+
+ let mut output: napi_value = ptr::null_mut();
+ assert_napi_ok!(napi_create_bigint_uint64(env, input, &mut output));
+
+ output
+}
+
+extern "C" fn test_words(
+ env: napi_env,
+ info: napi_callback_info,
+) -> napi_value {
+ let (args, _argc, _) = napi_get_callback_info!(env, info, 1);
+
+ let mut ty = -1;
+ assert_napi_ok!(napi_typeof(env, args[0], &mut ty));
+ assert_eq!(ty, napi_bigint);
+
+ let mut expected_work_count = 0;
+ assert_napi_ok!(napi_get_value_bigint_words(
+ env,
+ args[0],
+ ptr::null_mut(),
+ &mut expected_work_count,
+ ptr::null_mut()
+ ));
+
+ let mut sign_bit = 0;
+ let mut word_count: usize = 10;
+ let mut words: Vec<u64> = Vec::with_capacity(10);
+
+ assert_napi_ok!(napi_get_value_bigint_words(
+ env,
+ args[0],
+ &mut sign_bit,
+ &mut word_count,
+ words.as_mut_ptr(),
+ ));
+
+ assert_eq!(word_count, expected_work_count);
+ let mut output: napi_value = ptr::null_mut();
+
+ assert_napi_ok!(napi_create_bigint_words(
+ env,
+ sign_bit,
+ word_count,
+ words.as_ptr(),
+ &mut output,
+ ));
+ output
+}
+
+extern "C" fn create_too_big_big_int(
+ env: napi_env,
+ _info: napi_callback_info,
+) -> napi_value {
+ let sign_bit = 0;
+ let word_count = usize::MAX;
+ let words: Vec<u64> = Vec::with_capacity(10);
+
+ let mut output: napi_value = ptr::null_mut();
+ let result = unsafe {
+ napi_create_bigint_words(
+ env,
+ sign_bit,
+ word_count,
+ words.as_ptr(),
+ &mut output,
+ )
+ };
+ assert_eq!(result, 1);
+
+ output
+}
+
+extern "C" fn make_big_int_words_throw(
+ env: napi_env,
+ _info: napi_callback_info,
+) -> napi_value {
+ let words: Vec<u64> = Vec::with_capacity(10);
+ let mut output = ptr::null_mut();
+
+ let status = unsafe {
+ napi_create_bigint_words(env, 0, usize::MAX, words.as_ptr(), &mut output)
+ };
+
+ if status != napi_pending_exception {
+ unsafe {
+ napi_throw_error(
+ env,
+ ptr::null_mut(),
+ cstr!("Expected status 'napi_pending_exception'"),
+ )
+ };
+ }
+
+ ptr::null_mut()
+}
+
+pub fn init(env: napi_env, exports: napi_value) {
+ let properties = &[
+ napi_new_property!(env, "isLossless", is_lossless),
+ napi_new_property!(env, "testInt64", test_int64),
+ napi_new_property!(env, "testUint64", test_uint64),
+ napi_new_property!(env, "testWords", test_words),
+ napi_new_property!(env, "createTooBigBigInt", create_too_big_big_int),
+ napi_new_property!(env, "makeBigIntWordsThrow", make_big_int_words_throw),
+ ];
+
+ assert_napi_ok!(napi_define_properties(
+ env,
+ exports,
+ properties.len(),
+ properties.as_ptr()
+ ));
+}
diff --git a/test_napi/src/lib.rs b/test_napi/src/lib.rs
index dba9f65a5..a5a9866ce 100644
--- a/test_napi/src/lib.rs
+++ b/test_napi/src/lib.rs
@@ -9,6 +9,7 @@ use napi_sys::*;
pub mod array;
pub mod arraybuffer;
pub mod r#async;
+pub mod bigint;
pub mod callback;
pub mod coerce;
pub mod date;
@@ -156,6 +157,7 @@ unsafe extern "C" fn napi_register_module_v1(
date::init(env, exports);
tsfn::init(env, exports);
mem::init(env, exports);
+ bigint::init(env, exports);
init_cleanup_hook(env, exports);
diff --git a/test_napi/tests/napi_tests.rs b/test_napi/tests/napi_tests.rs
index 747f6aa27..3e3989436 100644
--- a/test_napi/tests/napi_tests.rs
+++ b/test_napi/tests/napi_tests.rs
@@ -26,6 +26,7 @@ fn napi_tests() {
let output = deno_cmd()
.current_dir(test_util::napi_tests_path())
+ .env("RUST_BACKTRACE", "1")
.arg("test")
.arg("--allow-read")
.arg("--allow-env")
@@ -39,6 +40,7 @@ fn napi_tests() {
let stderr = std::str::from_utf8(&output.stderr).unwrap();
if !output.status.success() {
+ eprintln!("exit code {:?}", output.status.code());
println!("stdout {stdout}");
println!("stderr {stderr}");
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-25 09:09:24 +0000