Skip to content

X
Xts Acts

OpenHarmony / Xts Acts
接近 2 年 前同步成功

通知 9
Star 22
Fork 0
X
Xts Acts
提交 0d5d5b9f 编写于 作者: H huangzhenghua
浏览文件
操作

cherry pick napi test cast to 3.2 release 

cherry pick pr list :
https: //gitee.com/openharmony/xts_acts/pulls/7761
https: //gitee.com/openharmony/xts_acts/pulls/7877
https: //gitee.com/openharmony/xts_acts/pulls/8005
issue: https://gitee.com/openharmony/arkui_napi/issues/I6P19GSigned-off-by: Nhuangzhenghua <huangzhenghua3@huawei.com>
Change-Id: Id8e5d8a688933150365842a72baf7bf798193baa
上级 ab5a9fcb
隐藏空白更改
内联 并排
Showing with 2298 addition and 1606 deletion
arkui/ace_napi_test/entry/src/main/cpp/napi/napi_test.cpp
浏览文件 @ 0d5d5b9f
...@@ -21,19 +21,19 @@ ...@@ -21,19 +21,19 @@
#include <vector> #include <vector>
#include <malloc.h> #include <malloc.h>
#include <ctime> #include <ctime>
#include <thread>
#include <uv.h> #include <uv.h>
static bool exceptionWasPending = false;
static napi_ref test_reference = NULL; static napi_ref test_reference = NULL;
static int test_value = 1; const int TAG_NUMBER = 666;
static napi_deferred deferred = NULL;
static void add_returned_status(napi_env env, static void add_returned_status(napi_env env,
const char* key, const char* key,
napi_value object, napi_value object,
const char* expected_message, const char* expected_message,
napi_status expected_status, napi_status expected_status,
napi_status actual_status) { napi_status actual_status)
{
char napi_message_string[100] = ""; char napi_message_string[100] = "";
napi_value prop_value; napi_value prop_value;
...@@ -55,7 +55,8 @@ static void add_returned_status(napi_env env, ...@@ -55,7 +55,8 @@ static void add_returned_status(napi_env env,
prop_value)); prop_value));
} }
static void add_last_status(napi_env env, const char* key, napi_value return_value) { static void add_last_status(napi_env env, const char* key, napi_value return_value)
{
napi_value prop_value; napi_value prop_value;
const napi_extended_error_info* p_last_error; const napi_extended_error_info* p_last_error;
NAPI_CALL_RETURN_VOID(env, napi_get_last_error_info(env, &p_last_error)); NAPI_CALL_RETURN_VOID(env, napi_get_last_error_info(env, &p_last_error));
...@@ -73,7 +74,8 @@ static void add_last_status(napi_env env, const char* key, napi_value return_val ...@@ -73,7 +74,8 @@ static void add_last_status(napi_env env, const char* key, napi_value return_val
prop_value)); prop_value));
} }
static napi_value getLastErrorInfo(napi_env env, napi_callback_info info) { static napi_value getLastErrorInfo(napi_env env, napi_callback_info info)
{
napi_value value; napi_value value;
NAPI_CALL(env, napi_create_string_utf8(env, "xyz", 3, &value)); NAPI_CALL(env, napi_create_string_utf8(env, "xyz", 3, &value));
double double_value; double double_value;
...@@ -86,10 +88,13 @@ static napi_value getLastErrorInfo(napi_env env, napi_callback_info info) { ...@@ -86,10 +88,13 @@ static napi_value getLastErrorInfo(napi_env env, napi_callback_info info) {
"Last error info code should match last status"); "Last error info code should match last status");
NAPI_ASSERT(env, error_info->error_message, NAPI_ASSERT(env, error_info->error_message,
"Last error info message should not be null"); "Last error info message should not be null");
return NULL; napi_value _value;
NAPI_CALL(env, napi_create_int32(env, error_info->error_code, &_value));
return _value;
} }
static napi_value cleanUpErrorInfo(napi_env env, napi_callback_info info) { static napi_value cleanUpErrorInfo(napi_env env, napi_callback_info info)
{
const napi_extended_error_info * error_info = 0; const napi_extended_error_info * error_info = 0;
NAPI_CALL(env, napi_get_last_error_info(env, &error_info)); NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
...@@ -100,31 +105,84 @@ static napi_value cleanUpErrorInfo(napi_env env, napi_callback_info info) { ...@@ -100,31 +105,84 @@ static napi_value cleanUpErrorInfo(napi_env env, napi_callback_info info) {
return result; return result;
} }
static napi_value throwExistingError(napi_env env, napi_callback_info info) { static napi_value throwExistingError(napi_env env, napi_callback_info info)
napi_value message; {
napi_value error; napi_value code = nullptr;
NAPI_CALL(env, napi_create_string_utf8(env, "existing error", NAPI_AUTO_LENGTH, &message)); napi_value message = nullptr;
NAPI_CALL(env, napi_create_error(env, NULL, message, &error)); napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
napi_create_string_latin1(env, "test error", NAPI_AUTO_LENGTH, &message);
napi_value error = nullptr;
napi_create_error(env, code, message, &error);
NAPI_ASSERT(env, error != nullptr, "error succes");
bool isError = false;
napi_is_error(env, error, &isError);
NAPI_ASSERT(env, isError, "error succes");
NAPI_CALL(env, napi_throw(env, error)); NAPI_CALL(env, napi_throw(env, error));
return NULL;
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value throwError(napi_env env, napi_callback_info info) { static napi_value throwError(napi_env env, napi_callback_info info)
NAPI_CALL(env, napi_throw_error(env, NULL, "error")); {
return NULL; napi_value code = nullptr;
napi_value message = nullptr;
napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
napi_create_string_latin1(env, "test error", NAPI_AUTO_LENGTH, &message);
napi_value error = nullptr;
napi_create_error(env, code, message, &error);
NAPI_ASSERT(env, error != nullptr, "error succes");
bool isError = false;
napi_is_error(env, error, &isError);
NAPI_ASSERT(env, isError, "error succes");
napi_throw_error(env, "500", "Common error");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value throwTypeError(napi_env env, napi_callback_info info) { static napi_value throwTypeError(napi_env env, napi_callback_info info)
NAPI_CALL(env, napi_throw_type_error(env, NULL, "type error")); {
return NULL; napi_value code = nullptr;
napi_value message = nullptr;
napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
napi_create_string_latin1(env, "type error 500", NAPI_AUTO_LENGTH, &message);
napi_value error = nullptr;
napi_create_type_error(env, code, message, &error);
NAPI_ASSERT(env, error != nullptr, "error succes");
bool isError = false;
napi_is_error(env, error, &isError);
NAPI_ASSERT(env, isError, "error succes");
napi_throw_type_error(env, NULL, "type error1");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value throwRangeError(napi_env env, napi_callback_info info) { static napi_value throwRangeError(napi_env env, napi_callback_info info)
NAPI_CALL(env, napi_throw_range_error(env, NULL, "range error")); {
return NULL; napi_value code = nullptr;
napi_value message = nullptr;
napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
napi_create_string_latin1(env, "range error 500", NAPI_AUTO_LENGTH, &message);
napi_value error = nullptr;
napi_create_range_error(env, code, message, &error);
NAPI_ASSERT(env, error != nullptr, "error succes");
bool isError = false;
napi_is_error(env, error, &isError);
NAPI_ASSERT(env, isError, "error succes");
napi_throw_range_error(env, NULL, "range error");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value isError(napi_env env, napi_callback_info info) { static napi_value isError(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -138,149 +196,186 @@ static napi_value isError(napi_env env, napi_callback_info info) { ...@@ -138,149 +196,186 @@ static napi_value isError(napi_env env, napi_callback_info info) {
return result; return result;
} }
static napi_value createError(napi_env env, napi_callback_info info) { static napi_value createError(napi_env env, napi_callback_info info)
napi_value result; {
napi_value message; napi_value code = nullptr;
NAPI_CALL(env, napi_create_string_utf8(env, "error", NAPI_AUTO_LENGTH, &message)); napi_value message = nullptr;
NAPI_CALL(env, napi_create_error(env, NULL, message, &result));
return result;
}
static napi_value createTypeError(napi_env env, napi_callback_info info) { napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
napi_value result; napi_create_string_latin1(env, "common error", NAPI_AUTO_LENGTH, &message);
napi_value message;
NAPI_CALL(env, napi_create_string_utf8(env, "type error", NAPI_AUTO_LENGTH, &message)); napi_value error = nullptr;
NAPI_CALL(env, napi_create_type_error(env, NULL, message, &result)); napi_create_error(env, code, message, &error);
return result; NAPI_ASSERT(env, error != nullptr, "error succes");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value createRangeError(napi_env env, napi_callback_info info) { static napi_value createTypeError(napi_env env, napi_callback_info info)
napi_value result; {
napi_value message; napi_value code = nullptr;
NAPI_CALL(env, napi_create_string_utf8(env, "range error", NAPI_AUTO_LENGTH, &message)); napi_value message = nullptr;
NAPI_CALL(env, napi_create_range_error(env, NULL, message, &result)); napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
return result; napi_create_string_latin1(env, "type error", NAPI_AUTO_LENGTH, &message);
napi_value error = nullptr;
napi_create_type_error(env, code, message, &error);
NAPI_ASSERT(env, error != nullptr, "error succes");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value getAndClearLastException(napi_env env, napi_callback_info info) { static napi_value createRangeError(napi_env env, napi_callback_info info)
size_t argc = 1; {
napi_value args[1]; napi_value code = nullptr;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); napi_value message = nullptr;
napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
napi_create_string_latin1(env, "range error", NAPI_AUTO_LENGTH, &message);
napi_value error = nullptr;
napi_create_range_error(env, code, message, &error);
napi_value global; NAPI_ASSERT(env, error != nullptr, "error succes");
NAPI_CALL(env, napi_get_global(env, &global));
napi_value result; napi_value _value;
napi_status status = napi_call_function(env, global, args[0], 0, 0, &result); NAPI_CALL(env, napi_create_int32(env, 0, &_value));
if (status == napi_pending_exception) { return _value;
napi_value ex;
NAPI_CALL(env, napi_get_and_clear_last_exception(env, &ex));
return ex;
}
return NULL;
} }
static napi_value isExceptionPending(napi_env env, napi_callback_info info) { static napi_value getAndClearLastException(napi_env env, napi_callback_info info)
size_t argc = 1; {
napi_value args[1]; napi_value code = nullptr;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); napi_value message = nullptr;
napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
napi_create_string_latin1(env, "tag range error", NAPI_AUTO_LENGTH, &message);
napi_value error = nullptr;
napi_create_range_error(env, code, message, &error);
NAPI_ASSERT(env, error != nullptr, "tag error succes");
napi_value global; bool isError = false;
NAPI_CALL(env, napi_get_global(env, &global)); napi_is_error(env, error, &isError);
NAPI_ASSERT(env, isError, "tag isError 1");
napi_value result; napi_value ex;
napi_call_function(env, global, args[0], 0, 0, &result); napi_get_and_clear_last_exception(env, &ex);
bool exceptionWasPending = true;
napi_is_exception_pending(env, &exceptionWasPending);
NAPI_ASSERT(env, !exceptionWasPending, "tag !exceptionWasPending 1");
napi_throw(env, error);
napi_is_exception_pending(env, &exceptionWasPending);
NAPI_ASSERT(env, exceptionWasPending, "tag exceptionWasPending 2");
napi_value ex1;
napi_get_and_clear_last_exception(env, &ex1);
isError = false;
napi_is_error(env, ex1, &isError);
NAPI_ASSERT(env, isError, "tag isError 2");
napi_is_exception_pending(env, &exceptionWasPending);
NAPI_ASSERT(env, !exceptionWasPending, "tag !exceptionWasPending 3");
NAPI_CALL(env, napi_is_exception_pending(env, &exceptionWasPending)); return ex1;
return NULL;
} }
static napi_value openAndCloseHandleScope(napi_env env, napi_callback_info info) { static napi_value isExceptionPending(napi_env env, napi_callback_info info)
napi_handle_scope scope; {
napi_value output = NULL; bool exceptionWasPending = false;
napi_is_exception_pending(env, &exceptionWasPending);
NAPI_ASSERT(env, exceptionWasPending, "error succes");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
}
static napi_value openAndCloseHandleScope(napi_env env, napi_callback_info info)
{
napi_handle_scope scope;
NAPI_CALL(env, napi_open_handle_scope(env, &scope)); NAPI_CALL(env, napi_open_handle_scope(env, &scope));
napi_value output = NULL;
NAPI_CALL(env, napi_create_object(env, &output)); NAPI_CALL(env, napi_create_object(env, &output));
NAPI_CALL(env, napi_close_handle_scope(env, scope)); NAPI_CALL(env, napi_close_handle_scope(env, scope));
return NULL; return output;
} }
static napi_value openAndCloseEscapableHandleScope(napi_env env, napi_callback_info info) { static napi_value openAndCloseEscapableHandleScope(napi_env env, napi_callback_info info)
{
napi_escapable_handle_scope scope; napi_escapable_handle_scope scope;
NAPI_CALL(env, napi_open_escapable_handle_scope(env, &scope));
napi_value output = NULL; napi_value output = NULL;
napi_value escapee = NULL; napi_value escapee = NULL;
NAPI_CALL(env, napi_open_escapable_handle_scope(env, &scope));
NAPI_CALL(env, napi_create_object(env, &output)); NAPI_CALL(env, napi_create_object(env, &output));
NAPI_CALL(env, napi_escape_handle(env, scope, output, &escapee)); NAPI_CALL(env, napi_escape_handle(env, scope, output, &escapee));
NAPI_CALL(env, napi_close_escapable_handle_scope(env, scope)); NAPI_CALL(env, napi_close_escapable_handle_scope(env, scope));
return escapee; return escapee;
} }
static napi_value createReference(napi_env env, napi_callback_info info) { static napi_value createReference(napi_env env, napi_callback_info info)
NAPI_ASSERT(env, test_reference == NULL, {
"The test allows only one reference at a time."); napi_value result = nullptr;
size_t argc = 2;
napi_value args[2];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
NAPI_ASSERT(env, argc == 2, "Expected two arguments.");
uint32_t initial_refcount;
NAPI_CALL(env, napi_get_value_uint32(env, args[1], &initial_refcount));
NAPI_CALL(env,
napi_create_reference(env, args[0], initial_refcount, &test_reference));
NAPI_ASSERT(env, test_reference != NULL,
"A reference should have been created.");
return NULL; napi_create_int32(env, TAG_NUMBER, &result);
NAPI_CALL(env, napi_create_reference(env, result, 1, &test_reference));
napi_value value;
NAPI_CALL(env, napi_create_int32(env, 0, &value));
return value;
} }
static napi_value deleteReference(napi_env env, napi_callback_info info) { static napi_value getAndDeleteReference(napi_env env, napi_callback_info info)
{
NAPI_ASSERT(env, test_reference != NULL, NAPI_ASSERT(env, test_reference != NULL,
"A reference must have been created."); "A reference must have been created.");
napi_value refValue = nullptr;
napi_get_reference_value(env, test_reference, &refValue);
int32_t value = 0;
napi_get_value_int32(env, refValue, &value);
NAPI_ASSERT(env, value == TAG_NUMBER,
"refValue expect equal to 666.");
NAPI_CALL(env, napi_delete_reference(env, test_reference)); NAPI_CALL(env, napi_delete_reference(env, test_reference));
test_reference = NULL; test_reference = NULL;
return NULL; return NULL;
} }
static napi_value referenceRef(napi_env env, napi_callback_info info) { static napi_value referenceRefAndUnref(napi_env env, napi_callback_info info)
NAPI_ASSERT(env, test_reference != NULL, {
"A reference must have been created."); napi_value result = nullptr;
napi_ref resultRef = nullptr;
uint32_t refcount; uint32_t resultRefCount = 0;
NAPI_CALL(env, napi_reference_ref(env, test_reference, &refcount));
napi_value result;
NAPI_CALL(env, napi_create_uint32(env, refcount, &result));
return result;
}
static napi_value referenceUnref(napi_env env, napi_callback_info info) {
NAPI_ASSERT(env, test_reference != NULL,
"A reference must have been created.");
uint32_t refcount;
NAPI_CALL(env, napi_reference_unref(env, test_reference, &refcount));
napi_value result;
NAPI_CALL(env, napi_create_uint32(env, refcount, &result));
return result;
}
static napi_value getReferenceValue(napi_env env, napi_callback_info info) { napi_create_object(env, &result);
NAPI_ASSERT(env, test_reference != NULL, napi_create_reference(env, result, 1, &resultRef);
"A reference must have been created.");
napi_reference_ref(env, resultRef, &resultRefCount);
NAPI_ASSERT(env, resultRefCount == 2,
"resultRefCount expect equal to 2");
napi_reference_unref(env, resultRef, &resultRefCount);
NAPI_ASSERT(env, resultRefCount == 1,
"resultRefCount expect equal to 1.");
napi_value refValue = nullptr;
napi_get_reference_value(env, resultRef, &refValue);
NAPI_ASSERT(env, refValue != NULL,
"A reference must have been created.");
napi_delete_reference(env, resultRef);
napi_value result; napi_value _value;
NAPI_CALL(env, napi_get_reference_value(env, test_reference, &result)); NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return result;
return _value;
} }
static napi_value createArrayAndGetLength(napi_env env, napi_callback_info info) { static napi_value createArrayAndGetLength(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -304,11 +399,11 @@ static napi_value createArrayAndGetLength(napi_env env, napi_callback_info info) ...@@ -304,11 +399,11 @@ static napi_value createArrayAndGetLength(napi_env env, napi_callback_info info)
NAPI_CALL(env, napi_get_element(env, args[0], i, &e)); NAPI_CALL(env, napi_get_element(env, args[0], i, &e));
NAPI_CALL(env, napi_set_element(env, ret, i, e)); NAPI_CALL(env, napi_set_element(env, ret, i, e));
} }
return ret; return ret;
} }
static napi_value getArrayWithLength(napi_env env, napi_callback_info info) { static napi_value getArrayWithLength(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -318,60 +413,72 @@ static napi_value getArrayWithLength(napi_env env, napi_callback_info info) { ...@@ -318,60 +413,72 @@ static napi_value getArrayWithLength(napi_env env, napi_callback_info info) {
napi_valuetype valuetype0; napi_valuetype valuetype0;
NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0)); NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
NAPI_ASSERT(env, valuetype0 == napi_number, NAPI_ASSERT(env, valuetype0 == napi_object,
"Wrong type of arguments. Expects an integer the first argument."); "Wrong type of arguments. Expects an integer the first argument.");
int32_t array_length; uint32_t array_length = 0;
NAPI_CALL(env, napi_get_value_int32(env, args[0], &array_length)); NAPI_CALL(env, napi_get_array_length(env, args[0], &array_length));
NAPI_ASSERT(env, array_length == 2, "array_length expect equal to 2");
napi_value ret; napi_value ret;
NAPI_CALL(env, napi_create_array_with_length(env, array_length, &ret)); NAPI_CALL(env, napi_create_array_with_length(env, array_length, &ret));
for (uint32_t i = 0; i < array_length * 2; i++) {
napi_value e;
NAPI_CALL(env, napi_create_uint32(env, i, &e));
NAPI_CALL(env, napi_set_element(env, ret, i, e));
}
return ret; return ret;
} }
static void finalizer(napi_env env, void * data, void * hint) { static napi_value createExternal(napi_env env, napi_callback_info info)
NAPI_CALL_RETURN_VOID(env, {
napi_throw_error(env, NULL, "Error during Finalize")); const char testStr[] = "test";
napi_value external = nullptr;
napi_create_external(
env, (void*)testStr,
[](napi_env env, void* data, void* hint) {},
(void*)testStr, &external);
void* tempExternal = nullptr;
NAPI_CALL(env, napi_get_value_external(env, external, &tempExternal));
NAPI_ASSERT(env, tempExternal != nullptr, "tempExternal expect not equal to nullptr");
NAPI_ASSERT(env, tempExternal == testStr, "tempExternal expect equal to testStr");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value createExternal(napi_env env, napi_callback_info info) { static napi_value createExternalArraybuffer(napi_env env, napi_callback_info info)
napi_value external; {
int* testInt = (int*)malloc(sizeof(int));
NAPI_CALL(env, *testInt = TAG_NUMBER;
napi_create_external(env, NULL, finalizer, NULL, &external)); napi_value external = nullptr;
size_t arrayBufferSize = 1024;
napi_create_external_arraybuffer(
env, (void*)testInt, arrayBufferSize,
[](napi_env env, void* data, void* hint) {
int* temp = static_cast<int*>(data);
free(temp);
temp = nullptr;
},
(void*)testInt, &external);
return external; return external;
} }
static napi_value createExternalArraybuffer(napi_env env, napi_callback_info info) { static napi_value createObject(napi_env env, napi_callback_info info)
static void* data = NULL; {
napi_value arraybuffer; napi_value result = nullptr;
NAPI_CALL(env, NAPI_CALL(env, napi_create_object(env, &result));
napi_create_external_arraybuffer(env, data, 0, NULL, NULL, &arraybuffer)); NAPI_ASSERT(env, result != nullptr, "napi_create_object");
return arraybuffer; return result;
}
static napi_value createObject(napi_env env, napi_callback_info info) {
napi_value ret;
NAPI_CALL(env, napi_create_object(env, &ret));
napi_value num;
NAPI_CALL(env, napi_create_int32(env, 987654321, &num));
NAPI_CALL(env, napi_set_named_property(env, ret, "test_number", num));
napi_value str;
const char* str_val = "test string";
size_t str_len = strlen(str_val);
NAPI_CALL(env, napi_create_string_utf8(env, str_val, str_len, &str));
NAPI_CALL(env, napi_set_named_property(env, ret, "test_string", str));
return ret;
} }
static napi_value createSymbol(napi_env env, napi_callback_info info) { static napi_value createSymbol(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -390,79 +497,61 @@ static napi_value createSymbol(napi_env env, napi_callback_info info) { ...@@ -390,79 +497,61 @@ static napi_value createSymbol(napi_env env, napi_callback_info info) {
napi_value symbol; napi_value symbol;
NAPI_CALL(env, napi_create_symbol(env, description, &symbol)); NAPI_CALL(env, napi_create_symbol(env, description, &symbol));
return symbol; napi_valuetype valuetypeSymbol;
} NAPI_CALL(env, napi_typeof(env, symbol, &valuetypeSymbol));
static napi_value createTypeArray(napi_env env, napi_callback_info info) {
static int8_t externalData[] = { 0, 1, 2 };
napi_value output_buffer;
NAPI_CALL(env, napi_create_external_arraybuffer(env,
externalData,
sizeof(externalData),
NULL, // finalize_callback
NULL, // finalize_hint
&output_buffer));
napi_value output_array; NAPI_ASSERT(env, valuetypeSymbol == napi_symbol,
NAPI_CALL(env, napi_create_typedarray(env, "Wrong type of arguments. Expects a string.");
napi_int8_array, napi_value _value;
sizeof(externalData) / sizeof(int8_t), NAPI_CALL(env, napi_create_int32(env, 0, &_value));
output_buffer,
0, return _value;
&output_array));
return output_array;
} }
static napi_value createDataView(napi_env env, napi_callback_info info) { static napi_value createTypeArray(napi_env env, napi_callback_info info)
size_t argc = 3; {
napi_value args [3]; napi_value arrayBuffer = nullptr;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); void* arrayBufferPtr = nullptr;
size_t arrayBufferSize = 16;
NAPI_ASSERT(env, argc == 3, "Wrong number of arguments"); size_t typedArrayLength = 4;
napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
napi_valuetype valuetype0;
napi_value arraybuffer = args[0];
NAPI_CALL(env, napi_typeof(env, arraybuffer, &valuetype0));
NAPI_ASSERT(env, valuetype0 == napi_object,
"Wrong type of arguments. Expects a ArrayBuffer as the first "
"argument.");
bool is_arraybuffer;
NAPI_CALL(env, napi_is_arraybuffer(env, arraybuffer, &is_arraybuffer));
NAPI_ASSERT(env, is_arraybuffer,
"Wrong type of arguments. Expects a ArrayBuffer as the first "
"argument.");
napi_valuetype valuetype1;
NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
NAPI_ASSERT(env, valuetype1 == napi_number,
"Wrong type of arguments. Expects a number as second argument.");
size_t byte_offset = 0;
NAPI_CALL(env, napi_get_value_uint32(env, args[1], (uint32_t*)(&byte_offset)));
napi_valuetype valuetype2; void* tmpArrayBufferPtr = nullptr;
NAPI_CALL(env, napi_typeof(env, args[2], &valuetype2)); size_t arrayBufferLength = 0;
napi_get_arraybuffer_info(env, arrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength);
NAPI_ASSERT(env, arrayBufferPtr == tmpArrayBufferPtr, "napi_get_arraybuffer_info success");
NAPI_ASSERT(env, arrayBufferSize == arrayBufferLength, "napi_create_arraybuffer success");
NAPI_ASSERT(env, valuetype2 == napi_number, napi_value _value;
"Wrong type of arguments. Expects a number as third argument."); napi_create_typedarray(env, napi_int32_array, typedArrayLength, arrayBuffer, 0, &_value);
return _value;
}
size_t length = 0; static napi_value createDataView(napi_env env, napi_callback_info info)
NAPI_CALL(env, napi_get_value_uint32(env, args[2], (uint32_t*)(&length))); {
napi_value arrayBuffer = nullptr;
void* arrayBufferPtr = nullptr;
size_t arrayBufferSize = 16;
napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
NAPI_ASSERT(env, arrayBufferPtr != nullptr, "napi_create_arraybuffer success");
bool isArrayBuffer = false;
napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
NAPI_ASSERT(env, isArrayBuffer, " napi_is_arraybuffer success");
napi_value output_dataview; napi_value result = nullptr;
NAPI_CALL(env, NAPI_CALL(env, napi_create_dataview(env, arrayBufferSize, arrayBuffer, 0, &result));
napi_create_dataview(env, length, arraybuffer,
byte_offset, &output_dataview));
return output_dataview; bool isDataView = false;
napi_is_dataview(env, result, &isDataView);
NAPI_ASSERT(env, isDataView, " napi_is_dataview success");
return result;
} }
static napi_value createAndGetInt32(napi_env env, napi_callback_info info) { static napi_value createAndGetInt32(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -476,7 +565,8 @@ static napi_value createAndGetInt32(napi_env env, napi_callback_info info) { ...@@ -476,7 +565,8 @@ static napi_value createAndGetInt32(napi_env env, napi_callback_info info) {
return output; return output;
} }
static napi_value createAndGetUInt32(napi_env env, napi_callback_info info) { static napi_value createAndGetUInt32(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -490,7 +580,8 @@ static napi_value createAndGetUInt32(napi_env env, napi_callback_info info) { ...@@ -490,7 +580,8 @@ static napi_value createAndGetUInt32(napi_env env, napi_callback_info info) {
return output; return output;
} }
static napi_value createAndGetInt64(napi_env env, napi_callback_info info) { static napi_value createAndGetInt64(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -504,7 +595,8 @@ static napi_value createAndGetInt64(napi_env env, napi_callback_info info) { ...@@ -504,7 +595,8 @@ static napi_value createAndGetInt64(napi_env env, napi_callback_info info) {
return output; return output;
} }
static napi_value createDouble(napi_env env, napi_callback_info info) { static napi_value createDouble(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -518,7 +610,8 @@ static napi_value createDouble(napi_env env, napi_callback_info info) { ...@@ -518,7 +610,8 @@ static napi_value createDouble(napi_env env, napi_callback_info info) {
return output; return output;
} }
static napi_value createAndGetStringLatin1(napi_env env, napi_callback_info info) { static napi_value createAndGetStringLatin1(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -533,10 +626,11 @@ static napi_value createAndGetStringLatin1(napi_env env, napi_callback_info info ...@@ -533,10 +626,11 @@ static napi_value createAndGetStringLatin1(napi_env env, napi_callback_info info
char buffer[128]; char buffer[128];
size_t buffer_size = 128; size_t buffer_size = 128;
size_t copied; size_t copied = 0;
NAPI_CALL(env, NAPI_CALL(env,
napi_get_value_string_latin1(env, args[0], buffer, buffer_size, &copied)); napi_get_value_string_latin1(env, args[0], buffer, buffer_size, &copied));
NAPI_ASSERT(env, copied == 3, "napi_get_value_string_latin1 fail");
napi_value output; napi_value output;
NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output)); NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output));
...@@ -544,7 +638,8 @@ static napi_value createAndGetStringLatin1(napi_env env, napi_callback_info info ...@@ -544,7 +638,8 @@ static napi_value createAndGetStringLatin1(napi_env env, napi_callback_info info
return output; return output;
} }
static napi_value createAndGetStringUtf8(napi_env env, napi_callback_info info) { static napi_value createAndGetStringUtf8(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -559,10 +654,11 @@ static napi_value createAndGetStringUtf8(napi_env env, napi_callback_info info) ...@@ -559,10 +654,11 @@ static napi_value createAndGetStringUtf8(napi_env env, napi_callback_info info)
char buffer[128]; char buffer[128];
size_t buffer_size = 128; size_t buffer_size = 128;
size_t copied; size_t copied = 0;
NAPI_CALL(env, NAPI_CALL(env,
napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied)); napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied));
NAPI_ASSERT(env, copied == 2, "napi_get_value_string_utf8 fail");
napi_value output; napi_value output;
NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output)); NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output));
...@@ -570,54 +666,124 @@ static napi_value createAndGetStringUtf8(napi_env env, napi_callback_info info) ...@@ -570,54 +666,124 @@ static napi_value createAndGetStringUtf8(napi_env env, napi_callback_info info)
return output; return output;
} }
static napi_value getPrototype(napi_env env, napi_callback_info info) { static napi_value getPrototype(napi_env env, napi_callback_info info)
{
napi_value testWrapClass = nullptr;
napi_define_class(env, "TestWrapClass", NAPI_AUTO_LENGTH, [](napi_env env, napi_callback_info info) -> napi_value {
napi_value thisVar = nullptr;
napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
return thisVar;
}, nullptr, 0, nullptr, &testWrapClass);
napi_value customClassPrototype = nullptr;
NAPI_CALL(env, napi_get_prototype(env, testWrapClass, &customClassPrototype));
NAPI_ASSERT(env, customClassPrototype != nullptr, "napi_get_prototype fail");
return customClassPrototype;
}
static napi_value getPrototype2(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
napi_value result; NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
NAPI_CALL(env, napi_get_prototype(env, args[0], &result));
return result; napi_valuetype valuetype;
NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
NAPI_ASSERT(env, valuetype == napi_function,
"Wrong type of argment. Expects a napi_function.");
napi_value customClassPrototype = nullptr;
NAPI_CALL(env, napi_get_prototype(env, args[0], &customClassPrototype));
NAPI_ASSERT(env, customClassPrototype != nullptr, "napi_get_prototype fail");
return customClassPrototype;
} }
static napi_value getDataViewInfo(napi_env env, napi_callback_info info) { static napi_value getTypedArrayInfo(napi_env env, napi_callback_info info)
size_t argc = 1; {
napi_value args [1]; napi_value arrayBuffer = nullptr;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); void* arrayBufferPtr = nullptr;
size_t arrayBufferSize = 16;
size_t typedArrayLength = 4;
napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
NAPI_ASSERT(env, arrayBufferPtr != nullptr, "getTypedArrayInfo napi_create_arraybuffer fail");
bool isArrayBuffer = false;
napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
NAPI_ASSERT(env, isArrayBuffer, "getTypedArrayInfo napi_is_arraybuffer fail");
napi_value result;
napi_create_typedarray(env, napi_int32_array, typedArrayLength, arrayBuffer, 0, &result);
NAPI_ASSERT(env, argc == 1, "Wrong number of arguments"); bool isTypedArray = false;
napi_is_typedarray(env, result, &isTypedArray);
NAPI_ASSERT(env, isTypedArray, "getTypedArrayInfo napi_is_dataview fail");
napi_valuetype valuetype; napi_typedarray_type type;
napi_value input_dataview = args[0];
NAPI_CALL(env, napi_typeof(env, input_dataview, &valuetype));
NAPI_ASSERT(env, valuetype == napi_object,
"Wrong type of arguments. Expects a DataView as the first "
"argument.");
bool is_dataview;
NAPI_CALL(env, napi_is_dataview(env, input_dataview, &is_dataview));
NAPI_ASSERT(env, is_dataview,
"Wrong type of arguments. Expects a DataView as the first "
"argument.");
size_t byte_offset = 0;
size_t length = 0; size_t length = 0;
napi_value buffer; void* data = nullptr;
NAPI_CALL(env, napi_value retArrayBuffer;
napi_get_dataview_info(env, input_dataview, &length, NULL, size_t byteOffset = -1;
&buffer, &byte_offset)); NAPI_CALL(env, napi_get_typedarray_info(env, result, &type, &length, &data, &retArrayBuffer, &byteOffset));
NAPI_ASSERT(env, type == napi_int32_array, "napi_get_typedarray_info success 0");
NAPI_ASSERT(env, length == arrayBufferSize, "napi_get_typedarray_info success 1");
NAPI_ASSERT(env, data == arrayBufferPtr, "napi_get_dataview_info success 2");
bool retIsArrayBuffer = false;
NAPI_CALL(env, napi_is_arraybuffer(env, retArrayBuffer, &retIsArrayBuffer));
void* tmpArrayBufferPtr = nullptr;
size_t arrayBufferLength = 0;
NAPI_CALL(env, napi_get_arraybuffer_info(env, retArrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength));
NAPI_ASSERT(env, byteOffset == 0, "napi_get_dataview_info success 3");
napi_value output_dataview; napi_value _value;
NAPI_CALL(env, NAPI_CALL(env, napi_create_int32(env, 0, &_value));
napi_create_dataview(env, length, buffer, return _value;
byte_offset, &output_dataview)); }
static napi_value getDataViewInfo(napi_env env, napi_callback_info info)
{
napi_value arrayBuffer = nullptr;
void* arrayBufferPtr = nullptr;
size_t arrayBufferSize = 1024;
napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
NAPI_ASSERT(env, arrayBufferPtr != nullptr, "getDataViewInfo napi_create_arraybuffer fail");
bool isArrayBuffer = false;
napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
NAPI_ASSERT(env, isArrayBuffer, "getDataViewInfo napi_is_arraybuffer fail");
napi_value result = nullptr;
napi_create_dataview(env, arrayBufferSize, arrayBuffer, 0, &result);
bool isDataView = false;
napi_is_dataview(env, result, &isDataView);
NAPI_ASSERT(env, isDataView, "getDataViewInfo napi_is_dataview fail");
napi_value retArrayBuffer = nullptr;
void* data = nullptr;
size_t byteLength = 0;
size_t byteOffset = -1;
napi_get_dataview_info(env, result, &byteLength, &data, &retArrayBuffer, &byteOffset);
bool retIsArrayBuffer = false;
napi_is_arraybuffer(env, retArrayBuffer, &retIsArrayBuffer);
void* tmpArrayBufferPtr = nullptr;
size_t arrayBufferLength = 0;
napi_get_arraybuffer_info(env, retArrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength);
return output_dataview; NAPI_ASSERT(env, arrayBufferLength == arrayBufferSize, "napi_get_dataview_info success 0");
NAPI_ASSERT(env, arrayBufferPtr == data, "napi_get_dataview_info success 1");
NAPI_ASSERT(env, byteOffset == 0, "napi_get_dataview_info success 2");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value getValueBool(napi_env env, napi_callback_info info) { static napi_value getValueBool(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -631,7 +797,8 @@ static napi_value getValueBool(napi_env env, napi_callback_info info) { ...@@ -631,7 +797,8 @@ static napi_value getValueBool(napi_env env, napi_callback_info info) {
return output; return output;
} }
static napi_value getValueDouble(napi_env env, napi_callback_info info) { static napi_value getValueDouble(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -645,40 +812,57 @@ static napi_value getValueDouble(napi_env env, napi_callback_info info) { ...@@ -645,40 +812,57 @@ static napi_value getValueDouble(napi_env env, napi_callback_info info) {
return output; return output;
} }
static napi_value getValueExternal(napi_env env, napi_callback_info info) { static napi_value getValueExternal(napi_env env, napi_callback_info info)
size_t argc = 1; {
napi_value arg; const char testStr[] = "test";
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL)); napi_value external = nullptr;
napi_create_external(
NAPI_ASSERT(env, argc == 1, "Expected one argument."); env, (void*)testStr,
[](napi_env env, void* data, void* hint) {},
napi_valuetype argtype; (void*)testStr, &external);
NAPI_CALL(env, napi_typeof(env, arg, &argtype)); void* tempExternal = nullptr;
napi_get_value_external(env, external, &tempExternal);
NAPI_ASSERT(env, argtype == napi_external, "Expected an external value.");
void* data;
NAPI_CALL(env, napi_get_value_external(env, arg, &data));
NAPI_ASSERT(env, data != NULL && *(int*)data == test_value, NAPI_ASSERT(env, tempExternal == testStr, "napi_get_value_external true");
"An external data value of 1 was expected.");
return NULL; napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value getNull(napi_env env, napi_callback_info info) { static napi_value getNull(napi_env env, napi_callback_info info)
napi_value result; {
napi_value result = nullptr;
NAPI_CALL(env, napi_get_null(env, &result)); NAPI_CALL(env, napi_get_null(env, &result));
return result; NAPI_ASSERT(env, result != nullptr, "napi_get_null success");
napi_valuetype type;
NAPI_CALL(env, napi_typeof(env, result, &type));
NAPI_ASSERT(env, type == napi_null, "napi_get_null fail");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value getUndefined(napi_env env, napi_callback_info info) { static napi_value getUndefined(napi_env env, napi_callback_info info)
napi_value result; {
napi_value result = nullptr;
NAPI_CALL(env, napi_get_undefined(env, &result)); NAPI_CALL(env, napi_get_undefined(env, &result));
return result; NAPI_ASSERT(env, result != nullptr, "napi_get_undefined success");
napi_valuetype type;
NAPI_CALL(env, napi_typeof(env, result, &type));
NAPI_ASSERT(env, type == napi_undefined, "napi_get_undefined fail");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value coerceToBool(napi_env env, napi_callback_info info) { static napi_value coerceToBool(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -689,7 +873,8 @@ static napi_value coerceToBool(napi_env env, napi_callback_info info) { ...@@ -689,7 +873,8 @@ static napi_value coerceToBool(napi_env env, napi_callback_info info) {
return output; return output;
} }
static napi_value coerceToNumber(napi_env env, napi_callback_info info) { static napi_value coerceToNumber(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -700,7 +885,8 @@ static napi_value coerceToNumber(napi_env env, napi_callback_info info) { ...@@ -700,7 +885,8 @@ static napi_value coerceToNumber(napi_env env, napi_callback_info info) {
return output; return output;
} }
static napi_value coerceToObject(napi_env env, napi_callback_info info) { static napi_value coerceToObject(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -711,7 +897,8 @@ static napi_value coerceToObject(napi_env env, napi_callback_info info) { ...@@ -711,7 +897,8 @@ static napi_value coerceToObject(napi_env env, napi_callback_info info) {
return output; return output;
} }
static napi_value coerceToString(napi_env env, napi_callback_info info) { static napi_value coerceToString(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -722,67 +909,53 @@ static napi_value coerceToString(napi_env env, napi_callback_info info) { ...@@ -722,67 +909,53 @@ static napi_value coerceToString(napi_env env, napi_callback_info info) {
return output; return output;
} }
static napi_value instanceOf(napi_env env, napi_callback_info info) { static napi_value instanceOf(napi_env env, napi_callback_info info)
size_t argc = 2; {
napi_value args[2]; napi_value customClass = nullptr;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
bool instanceof;
NAPI_CALL(env, napi_instanceof(env, args[0], args[1], &instanceof));
napi_value result;
NAPI_CALL(env, napi_get_boolean(env, instanceof, &result));
return result;
}
static napi_value isArray(napi_env env, napi_callback_info info) {
size_t argc = 2;
napi_value args[2];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
napi_valuetype valuetype0;
NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
NAPI_ASSERT(env, valuetype0 == napi_object,
"Wrong type of arguments. Expects an array as first argument.");
napi_valuetype valuetype1;
NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
NAPI_ASSERT(env, valuetype1 == napi_number, napi_define_class(env, "TestWrapClass", NAPI_AUTO_LENGTH,
"Wrong type of arguments. Expects an integer as second argument."); [](napi_env env, napi_callback_info info) -> napi_value {
napi_value thisVar = nullptr;
napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
return thisVar;
}, nullptr, 0, nullptr, &customClass);
napi_value array = args[0]; napi_value customClassPrototype = nullptr;
int32_t index; napi_get_prototype(env, customClass, &customClassPrototype);
NAPI_CALL(env, napi_get_value_int32(env, args[1], &index));
napi_value customInstance = nullptr;
NAPI_CALL(env, napi_new_instance(env, customClass, 0, nullptr, &customInstance));
NAPI_ASSERT(env, index >= 0, "Invalid index. Expects a positive integer."); bool isInstanceOf = false;
NAPI_CALL(env, napi_instanceof(env, customInstance, customClass, &isInstanceOf));
bool isarray; NAPI_ASSERT(env, isInstanceOf, "isInstanceOf success");
NAPI_CALL(env, napi_is_array(env, array, &isarray));
if (!isarray) { napi_value result;
return NULL; NAPI_CALL(env, napi_get_boolean(env, isInstanceOf, &result));
}
uint32_t length;
NAPI_CALL(env, napi_get_array_length(env, array, &length));
NAPI_ASSERT(env, ((uint32_t)index < length), "Index out of bounds!"); return result;
}
napi_value ret; static napi_value isArray(napi_env env, napi_callback_info info)
NAPI_CALL(env, napi_get_element(env, array, index, &ret)); {
napi_value array = nullptr;
napi_create_array(env, &array);
NAPI_ASSERT(env, array != nullptr, "napi_get_undefined success");
bool isArray = false;
napi_is_array(env, array, &isArray);
NAPI_ASSERT(env, isArray, "napi_is_arrayd success");
return ret; napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value isDate(napi_env env, napi_callback_info info) { static napi_value isDate(napi_env env, napi_callback_info info)
{
napi_value date, result; napi_value date, result;
size_t argc = 1; size_t argc = 1;
bool is_date; bool is_date = false;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &date, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &date, NULL, NULL));
NAPI_CALL(env, napi_is_date(env, date, &is_date)); NAPI_CALL(env, napi_is_date(env, date, &is_date));
...@@ -791,40 +964,72 @@ static napi_value isDate(napi_env env, napi_callback_info info) { ...@@ -791,40 +964,72 @@ static napi_value isDate(napi_env env, napi_callback_info info) {
return result; return result;
} }
static napi_value strictEquals(napi_env env, napi_callback_info info) { static napi_value strictEquals(napi_env env, napi_callback_info info)
size_t argc = 2; {
napi_value args[2]; const char* testStringStr = "test";
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); napi_value testString = nullptr;
napi_create_string_utf8(env, testStringStr, strlen(testStringStr), &testString);
bool bool_result; bool isStrictEquals = false;
napi_value result; napi_strict_equals(env, testString, testString, &isStrictEquals);
NAPI_CALL(env, napi_strict_equals(env, args[0], args[1], &bool_result)); NAPI_ASSERT(env, isStrictEquals, "napi_strict_equals success 0");
NAPI_CALL(env, napi_get_boolean(env, bool_result, &result));
napi_value testObject = nullptr;
napi_create_object(env, &testObject);
isStrictEquals = false;
napi_strict_equals(env, testObject, testObject, &isStrictEquals);
NAPI_ASSERT(env, isStrictEquals, "napi_strict_equals success 1");
napi_value napi_number1 = nullptr;
napi_value napi_number2 = nullptr;
napi_create_double(env, 10.1, &napi_number1);
napi_create_int32(env, 10, &napi_number2);
isStrictEquals = true;
napi_strict_equals(env, napi_number1, napi_number2, &isStrictEquals);
NAPI_ASSERT(env, !isStrictEquals, "napi_strict_equals success 2");
return result; napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value getPropertyNames(napi_env env, napi_callback_info info) { static napi_value getPropertyNames(napi_env env, napi_callback_info info)
size_t argc = 1; {
napi_value args[1]; napi_value result = nullptr;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_create_object(env, &result));
NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments"); NAPI_ASSERT(env, result != nullptr, "napi_create_object success");
napi_valuetype value_type0; const char testStr[] = "1234567";
NAPI_CALL(env, napi_typeof(env, args[0], &value_type0)); napi_value strAttribute = nullptr;
NAPI_ASSERT(env, value_type0 == napi_object, NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
"Wrong type of arguments. Expects an object as first argument."); NAPI_ASSERT(env, strAttribute != nullptr, "napi_create_string_utf8 success");
napi_value output; NAPI_CALL(env, napi_set_named_property(env, result, "strAttribute", strAttribute));
NAPI_CALL(env, napi_get_property_names(env, args[0], &output)); bool hasNamedProperty = false;
NAPI_CALL(env, napi_has_named_property(env, result, "strAttribute", &hasNamedProperty));
NAPI_ASSERT(env, hasNamedProperty, "napi_has_named_property fail");
return output; napi_value retStrAttribute = nullptr;
NAPI_CALL(env, napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
NAPI_ASSERT(env, retStrAttribute != nullptr, "napi_get_named_property success");
napi_valuetype type;
NAPI_CALL(env, napi_typeof(env, retStrAttribute, &type));
NAPI_ASSERT(env, type == napi_string, "napi_get_named_property fail");
napi_value res;
napi_coerce_to_number(env, retStrAttribute, &res);
int32_t num = 0;
napi_get_value_int32(env, res, &num);
NAPI_ASSERT(env, num == 1234567, "getPropertyNames fail");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value setProperty(napi_env env, static napi_value setProperty(napi_env env,
napi_callback_info info) { napi_callback_info info)
{
napi_status status; napi_status status;
napi_value object, key, value; napi_value object, key, value;
...@@ -859,7 +1064,8 @@ static napi_value setProperty(napi_env env, ...@@ -859,7 +1064,8 @@ static napi_value setProperty(napi_env env,
} }
static napi_value getProperty(napi_env env, static napi_value getProperty(napi_env env,
napi_callback_info info) { napi_callback_info info)
{
napi_status status; napi_status status;
napi_value object, key, result; napi_value object, key, result;
...@@ -893,35 +1099,67 @@ static napi_value getProperty(napi_env env, ...@@ -893,35 +1099,67 @@ static napi_value getProperty(napi_env env,
return object; return object;
} }
static napi_value hasProperty(napi_env env, napi_callback_info info) { static napi_value hasProperty(napi_env env, napi_callback_info info)
size_t argc = 2; {
napi_value args[2]; napi_value result = nullptr;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_create_object(env, &result));
NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments"); const char testStr[] = "1234567";
napi_value strAttribute = nullptr;
NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
NAPI_CALL(env, napi_set_named_property(env, result, "strAttribute", strAttribute));
napi_valuetype valuetype0; napi_value retStrAttribute = nullptr;
NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0)); NAPI_CALL(env, napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
NAPI_ASSERT(env, valuetype0 == napi_object, int32_t testNumber = 12345;
"Wrong type of arguments. Expects an object as first argument."); napi_value numberAttribute = nullptr;
NAPI_CALL(env, napi_create_int32(env, testNumber, &numberAttribute));
NAPI_CALL(env, napi_set_named_property(env, result, "numberAttribute", numberAttribute));
napi_valuetype valuetype1; napi_value propNames = nullptr;
NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1)); NAPI_CALL(env, napi_get_property_names(env, result, &propNames));
NAPI_ASSERT(env, propNames != nullptr, "napi_get_property_names success");
NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol, bool isArray = false;
"Wrong type of arguments. Expects a string or symbol as second."); NAPI_CALL(env, napi_is_array(env, propNames, &isArray));
NAPI_ASSERT(env, isArray, "napi_is_array success");
bool has_property; uint32_t arrayLength = 0;
NAPI_CALL(env, napi_has_property(env, args[0], args[1], &has_property)); NAPI_CALL(env, napi_get_array_length(env, propNames, &arrayLength));
napi_value ret; for (uint32_t i = 0; i < arrayLength; i++) {
NAPI_CALL(env, napi_get_boolean(env, has_property, &ret)); bool hasElement = false;
NAPI_CALL(env, napi_has_element(env, propNames, i, &hasElement));
NAPI_ASSERT(env, hasElement, "napi_has_element success");
return ret; napi_value propName = nullptr;
NAPI_CALL(env, napi_get_element(env, propNames, i, &propName));
NAPI_ASSERT(env, propName != nullptr, "napi_get_element success");
bool hasProp = false;
napi_has_property(env, result, propName, &hasProp);
NAPI_ASSERT(env, hasProp, "napi_get_element success");
napi_value propValue = nullptr;
napi_get_property(env, result, propName, &propValue);
NAPI_ASSERT(env, propValue != nullptr, "napi_get_property success");
}
bool deletion = false;
NAPI_CALL(env, napi_delete_element(env, propNames, 1, &deletion));
NAPI_ASSERT(env, deletion, "napi_delete_element fail");
bool hasElement = true;
NAPI_CALL(env, napi_has_element(env, propNames, 1, &hasElement));
NAPI_ASSERT(env, !hasElement, "napi_has_element fail");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value deleteProperty(napi_env env, napi_callback_info info) { static napi_value setAndDeleteProperty(napi_env env, napi_callback_info info)
{
size_t argc = 2; size_t argc = 2;
napi_value args[2]; napi_value args[2];
...@@ -938,15 +1176,31 @@ static napi_value deleteProperty(napi_env env, napi_callback_info info) { ...@@ -938,15 +1176,31 @@ static napi_value deleteProperty(napi_env env, napi_callback_info info) {
NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol, NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
"Wrong type of arguments. Expects a string or symbol as second."); "Wrong type of arguments. Expects a string or symbol as second.");
const char testStr[] = "cKey";
napi_value cKey;
napi_value cValue;
NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &cKey));
NAPI_CALL(env, napi_create_int32(env, 3, &cValue));
NAPI_CALL(env, napi_set_property(env, args[0], cKey, cValue));
bool hasProp = false;
NAPI_CALL(env, napi_has_property(env, args[0], cKey, &hasProp));
NAPI_ASSERT(env, hasProp, "setAndDeleteProperty napi_has_property fail 1");
bool result; bool result;
napi_value ret; napi_value ret;
NAPI_CALL(env, napi_delete_property(env, args[0], args[1], &result)); NAPI_CALL(env, napi_delete_property(env, args[0], cKey, &result));
NAPI_CALL(env, napi_get_boolean(env, result, &ret)); NAPI_CALL(env, napi_get_boolean(env, result, &ret));
NAPI_CALL(env, napi_has_property(env, args[0], cKey, &hasProp));
NAPI_ASSERT(env, !hasProp, "setAndDeleteProperty napi_has_property fail 2");
return ret; napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value hasOwnProperty(napi_env env, napi_callback_info info) { static napi_value hasOwnProperty(napi_env env, napi_callback_info info)
{
size_t argc = 2; size_t argc = 2;
napi_value args[2]; napi_value args[2];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -968,7 +1222,8 @@ static napi_value hasOwnProperty(napi_env env, napi_callback_info info) { ...@@ -968,7 +1222,8 @@ static napi_value hasOwnProperty(napi_env env, napi_callback_info info) {
return ret; return ret;
} }
static napi_value setNamedProperty(napi_env env, napi_callback_info info) { static napi_value setNamedProperty(napi_env env, napi_callback_info info)
{
size_t argc = 3; size_t argc = 3;
napi_value args[3]; napi_value args[3];
char key[256] = ""; char key[256] = "";
...@@ -1003,7 +1258,8 @@ static napi_value setNamedProperty(napi_env env, napi_callback_info info) { ...@@ -1003,7 +1258,8 @@ static napi_value setNamedProperty(napi_env env, napi_callback_info info) {
return value_true; return value_true;
} }
static napi_value getNamedProperty(napi_env env, napi_callback_info info) { static napi_value getNamedProperty(napi_env env, napi_callback_info info)
{
size_t argc = 2; size_t argc = 2;
napi_value args[2]; napi_value args[2];
char key[256] = ""; char key[256] = "";
...@@ -1036,7 +1292,8 @@ static napi_value getNamedProperty(napi_env env, napi_callback_info info) { ...@@ -1036,7 +1292,8 @@ static napi_value getNamedProperty(napi_env env, napi_callback_info info) {
return output; return output;
} }
static napi_value hasNamedProperty(napi_env env, napi_callback_info info) { static napi_value hasNamedProperty(napi_env env, napi_callback_info info)
{
size_t argc = 2; size_t argc = 2;
napi_value args[2]; napi_value args[2];
char key[256] = ""; char key[256] = "";
...@@ -1072,7 +1329,8 @@ static napi_value hasNamedProperty(napi_env env, napi_callback_info info) { ...@@ -1072,7 +1329,8 @@ static napi_value hasNamedProperty(napi_env env, napi_callback_info info) {
return ret; return ret;
} }
static napi_value setElement(napi_env env, napi_callback_info info) { static napi_value setElement(napi_env env, napi_callback_info info)
{
napi_value return_value, object; napi_value return_value, object;
NAPI_CALL(env, napi_create_object(env, &return_value)); NAPI_CALL(env, napi_create_object(env, &return_value));
...@@ -1095,7 +1353,8 @@ static napi_value setElement(napi_env env, napi_callback_info info) { ...@@ -1095,7 +1353,8 @@ static napi_value setElement(napi_env env, napi_callback_info info) {
return return_value; return return_value;
} }
static napi_value getElement(napi_env env, napi_callback_info info) { static napi_value getElement(napi_env env, napi_callback_info info)
{
napi_value return_value, object, prop; napi_value return_value, object, prop;
NAPI_CALL(env, napi_create_object(env, &return_value)); NAPI_CALL(env, napi_create_object(env, &return_value));
...@@ -1118,7 +1377,8 @@ static napi_value getElement(napi_env env, napi_callback_info info) { ...@@ -1118,7 +1377,8 @@ static napi_value getElement(napi_env env, napi_callback_info info) {
} }
static napi_value TestBoolValuedElementApi(napi_env env, static napi_value TestBoolValuedElementApi(napi_env env,
napi_status (* api)(napi_env, napi_value, uint32_t, bool*)) { napi_status (* api)(napi_env, napi_value, uint32_t, bool*))
{
napi_value return_value, object; napi_value return_value, object;
bool result; bool result;
...@@ -1141,18 +1401,21 @@ static napi_value TestBoolValuedElementApi(napi_env env, ...@@ -1141,18 +1401,21 @@ static napi_value TestBoolValuedElementApi(napi_env env,
return return_value; return return_value;
} }
static napi_value hasElement(napi_env env, napi_callback_info info) { static napi_value hasElement(napi_env env, napi_callback_info info)
{
return TestBoolValuedElementApi(env, napi_has_element); return TestBoolValuedElementApi(env, napi_has_element);
} }
static napi_value deleteElement(napi_env env, napi_callback_info info) { static napi_value deleteElement(napi_env env, napi_callback_info info)
{
return TestBoolValuedElementApi(env, napi_delete_element); return TestBoolValuedElementApi(env, napi_delete_element);
} }
static napi_value defineProperties(napi_env env, napi_callback_info info) { static napi_value defineProperties(napi_env env, napi_callback_info info)
{
napi_value object, return_value; napi_value object, return_value;
napi_property_descriptor desc = { "prop", NULL, defineProperties, NULL, NULL, NULL, napi_enumerable, NULL }; napi_property_descriptor desc = {"prop", NULL, defineProperties, NULL, NULL, NULL, napi_enumerable, NULL};
NAPI_CALL(env, napi_create_object(env, &object)); NAPI_CALL(env, napi_create_object(env, &object));
NAPI_CALL(env, napi_create_object(env, &return_value)); NAPI_CALL(env, napi_create_object(env, &return_value));
...@@ -1183,60 +1446,111 @@ static napi_value defineProperties(napi_env env, napi_callback_info info) { ...@@ -1183,60 +1446,111 @@ static napi_value defineProperties(napi_env env, napi_callback_info info) {
return return_value; return return_value;
} }
static napi_value getNewTarget(napi_env env, napi_callback_info info) { static napi_value MyConstructor(napi_env env, napi_callback_info info)
napi_value newTargetArg; {
NAPI_CALL(env, napi_get_new_target(env, info, &newTargetArg)); napi_value thisVar = nullptr;
napi_value thisArg; size_t argc = 0;
NAPI_CALL(env, napi_get_cb_info(env, info, NULL, NULL, &thisArg, NULL)); napi_value constructor = nullptr;
napi_value undefined; napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
NAPI_CALL(env, napi_get_undefined(env, &undefined)); napi_get_new_target(env, info, &constructor);
if (constructor == nullptr) {
napi_throw_error(env, nullptr, "is not new instance");
}
return thisVar;
}
bool result; static napi_value wrap(napi_env env, napi_callback_info info)
NAPI_CALL(env, napi_strict_equals(env, newTargetArg, thisArg, &result)); {
NAPI_ASSERT(env, !result, "this !== new.target"); napi_value testClass = nullptr;
napi_define_class(
env, "TestClass", NAPI_AUTO_LENGTH,
[](napi_env env, napi_callback_info info) -> napi_value {
napi_value thisVar = nullptr;
napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
NAPI_ASSERT(env, newTargetArg != NULL, "newTargetArg != NULL"); return thisVar;
NAPI_CALL(env, napi_strict_equals(env, newTargetArg, undefined, &result)); },
NAPI_ASSERT(env, !result, "new.target !== undefined"); nullptr, 0, nullptr, &testClass);
napi_value instanceValue = nullptr;
napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
return thisArg; const char* testStr = "test";
napi_wrap(
env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value wrap(napi_env env, napi_callback_info info) { static napi_value unwrap(napi_env env, napi_callback_info info)
size_t argc = 1; {
napi_value arg; napi_value testClass = nullptr;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL)); napi_define_class(
env, "TestClass", NAPI_AUTO_LENGTH,
[](napi_env env, napi_callback_info info) -> napi_value {
napi_value thisVar = nullptr;
napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
NAPI_CALL(env, napi_wrap(env, arg, &test_value, NULL, NULL, NULL)); return thisVar;
return NULL; },
} nullptr, 0, nullptr, &testClass);
static napi_value unwrap(napi_env env, napi_callback_info info) { napi_value instanceValue = nullptr;
size_t argc = 1; napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
napi_value arg;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL));
void* data; const char* testStr = "test";
NAPI_CALL(env, napi_unwrap(env, arg, &data)); napi_wrap(
env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
bool is_expected = (data != NULL && *(int*)data == 3); const char* tmpTestStr = nullptr;
napi_value result; NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr));
NAPI_CALL(env, napi_get_boolean(env, is_expected, &result)); NAPI_ASSERT(env, tmpTestStr == testStr, "napi_unwrap fail");
return result;
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value removeWrap(napi_env env, napi_callback_info info) { static napi_value removeWrap(napi_env env, napi_callback_info info)
size_t argc = 1; {
napi_value wrapped; napi_value testClass = nullptr;
void* data; napi_define_class(
env, "TestClass", NAPI_AUTO_LENGTH,
[](napi_env env, napi_callback_info info) -> napi_value {
napi_value thisVar = nullptr;
napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &wrapped, NULL, NULL)); return thisVar;
NAPI_CALL(env, napi_remove_wrap(env, wrapped, &data)); },
nullptr, 0, nullptr, &testClass);
return NULL; napi_value instanceValue = nullptr;
napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
const char* testStr = "test";
napi_wrap(
env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
const char* tmpTestStr = nullptr;
NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr));
NAPI_ASSERT(env, tmpTestStr == testStr, "napi_unwrap fail");
const char* tmpTestStr1 = nullptr;
napi_remove_wrap(env, instanceValue, (void**)&tmpTestStr1);
NAPI_ASSERT(env, tmpTestStr1 == testStr, "napi_remove_wrap fail 1");
NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr1));
NAPI_ASSERT(env, tmpTestStr1 == nullptr, "napi_remove_wrap fail");
napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value getVersion(napi_env env, napi_callback_info info) { static napi_value getVersion(napi_env env, napi_callback_info info)
{
uint32_t version; uint32_t version;
napi_value result; napi_value result;
NAPI_CALL(env, napi_get_version(env, &version)); NAPI_CALL(env, napi_get_version(env, &version));
...@@ -1244,50 +1558,54 @@ static napi_value getVersion(napi_env env, napi_callback_info info) { ...@@ -1244,50 +1558,54 @@ static napi_value getVersion(napi_env env, napi_callback_info info) {
return result; return result;
} }
static napi_value createPromise(napi_env env, napi_callback_info info) { static napi_value createPromise(napi_env env, napi_callback_info info)
napi_value promise; {
napi_deferred deferred = nullptr;
// We do not overwrite an existing deferred. napi_value promise = nullptr;
if (deferred != NULL) { napi_create_promise(env, &deferred, &promise);
return NULL; NAPI_ASSERT(env, deferred != nullptr, "create promise success");
} NAPI_ASSERT(env, promise != nullptr, "create promise success");
NAPI_CALL(env, napi_create_promise(env, &deferred, &promise)); napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return promise; return _value;
} }
static napi_value resolveAndRejectDeferred(napi_env env, napi_callback_info info) { static napi_value resolveAndRejectDeferred(napi_env env, napi_callback_info info)
napi_value argv[2]; {
size_t argc = 2; napi_deferred deferred = nullptr;
bool resolution; napi_value promise = nullptr;
NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL)); bool isPromise = false;
NAPI_CALL(env, napi_get_value_bool(env, argv[1], &resolution)); napi_is_promise(env, promise, &isPromise);
if (resolution) {
NAPI_CALL(env, napi_resolve_deferred(env, deferred, argv[0]));
} else {
NAPI_CALL(env, napi_reject_deferred(env, deferred, argv[0]));
}
deferred = NULL; napi_value undefined = nullptr;
napi_get_undefined(env, &undefined);
NAPI_CALL(env, napi_resolve_deferred(env, deferred, undefined));
return NULL; napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value isPromise(napi_env env, napi_callback_info info) { static napi_value isPromise(napi_env env, napi_callback_info info)
napi_value promise, result; {
size_t argc = 1; napi_deferred deferred = nullptr;
bool is_promise; napi_value promise = nullptr;
NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &promise, NULL, NULL));
NAPI_CALL(env, napi_is_promise(env, promise, &is_promise)); bool isPromise = false;
NAPI_CALL(env, napi_get_boolean(env, is_promise, &result)); NAPI_CALL(env, napi_is_promise(env, promise, &isPromise));
NAPI_ASSERT(env, isPromise, "napi_is_promise success");
return result; napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
} }
static napi_value runScript(napi_env env, napi_callback_info info) { static napi_value runScript(napi_env env, napi_callback_info info)
{
napi_value script, result; napi_value script, result;
size_t argc = 1; size_t argc = 1;
...@@ -1298,7 +1616,18 @@ static napi_value runScript(napi_env env, napi_callback_info info) { ...@@ -1298,7 +1616,18 @@ static napi_value runScript(napi_env env, napi_callback_info info) {
return result; return result;
} }
static napi_value TestLatin1(napi_env env, napi_callback_info info) { static napi_value getUvEventLoop(napi_env env, napi_callback_info info)
{
struct uv_loop_s* loop = nullptr;
NAPI_CALL(env, napi_get_uv_event_loop(env, &loop));
NAPI_ASSERT(env, loop != nullptr, "napi_get_uv_event_loop fail");
return nullptr;
}
static napi_value TestLatin1(napi_env env, napi_callback_info info)
{
size_t argc = 1; size_t argc = 1;
napi_value args[1]; napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
...@@ -1336,6 +1665,27 @@ static napi_value napCreateArrayBuffer(napi_env env, napi_callback_info info) ...@@ -1336,6 +1665,27 @@ static napi_value napCreateArrayBuffer(napi_env env, napi_callback_info info)
return arrayBuffer; return arrayBuffer;
} }
static napi_value napiGetCbInfo(napi_env env, napi_callback_info info)
{
size_t argc = 1;
napi_value args[1];
napi_status status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
NAPI_ASSERT(env, status == napi_ok, "get_cb_info ok");
NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
double value;
napi_get_value_double(env, args[0], &value);
napi_valuetype valuetype;
NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
NAPI_ASSERT(env, valuetype == napi_number, "Wrong type of argment. Expects a nunber.");
napi_value returnValue;
napi_status statusDouble = napi_create_double(env, value, &returnValue);
NAPI_ASSERT(env, statusDouble == napi_ok, "success to napi_create_double");
return returnValue;
}
static napi_value naiGetArrayBufferInfo(napi_env env, napi_callback_info info) static napi_value naiGetArrayBufferInfo(napi_env env, napi_callback_info info)
{ {
// the value to return // the value to return
...@@ -1358,23 +1708,6 @@ static napi_value naiGetArrayBufferInfo(napi_env env, napi_callback_info info) ...@@ -1358,23 +1708,6 @@ static napi_value naiGetArrayBufferInfo(napi_env env, napi_callback_info info)
return arrayLength; return arrayLength;
} }
static napi_value napiNewInstance(napi_env env, napi_callback_info info)
{
// the value to return
napi_value global, constructor, arg, value;
napi_status status = napi_get_global(env, &global);
NAPI_ASSERT(env, status == napi_ok, "napi_get_global success");
status = napi_get_named_property(env, global, "MyObject", &constructor);
NAPI_ASSERT(env, status == napi_ok, "napi_get_named_property success");
status = napi_create_string_utf8(env, "hello", NAPI_AUTO_LENGTH, &arg);
napi_value* argv = &arg;
size_t argc = 1;
napi_status _status = napi_new_instance(env, constructor, argc, argv, &value);
NAPI_ASSERT(env, _status != napi_ok, "fail to napi_new_instance");
return value;
}
static napi_value napiDefineClass(napi_env env, napi_callback_info info) static napi_value napiDefineClass(napi_env env, napi_callback_info info)
{ {
napi_value testWrapClass = nullptr; napi_value testWrapClass = nullptr;
...@@ -1399,6 +1732,7 @@ static napi_value napiRunScriptPath(napi_env env, napi_callback_info info) ...@@ -1399,6 +1732,7 @@ static napi_value napiRunScriptPath(napi_env env, napi_callback_info info)
const char* path = "index/page"; const char* path = "index/page";
napi_status status = napi_run_script_path(env, path, &value); napi_status status = napi_run_script_path(env, path, &value);
NAPI_ASSERT(env, status == napi_ok, "napi_run_script_path ok"); NAPI_ASSERT(env, status == napi_ok, "napi_run_script_path ok");
NAPI_ASSERT(env, value == nullptr, "napi_run_script_path fail");
napi_value _value; napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value)); NAPI_CALL(env, napi_create_int32(env, 0, &_value));
...@@ -1461,6 +1795,107 @@ static napi_value napiCreateThreadsafeFunction(napi_env env, napi_callback_info ...@@ -1461,6 +1795,107 @@ static napi_value napiCreateThreadsafeFunction(napi_env env, napi_callback_info
return _value; return _value;
} }
struct AddonData {
napi_async_work asyncWork = nullptr;
napi_deferred deferred = nullptr;
napi_ref callback = nullptr;
double args = 0;
double result = 0;
};
static void AddExecuteCB(napi_env env, void *data) {
AddonData *addonData = (AddonData *)data;
addonData->result = addonData->args;
}
static void AddCallbackCompleteCB(napi_env env, napi_status status, void *data) {
AddonData *addonData = (AddonData *)data;
napi_value callback = nullptr;
NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, addonData->callback, &callback));
napi_value result = nullptr;
NAPI_CALL_RETURN_VOID(env, napi_create_double(env, addonData->result, &result));
napi_value callbackResult = nullptr;
int32_t ret = 0;
NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback, 1, &result, &callbackResult));
NAPI_CALL_RETURN_VOID(env, napi_get_value_int32(env, callbackResult, &ret));
NAPI_ASSERT_RETURN_VOID(env, ret == 2000, "AddCallbackCompleteCB failed");
if (addonData->callback != nullptr) {
NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, addonData->callback));
}
NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, addonData->asyncWork));
free(addonData);
}
static napi_value testAsyncWork(napi_env env, napi_callback_info info) {
size_t argc = 2;
napi_value args[2];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
struct AddonData* addonData = (struct AddonData*)malloc(sizeof(struct AddonData));
if (addonData == nullptr) {
return nullptr;
}
NAPI_CALL(env, napi_get_value_double(env, args[0], &addonData->args));
NAPI_CALL(env, napi_create_reference(env, args[1], 1, &addonData->callback));
napi_value resourceName = nullptr;
NAPI_CALL(env, napi_create_string_utf8(env, "AsyncWorkTest", NAPI_AUTO_LENGTH, &resourceName));
NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, AddExecuteCB, AddCallbackCompleteCB,
(void *)addonData, &addonData->asyncWork));
NAPI_CALL(env, napi_queue_async_work(env, addonData->asyncWork));
napi_value _value = 0;
NAPI_CALL(env, napi_create_int32(env, 0, &_value));
return _value;
}
static void AddPromiseCompleteCB(napi_env env, napi_status status, void *data) {
AddonData *addonData = (AddonData *)data;
napi_value result = nullptr;
NAPI_CALL_RETURN_VOID(env, napi_create_double(env, addonData->result, &result));
if (addonData->result > 0) {
NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, addonData->deferred, result));
} else {
NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, addonData->deferred, result));
}
NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, addonData->asyncWork));
free(addonData);
addonData = nullptr;
}
static napi_value testPromise(napi_env env, napi_callback_info info)
{
size_t argc = 1;
napi_value args[1];
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
napi_value promise = nullptr;
napi_deferred deferred = nullptr;
NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
struct AddonData* addonData = (struct AddonData*)malloc(sizeof(struct AddonData));
if (addonData == nullptr) {
return nullptr;
}
addonData->deferred = deferred;
NAPI_CALL(env, napi_get_value_double(env, args[0], &addonData->args));
napi_value resourceName = nullptr;
NAPI_CALL(env, napi_create_string_utf8(env, "AsyncCallback", NAPI_AUTO_LENGTH, &resourceName));
NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, AddExecuteCB,
AddPromiseCompleteCB, (void *)addonData, &addonData->asyncWork));
napi_queue_async_work(env, addonData->asyncWork);
return promise;
}
static napi_value napiCancelAsyncWork(napi_env env, napi_callback_info info) static napi_value napiCancelAsyncWork(napi_env env, napi_callback_info info)
{ {
napi_async_work work = nullptr; napi_async_work work = nullptr;
...@@ -1472,7 +1907,7 @@ static napi_value napiCancelAsyncWork(napi_env env, napi_callback_info info) ...@@ -1472,7 +1907,7 @@ static napi_value napiCancelAsyncWork(napi_env env, napi_callback_info info)
napi_delete_async_work(env, workData); napi_delete_async_work(env, workData);
}, work, &work); }, work, &work);
napi_queue_async_work(env, work); napi_queue_async_work(env, work);
napi_cancel_async_work(env, work); NAPI_CALL(env, napi_cancel_async_work(env, work));
napi_value value; napi_value value;
NAPI_CALL(env, napi_create_int32(env, 0, &value)); NAPI_CALL(env, napi_create_int32(env, 0, &value));
...@@ -1482,19 +1917,21 @@ static napi_value napiCancelAsyncWork(napi_env env, napi_callback_info info) ...@@ -1482,19 +1917,21 @@ static napi_value napiCancelAsyncWork(napi_env env, napi_callback_info info)
static napi_value SayHello(napi_env env, napi_callback_info info) static napi_value SayHello(napi_env env, napi_callback_info info)
{ {
printf("Hello\n"); printf("Hello\n");
napi_value ret;
return NULL; NAPI_CALL(env, napi_create_int32(env, TAG_NUMBER, &ret));
return ret;
} }
static napi_value napiCreateFunction(napi_env env, napi_callback_info info) static napi_value napiCreateFunction(napi_env env, napi_callback_info info)
{ {
napi_value funcValue = nullptr; napi_value funcValue = nullptr;
napi_status status = napi_create_function(env, NULL, 0, SayHello, NULL, &funcValue); napi_status status = napi_create_function(env, "func", NAPI_AUTO_LENGTH, SayHello, NULL, &funcValue);
NAPI_ASSERT(env, status != napi_ok, "napi_create_function fail"); NAPI_ASSERT(env, funcValue != nullptr, "napi_create_function fail");
NAPI_ASSERT(env, status == napi_ok, "napi_create_function fail");
napi_value value; napi_value value;
NAPI_CALL(env, napi_create_int32(env, 1, &value)); NAPI_CALL(env, napi_create_int32(env, 1, &value));
return value; return funcValue;
} }
static napi_value napiRefthreadSafeFunction(napi_env env, napi_callback_info info) static napi_value napiRefthreadSafeFunction(napi_env env, napi_callback_info info)
...@@ -1544,6 +1981,7 @@ static napi_value napiCreateBigintUint64(napi_env env, napi_callback_info info) ...@@ -1544,6 +1981,7 @@ static napi_value napiCreateBigintUint64(napi_env env, napi_callback_info info)
uint64_t resultValue = 0; uint64_t resultValue = 0;
bool flag = false; bool flag = false;
napi_get_value_bigint_uint64(env, result, &resultValue, &flag); napi_get_value_bigint_uint64(env, result, &resultValue, &flag);
NAPI_ASSERT(env, resultValue == testValue, "napi_get_value_bigint_int64 failed");
napi_value value; napi_value value;
NAPI_CALL(env, napi_create_int32(env, flag, &value)); NAPI_CALL(env, napi_create_int32(env, flag, &value));
...@@ -1558,6 +1996,7 @@ static napi_value napiCreateBigintInt64(napi_env env, napi_callback_info info) ...@@ -1558,6 +1996,7 @@ static napi_value napiCreateBigintInt64(napi_env env, napi_callback_info info)
int64_t resultValue = 0; int64_t resultValue = 0;
bool flag = false; bool flag = false;
napi_get_value_bigint_int64(env, result, &resultValue, &flag); napi_get_value_bigint_int64(env, result, &resultValue, &flag);
NAPI_ASSERT(env, resultValue == testValue, "napi_get_value_bigint_int64 failed");
napi_value value; napi_value value;
NAPI_CALL(env, napi_create_int32(env, flag, &value)); NAPI_CALL(env, napi_create_int32(env, flag, &value));
...@@ -1568,15 +2007,22 @@ static napi_value napiCreateBigintWords(napi_env env, napi_callback_info info) ...@@ -1568,15 +2007,22 @@ static napi_value napiCreateBigintWords(napi_env env, napi_callback_info info)
{ {
int signBit = 0; int signBit = 0;
size_t wordCount = 4; size_t wordCount = 4;
uint64_t words[] = { 0xFFFFFFFFFFFFFFFF, 34ULL, 56ULL, 0xFFFFFFFFFFFFFFFF }; uint64_t words[] = {0ULL, 34ULL, 56ULL, 2ULL};
uint64_t wordsOut[] = { 0ULL, 0ULL, 0ULL, 0ULL }; uint64_t wordsOut[] = {0ULL, 0ULL, 0ULL, 0ULL};
napi_value result = nullptr; napi_value result = nullptr;
NAPI_CALL(env, napi_create_bigint_words(env, signBit, wordCount, words, &result)); NAPI_CALL(env, napi_create_bigint_words(env, signBit, wordCount, words, &result));
NAPI_CALL(env, napi_get_value_bigint_words(env, result, &signBit, &wordCount, wordsOut)); int retSignBit = -1;
bool testResult = false; size_t retWordCount = 4;
const int wCount = 2; NAPI_CALL(env, napi_get_value_bigint_words(env, result, &retSignBit, &retWordCount, wordsOut));
if (signBit == 0 && wordCount == wCount && words[0] == wordsOut[0] && words[1] == wordsOut[1]) { bool testResult = true;
testResult = true; if (retSignBit != signBit || retWordCount != wordCount) {
testResult = false;
}
for (size_t i = 0; i < wordCount; i++) {
if (wordsOut[i] != words[i]) {
testResult = false;
break;
}
} }
napi_value value; napi_value value;
NAPI_CALL(env, napi_create_int32(env, testResult, &value)); NAPI_CALL(env, napi_create_int32(env, testResult, &value));
...@@ -1584,61 +2030,75 @@ static napi_value napiCreateBigintWords(napi_env env, napi_callback_info info) ...@@ -1584,61 +2030,75 @@ static napi_value napiCreateBigintWords(napi_env env, napi_callback_info info)
return value; return value;
} }
static napi_value napiFatalerror(napi_env env, napi_callback_info info) static napi_value callFunction(napi_env env, napi_callback_info info)
{ {
void *data = nullptr; size_t argc = 1;
napi_threadsafe_function tsfun = static_cast<napi_threadsafe_function>(data); napi_value args[1];
if (napi_release_threadsafe_function(tsfun, napi_tsfn_release) == napi_ok) { NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
napi_fatal_error("ReleaseThreadsafeFunction", NAPI_AUTO_LENGTH,
"napi_release_threadsafe_function failed", NAPI_AUTO_LENGTH); NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
}
napi_value _value; napi_valuetype valuetype;
NAPI_CALL(env, napi_create_int32(env, 0, &_value)); NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
return _value; NAPI_ASSERT(env, valuetype == napi_function,
"Wrong type of argment. Expects a string.");
napi_value ret;
NAPI_CALL(env, napi_call_function(env, nullptr, args[0], 0, nullptr, &ret));
return ret;
} }
static napi_value napiGetTypedarrayInfo(napi_env env, napi_callback_info info) static napi_value getGlobal(napi_env env, napi_callback_info info)
{ {
napi_value arrayBuffer = nullptr; napi_value result = nullptr;
void* arrayBufferPr = nullptr; NAPI_CALL(env, napi_get_global(env, &result));
size_t arrayBufferSize = 200; NAPI_ASSERT(env, result != nullptr, "napi_get_global failed");
// create a JavaScript ArrayBuffer return nullptr;
napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPr, &arrayBuffer); }
// convert from N-API to C types napi_threadsafe_function tsfn;
void* tmpArrayBufferPr = nullptr; napi_ref functionRef;
size_t arrayBufferLength = 0; static void CallJs(napi_env env, napi_value js_cb, void *context, void *data) {
napi_get_arraybuffer_info(env, arrayBuffer, &tmpArrayBufferPr, &arrayBufferLength);
NAPI_ASSERT(env, arrayBufferPr == tmpArrayBufferPr, "creat and get ArrayBuffer success");
NAPI_ASSERT(env, arrayBufferSize == arrayBufferLength, "creat and get ArrayBuffer size success");
napi_value typedarray = nullptr; napi_value undefined;
// create a JavaScript TypedArray NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
napi_status status = napi_create_typedarray(env, napi_int8_array, arrayBufferSize, arrayBuffer, 0, &typedarray); napi_value cb;
NAPI_ASSERT(env, status == napi_ok, "napi_create_typedarray success"); NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, functionRef, &cb));
bool isTypedArray = false; napi_value ret;
// Whether the given napi_value represents a TypedArray int32_t num = 0;
napi_is_typedarray(env, typedarray, &isTypedArray); NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, cb, 0, nullptr, &ret));
NAPI_ASSERT(env, isTypedArray, "the type is TypeArray"); NAPI_CALL_RETURN_VOID(env, napi_get_value_int32(env, ret, &num));
NAPI_ASSERT_RETURN_VOID(env, num == TAG_NUMBER, "CallJs fail");
}
static napi_value ThreadSafeTest(napi_env env, napi_callback_info info) {
size_t argc = 1;
napi_value js_cb, work_name;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &js_cb, NULL, NULL));
napi_create_reference(env, js_cb, 1, &functionRef);
NAPI_CALL(env, napi_create_string_utf8(env, "work_name", NAPI_AUTO_LENGTH, &work_name));
napi_valuetype valueType = napi_undefined;
NAPI_CALL(env, napi_typeof(env, js_cb, &valueType));
NAPI_ASSERT(env, valueType == napi_function, "valueType expect equal to napi_function");
// convert from N-API to C types const char context[] = "context";
napi_typedarray_type typedarrayType; NAPI_CALL(env, napi_create_threadsafe_function(
size_t typedarrayLength = 0; env, js_cb, NULL, work_name, 0, 1, NULL, NULL, (void*)context, CallJs, &tsfn));
void* typedarrayBufferPtr = nullptr; void* retContext = nullptr;
napi_value tmpArrayBuffer = nullptr; NAPI_CALL(env, napi_get_threadsafe_function_context(tsfn, &retContext));
size_t byteOffset = 0; NAPI_ASSERT(env, retContext == context, "napi_get_threadsafe_function_context failed");
// returns various properties of a typed array
napi_get_typedarray_info(env, typedarray, &typedarrayType, &typedarrayLength, &typedarrayBufferPtr, &tmpArrayBuffer, &byteOffset); napi_acquire_threadsafe_function(tsfn);
NAPI_ASSERT(env, typedarrayBufferPtr == arrayBufferPr, "napi_get_typedarray_info success"); napi_call_threadsafe_function(tsfn, NULL, napi_tsfn_blocking);
NAPI_ASSERT(env, arrayBufferSize == typedarrayLength, "napi_get_typedarray_info size success");
// return the value of success NAPI_CALL(env, napi_ref_threadsafe_function(env, tsfn));
NAPI_CALL(env, napi_unref_threadsafe_function(env, tsfn));
NAPI_CALL(env, napi_release_threadsafe_function(tsfn, napi_tsfn_release));
napi_value _value; napi_value _value;
NAPI_CALL(env, napi_create_int32(env, 0, &_value)); NAPI_CALL(env, napi_create_int32(env, 1, &_value));
return _value; return _value;
} }
...@@ -1646,81 +2106,81 @@ EXTERN_C_START ...@@ -1646,81 +2106,81 @@ EXTERN_C_START
static napi_value Init(napi_env env, napi_value exports) static napi_value Init(napi_env env, napi_value exports)
{ {
napi_property_descriptor properties[] = { DECLARE_NAPI_FUNCTION("getLastErrorInfo", getLastErrorInfo), napi_property_descriptor properties[] = {
DECLARE_NAPI_FUNCTION("cleanUpErrorInfo", cleanUpErrorInfo), DECLARE_NAPI_FUNCTION("getLastErrorInfo", getLastErrorInfo),
DECLARE_NAPI_FUNCTION("throwExistingError", throwExistingError), DECLARE_NAPI_FUNCTION("cleanUpErrorInfo", cleanUpErrorInfo),
DECLARE_NAPI_FUNCTION("throwError", throwError), DECLARE_NAPI_FUNCTION("throwExistingError", throwExistingError),
DECLARE_NAPI_FUNCTION("throwTypeError", throwTypeError), DECLARE_NAPI_FUNCTION("throwError", throwError),
DECLARE_NAPI_FUNCTION("throwRangeError", throwRangeError), DECLARE_NAPI_FUNCTION("throwTypeError", throwTypeError),
DECLARE_NAPI_FUNCTION("isError", isError), DECLARE_NAPI_FUNCTION("throwRangeError", throwRangeError),
DECLARE_NAPI_FUNCTION("createError", createError), DECLARE_NAPI_FUNCTION("isError", isError),
DECLARE_NAPI_FUNCTION("createTypeError", createTypeError), DECLARE_NAPI_FUNCTION("createError", createError),
DECLARE_NAPI_FUNCTION("createRangeError", createRangeError), DECLARE_NAPI_FUNCTION("createTypeError", createTypeError),
DECLARE_NAPI_FUNCTION("getAndClearLastException", getAndClearLastException), DECLARE_NAPI_FUNCTION("createRangeError", createRangeError),
DECLARE_NAPI_FUNCTION("isExceptionPending", isExceptionPending), DECLARE_NAPI_FUNCTION("getAndClearLastException", getAndClearLastException),
DECLARE_NAPI_FUNCTION("openAndCloseHandleScope", openAndCloseHandleScope), DECLARE_NAPI_FUNCTION("isExceptionPending", isExceptionPending),
DECLARE_NAPI_FUNCTION("openAndCloseEscapableHandleScope", openAndCloseEscapableHandleScope), DECLARE_NAPI_FUNCTION("openAndCloseHandleScope", openAndCloseHandleScope),
DECLARE_NAPI_FUNCTION("createReference", createReference), DECLARE_NAPI_FUNCTION("openAndCloseEscapableHandleScope", openAndCloseEscapableHandleScope),
DECLARE_NAPI_FUNCTION("deleteReference", deleteReference), DECLARE_NAPI_FUNCTION("createReference", createReference),
DECLARE_NAPI_FUNCTION("referenceRef", referenceRef), DECLARE_NAPI_FUNCTION("getAndDeleteReference", getAndDeleteReference),
DECLARE_NAPI_FUNCTION("referenceUnref", referenceUnref), DECLARE_NAPI_FUNCTION("referenceRefAndUnref", referenceRefAndUnref),
DECLARE_NAPI_FUNCTION("getReferenceValue", getReferenceValue), DECLARE_NAPI_FUNCTION("createArrayAndGetLength", createArrayAndGetLength),
DECLARE_NAPI_FUNCTION("createArrayAndGetLength", createArrayAndGetLength), DECLARE_NAPI_FUNCTION("getArrayWithLength", getArrayWithLength),
DECLARE_NAPI_FUNCTION("getArrayWithLength", getArrayWithLength), DECLARE_NAPI_FUNCTION("createExternal", createExternal),
DECLARE_NAPI_FUNCTION("createExternal", createExternal), DECLARE_NAPI_FUNCTION("createExternalArraybuffer", createExternalArraybuffer),
DECLARE_NAPI_FUNCTION("createExternalArraybuffer", createExternalArraybuffer), DECLARE_NAPI_FUNCTION("createObject", createObject),
DECLARE_NAPI_FUNCTION("createObject", createObject), DECLARE_NAPI_FUNCTION("createSymbol", createSymbol),
DECLARE_NAPI_FUNCTION("createSymbol", createSymbol), DECLARE_NAPI_FUNCTION("createTypeArray", createTypeArray),
DECLARE_NAPI_FUNCTION("createTypeArray", createTypeArray), DECLARE_NAPI_FUNCTION("createDataView", createDataView),
DECLARE_NAPI_FUNCTION("createDataView", createDataView), DECLARE_NAPI_FUNCTION("createAndGetInt32", createAndGetInt32),
DECLARE_NAPI_FUNCTION("createAndGetInt32", createAndGetInt32), DECLARE_NAPI_FUNCTION("createAndGetUInt32", createAndGetUInt32),
DECLARE_NAPI_FUNCTION("createAndGetUInt32", createAndGetUInt32), DECLARE_NAPI_FUNCTION("createAndGetInt64", createAndGetInt64),
DECLARE_NAPI_FUNCTION("createAndGetInt64", createAndGetInt64), DECLARE_NAPI_FUNCTION("createDouble", createDouble),
DECLARE_NAPI_FUNCTION("createDouble", createDouble), DECLARE_NAPI_FUNCTION("createAndGetStringLatin1", createAndGetStringLatin1),
DECLARE_NAPI_FUNCTION("createAndGetStringLatin1", createAndGetStringLatin1), DECLARE_NAPI_FUNCTION("createAndGetStringUtf8", createAndGetStringUtf8),
DECLARE_NAPI_FUNCTION("createAndGetStringUtf8", createAndGetStringUtf8), DECLARE_NAPI_FUNCTION("getPrototype", getPrototype),
DECLARE_NAPI_FUNCTION("getPrototype", getPrototype), DECLARE_NAPI_FUNCTION("getPrototype2", getPrototype2),
DECLARE_NAPI_FUNCTION("getDataViewInfo", getDataViewInfo), DECLARE_NAPI_FUNCTION("getTypedArrayInfo", getTypedArrayInfo),
DECLARE_NAPI_FUNCTION("getValueBool", getValueBool), DECLARE_NAPI_FUNCTION("getDataViewInfo", getDataViewInfo),
DECLARE_NAPI_FUNCTION("getValueDouble", getValueDouble), DECLARE_NAPI_FUNCTION("getValueBool", getValueBool),
DECLARE_NAPI_FUNCTION("getValueExternal", getValueExternal), DECLARE_NAPI_FUNCTION("getValueDouble", getValueDouble),
DECLARE_NAPI_FUNCTION("getNull", getNull), DECLARE_NAPI_FUNCTION("getValueExternal", getValueExternal),
DECLARE_NAPI_FUNCTION("getUndefined", getUndefined), DECLARE_NAPI_FUNCTION("getNull", getNull),
DECLARE_NAPI_FUNCTION("coerceToBool", coerceToBool), DECLARE_NAPI_FUNCTION("getUndefined", getUndefined),
DECLARE_NAPI_FUNCTION("coerceToNumber", coerceToNumber), DECLARE_NAPI_FUNCTION("coerceToBool", coerceToBool),
DECLARE_NAPI_FUNCTION("coerceToObject", coerceToObject), DECLARE_NAPI_FUNCTION("coerceToNumber", coerceToNumber),
DECLARE_NAPI_FUNCTION("coerceToString", coerceToString), DECLARE_NAPI_FUNCTION("coerceToObject", coerceToObject),
DECLARE_NAPI_FUNCTION("instanceOf", instanceOf), DECLARE_NAPI_FUNCTION("coerceToString", coerceToString),
DECLARE_NAPI_FUNCTION("isArray", isArray), DECLARE_NAPI_FUNCTION("instanceOf", instanceOf),
DECLARE_NAPI_FUNCTION("isDate", isDate), DECLARE_NAPI_FUNCTION("isArray", isArray),
DECLARE_NAPI_FUNCTION("strictEquals", strictEquals), DECLARE_NAPI_FUNCTION("isDate", isDate),
DECLARE_NAPI_FUNCTION("getPropertyNames", getPropertyNames), DECLARE_NAPI_FUNCTION("strictEquals", strictEquals),
DECLARE_NAPI_FUNCTION("setProperty", setProperty), DECLARE_NAPI_FUNCTION("getPropertyNames", getPropertyNames),
DECLARE_NAPI_FUNCTION("getProperty", getProperty), DECLARE_NAPI_FUNCTION("setProperty", setProperty),
DECLARE_NAPI_FUNCTION("hasProperty", hasProperty), DECLARE_NAPI_FUNCTION("getProperty", getProperty),
DECLARE_NAPI_FUNCTION("deleteProperty", deleteProperty), DECLARE_NAPI_FUNCTION("hasProperty", hasProperty),
DECLARE_NAPI_FUNCTION("hasOwnProperty", hasOwnProperty), DECLARE_NAPI_FUNCTION("setAndDeleteProperty", setAndDeleteProperty),
DECLARE_NAPI_FUNCTION("setNamedProperty", setNamedProperty), DECLARE_NAPI_FUNCTION("hasOwnProperty", hasOwnProperty),
DECLARE_NAPI_FUNCTION("getNamedProperty", getNamedProperty), DECLARE_NAPI_FUNCTION("setNamedProperty", setNamedProperty),
DECLARE_NAPI_FUNCTION("hasNamedProperty", hasNamedProperty), DECLARE_NAPI_FUNCTION("getNamedProperty", getNamedProperty),
DECLARE_NAPI_FUNCTION("setElement", setElement), DECLARE_NAPI_FUNCTION("hasNamedProperty", hasNamedProperty),
DECLARE_NAPI_FUNCTION("getElement", getElement), DECLARE_NAPI_FUNCTION("setElement", setElement),
DECLARE_NAPI_FUNCTION("hasElement", hasElement), DECLARE_NAPI_FUNCTION("getElement", getElement),
DECLARE_NAPI_FUNCTION("deleteElement", deleteElement), DECLARE_NAPI_FUNCTION("hasElement", hasElement),
DECLARE_NAPI_FUNCTION("defineProperties", defineProperties), DECLARE_NAPI_FUNCTION("deleteElement", deleteElement),
DECLARE_NAPI_FUNCTION("getNewTarget", getNewTarget), DECLARE_NAPI_FUNCTION("defineProperties", defineProperties),
DECLARE_NAPI_FUNCTION("wrap", wrap), DECLARE_NAPI_FUNCTION("wrap", wrap),
DECLARE_NAPI_FUNCTION("unwrap", unwrap), DECLARE_NAPI_FUNCTION("unwrap", unwrap),
DECLARE_NAPI_FUNCTION("removeWrap", removeWrap), DECLARE_NAPI_FUNCTION("removeWrap", removeWrap),
DECLARE_NAPI_FUNCTION("getVersion", getVersion), DECLARE_NAPI_FUNCTION("getVersion", getVersion),
DECLARE_NAPI_FUNCTION("createPromise", createPromise), DECLARE_NAPI_FUNCTION("createPromise", createPromise),
DECLARE_NAPI_FUNCTION("resolveAndRejectDeferred", resolveAndRejectDeferred), DECLARE_NAPI_FUNCTION("resolveAndRejectDeferred", resolveAndRejectDeferred),
DECLARE_NAPI_FUNCTION("isPromise", isPromise), DECLARE_NAPI_FUNCTION("isPromise", isPromise),
DECLARE_NAPI_FUNCTION("TestLatin1", TestLatin1), DECLARE_NAPI_FUNCTION("TestLatin1", TestLatin1),
DECLARE_NAPI_FUNCTION("runScript", runScript), DECLARE_NAPI_FUNCTION("runScript", runScript),
DECLARE_NAPI_FUNCTION("getUvEventLoop", getUvEventLoop),
DECLARE_NAPI_FUNCTION("napCreateArrayBuffer", napCreateArrayBuffer), DECLARE_NAPI_FUNCTION("napCreateArrayBuffer", napCreateArrayBuffer),
DECLARE_NAPI_FUNCTION("naiGetArrayBufferInfo", naiGetArrayBufferInfo), DECLARE_NAPI_FUNCTION("naiGetArrayBufferInfo", naiGetArrayBufferInfo),
DECLARE_NAPI_FUNCTION("napiNewInstance", napiNewInstance),
DECLARE_NAPI_FUNCTION("napiDefineClass", napiDefineClass), DECLARE_NAPI_FUNCTION("napiDefineClass", napiDefineClass),
DECLARE_NAPI_FUNCTION("napiRunScriptPath", napiRunScriptPath), DECLARE_NAPI_FUNCTION("napiRunScriptPath", napiRunScriptPath),
DECLARE_NAPI_FUNCTION("napiGetNodeVersion", napiGetNodeVersion), DECLARE_NAPI_FUNCTION("napiGetNodeVersion", napiGetNodeVersion),
...@@ -1731,29 +2191,40 @@ static napi_value Init(napi_env env, napi_value exports) ...@@ -1731,29 +2191,40 @@ static napi_value Init(napi_env env, napi_value exports)
DECLARE_NAPI_FUNCTION("napiCreateBigintUint64", napiCreateBigintUint64), DECLARE_NAPI_FUNCTION("napiCreateBigintUint64", napiCreateBigintUint64),
DECLARE_NAPI_FUNCTION("napiCreateBigintInt64", napiCreateBigintInt64), DECLARE_NAPI_FUNCTION("napiCreateBigintInt64", napiCreateBigintInt64),
DECLARE_NAPI_FUNCTION("napiCreateBigintWords", napiCreateBigintWords), DECLARE_NAPI_FUNCTION("napiCreateBigintWords", napiCreateBigintWords),
DECLARE_NAPI_FUNCTION("napiGetTypedarrayInfo", napiGetTypedarrayInfo), DECLARE_NAPI_FUNCTION("napiGetCbInfo", napiGetCbInfo),
{ "napiCancelAsyncWork", nullptr, napiCancelAsyncWork, nullptr, nullptr, nullptr, napi_default, nullptr }, { "napiCancelAsyncWork", nullptr, napiCancelAsyncWork, nullptr, nullptr, nullptr, napi_default, nullptr },
{ "testAsyncWork", nullptr, testAsyncWork, nullptr, nullptr, nullptr, napi_default, nullptr },
{ "testPromise", nullptr, testPromise, nullptr, nullptr, nullptr, napi_default, nullptr },
{ "napiCreateFunction", nullptr, napiCreateFunction, nullptr, nullptr, nullptr, napi_default, nullptr }, { "napiCreateFunction", nullptr, napiCreateFunction, nullptr, nullptr, nullptr, napi_default, nullptr },
DECLARE_NAPI_FUNCTION("napiFatalerror", napiFatalerror), }; DECLARE_NAPI_FUNCTION("getGlobal", getGlobal),
DECLARE_NAPI_FUNCTION("callFunction", callFunction),
DECLARE_NAPI_FUNCTION("ThreadSafeTest", ThreadSafeTest),
};
NAPI_CALL(env, napi_define_properties(env, exports, sizeof(properties) / sizeof(properties[0]), properties)); NAPI_CALL(env, napi_define_properties(env, exports, sizeof(properties) / sizeof(properties[0]), properties));
napi_property_descriptor descClass[] = {
DECLARE_NAPI_FUNCTION("sayHello", SayHello),
};
napi_value myClass;
napi_define_class(env, "myClass", NAPI_AUTO_LENGTH, MyConstructor, nullptr,
sizeof(descClass) / sizeof(descClass[0]), descClass, &myClass);
napi_set_named_property(env, exports, "myClass", myClass);
return exports; return exports;
} }
EXTERN_C_END EXTERN_C_END
static napi_module static napi_module demoModule = {
demoModule = { .nm_version = 1,
.nm_version = 1, .nm_flags = 0,
.nm_flags = 0, .nm_filename = nullptr,
.nm_filename = nullptr, .nm_register_func = Init,
.nm_register_func = Init, .nm_modname = "napitest",
.nm_modname = "napitest", .nm_priv = ((void *)0),
.nm_priv = ((void *)0), .reserved = {0},
.reserved = {
0 },
}; };
extern "C" __attribute__((constructor)) void RegisterModule(void) extern "C" __attribute__((constructor)) void RegisterModule(void)
{ {
napi_module_register(& demoModule); napi_module_register(&demoModule);
} }
arkui/ace_napi_test/entry/src/main/ets/test/List.test.ets
浏览文件 @ 0d5d5b9f
...@@ -13,9 +13,7 @@ ...@@ -13,9 +13,7 @@
* limitations under the License. * limitations under the License.
*/ */
import napiStringTest from './NativeApiStringTest'; import napiStringTest from './NativeApiStringTest';
import aceNapiEtsTest from './NapiEtsTest'
export default function testsuite() { export default function testsuite() {
napiStringTest() napiStringTest()
aceNapiEtsTest()
} }
\ No newline at end of file
arkui/ace_napi_test/entry/src/main/ets/test/NapiEtsTest.ets 已删除 100644 → 0
浏览文件 @ ab5a9fcb
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium'
import napitest from 'libnapitest.so'
export default function aceNapiEtsTest() {
describe('aceNapiEtsTest', function () {
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0100
* @tc.name aceNapiTest001
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest001', 0, async function (done) {
console.info('aceNapiTest001 START');
napitest.add_returned_status()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0110
* @tc.name aceNapiTest002
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest002', 0, async function (done) {
console.info('aceNapiTest002 START');
napitest.add_last_status()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0120
* @tc.name aceNapiTest003
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest003', 0, async function (done) {
console.info('aceNapiTest003 START');
napitest.getLastErrorInfo()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0130
* @tc.name aceNapiTest004
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest004', 0, async function (done) {
console.info('aceNapiTest004 START');
napitest.cleanUpErrorInfo()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0140
* @tc.name aceNapiTest005
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest005', 0, async function (done) {
console.info('aceNapiTest005 START');
napitest.throwExistingError()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0150
* @tc.name aceNapiTest006
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest006', 0, async function (done) {
console.info('aceNapiTest006 START');
napitest.throwError()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0160
* @tc.name aceNapiTest007
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest007', 0, async function (done) {
console.info('aceNapiTest007 START');
napitest.throwTypeError()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0170
* @tc.name aceNapiTest008
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest008', 0, async function (done) {
console.info('aceNapiTest008 START');
napitest.throwRangeError()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0180
* @tc.name aceNapiTest009
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest009', 0, async function (done) {
console.info('aceNapiTest009 START');
napitest.isError()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0190
* @tc.name aceNapiTest010
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest010', 0, async function (done) {
console.info('aceNapiTest010 START');
napitest.createError()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0200
* @tc.name aceNapiTest011
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest011', 0, async function (done) {
console.info('aceNapiTest011 START');
napitest.createTypeError()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0210
* @tc.name aceNapiTest012
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest012', 0, async function (done) {
console.info('aceNapiTest012 START');
napitest.createRangeError()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0220
* @tc.name aceNapiTest013
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest013', 0, async function (done) {
console.info('aceNapiTest013 START');
napitest.getAndClearLastException()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0230
* @tc.name aceNapiTest014
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest014', 0, async function (done) {
console.info('aceNapiTest014 START');
napitest.isExceptionPending()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0240
* @tc.name aceNapiTest015
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest015', 0, async function (done) {
console.info('aceNapiTest015 START');
napitest.openAndCloseHandleScope()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0250
* @tc.name aceNapiTest016
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest016', 0, async function (done) {
console.info('aceNapiTest016 START');
napitest.openAndCloseEscapableHandleScope()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0260
* @tc.name aceNapiTest017
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest017', 0, async function (done) {
console.info('aceNapiTest017 START');
napitest.createReference()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0270
* @tc.name aceNapiTest018
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest018', 0, async function (done) {
console.info('aceNapiTest018 START');
napitest.deleteReference()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0280
* @tc.name aceNapiTest019
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest019', 0, async function (done) {
console.info('aceNapiTest019 START');
napitest.referenceRef()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0290
* @tc.name aceNapiTest020
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest020', 0, async function (done) {
console.info('aceNapiTest020 START');
napitest.referenceUnref()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0300
* @tc.name aceNapiTest021
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest021', 0, async function (done) {
console.info('aceNapiTest021 START');
napitest.getReferenceValue()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0310
* @tc.name aceNapiTest022
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest022', 0, async function (done) {
console.info('aceNapiTest022 START');
napitest.createArrayAndGetLength()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0320
* @tc.name aceNapiTest023
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest023', 0, async function (done) {
console.info('aceNapiTest023 START');
napitest.getArrayWithLength()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0330
* @tc.name aceNapiTest024
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest024', 0, async function (done) {
console.info('aceNapiTest024 START');
napitest.finalizer()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0340
* @tc.name aceNapiTest025
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest025', 0, async function (done) {
console.info('aceNapiTest025 START');
napitest.createExternal()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0350
* @tc.name aceNapiTest026
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest026', 0, async function (done) {
console.info('aceNapiTest026 START');
napitest.createExternalArraybuffer()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0360
* @tc.name aceNapiTest027
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest027', 0, async function (done) {
console.info('aceNapiTest027 START');
napitest.createObject()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0370
* @tc.name aceNapiTest028
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest028', 0, async function (done) {
console.info('aceNapiTest028 START');
napitest.createSymbol()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0380
* @tc.name aceNapiTest029
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest029', 0, async function (done) {
console.info('aceNapiTest029 START');
napitest.createTypeArray()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0390
* @tc.name aceNapiTest030
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest030', 0, async function (done) {
console.info('aceNapiTest030 START');
napitest.createDataView()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0400
* @tc.name aceNapiTest031
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest031', 0, async function (done) {
console.info('aceNapiTest031 START');
napitest.createAndGetInt32()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0410
* @tc.name aceNapiTest032
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest032', 0, async function (done) {
console.info('aceNapiTest032 START');
napitest.createAndGetUInt32()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0420
* @tc.name aceNapiTest033
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest033', 0, async function (done) {
console.info('aceNapiTest033 START');
napitest.createAndGetInt64()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0430
* @tc.name aceNapiTest034
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest034', 0, async function (done) {
console.info('aceNapiTest034 START');
napitest.createDouble()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0440
* @tc.name aceNapiTest035
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest035', 0, async function (done) {
console.info('aceNapiTest035 START');
napitest.createAndGetStringLatin1()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0450
* @tc.name aceNapiTest036
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest036', 0, async function (done) {
console.info('aceNapiTest036 START');
napitest.createAndGetStringUtf8()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0460
* @tc.name aceNapiTest037
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest037', 0, async function (done) {
console.info('aceNapiTest037 START');
napitest.getPrototype()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0470
* @tc.name aceNapiTest038
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest038', 0, async function (done) {
console.info('aceNapiTest038 START');
napitest.getTypedArrayInfo()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0480
* @tc.name aceNapiTest039
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest039', 0, async function (done) {
console.info('aceNapiTest039 START');
napitest.getDataViewInfo()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0490
* @tc.name aceNapiTest040
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest040', 0, async function (done) {
console.info('aceNapiTest040 START');
napitest.getValueBool()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0500
* @tc.name aceNapiTest041
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest041', 0, async function (done) {
console.info('aceNapiTest041 START');
napitest.getValueDouble()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0510
* @tc.name aceNapiTest042
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest042', 0, async function (done) {
console.info('aceNapiTest042 START');
napitest.getValueExternal()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0520
* @tc.name aceNapiTest043
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest043', 0, async function (done) {
console.info('aceNapiTest043 START');
napitest.getNull()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0530
* @tc.name aceNapiTest044
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest044', 0, async function (done) {
console.info('aceNapiTest044 START');
napitest.getUndefined()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0540
* @tc.name aceNapiTest045
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest045', 0, async function (done) {
console.info('aceNapiTest045 START');
napitest.coerceToBool()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0550
* @tc.name aceNapiTest046
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest046', 0, async function (done) {
console.info('aceNapiTest046 START');
napitest.coerceToNumber()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0560
* @tc.name aceNapiTest047
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest047', 0, async function (done) {
console.info('aceNapiTest047 START');
napitest.coerceToObject()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0570
* @tc.name aceNapiTest048
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest048', 0, async function (done) {
console.info('aceNapiTest048 START');
napitest.coerceToString()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0580
* @tc.name aceNapiTest049
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest049', 0, async function (done) {
console.info('aceNapiTest049 START');
napitest.instanceOf()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0590
* @tc.name aceNapiTest050
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest050', 0, async function (done) {
console.info('aceNapiTest050 START');
napitest.isArray()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0600
* @tc.name aceNapiTest051
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest051', 0, async function (done) {
console.info('aceNapiTest051 START');
napitest.isDate()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0610
* @tc.name aceNapiTest052
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest052', 0, async function (done) {
console.info('aceNapiTest052 START');
napitest.strictEquals()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0620
* @tc.name aceNapiTest053
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest053', 0, async function (done) {
console.info('aceNapiTest053 START');
napitest.getPropertyNames()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0630
* @tc.name aceNapiTest054
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest054', 0, async function (done) {
console.info('aceNapiTest054 START');
napitest.setProperty()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0640
* @tc.name aceNapiTest055
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest055', 0, async function (done) {
console.info('aceNapiTest055 START');
napitest.getProperty()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0650
* @tc.name aceNapiTest056
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest056', 0, async function (done) {
console.info('aceNapiTest056 START');
napitest.hasProperty()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0660
* @tc.name aceNapiTest057
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest057', 0, async function (done) {
console.info('aceNapiTest057 START');
napitest.deleteProperty()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0670
* @tc.name aceNapiTest058
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest058', 0, async function (done) {
console.info('aceNapiTest058 START');
napitest.hasOwnProperty()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0680
* @tc.name aceNapiTest059
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest059', 0, async function (done) {
console.info('aceNapiTest059 START');
napitest.setNamedProperty()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0690
* @tc.name aceNapiTest060
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest060', 0, async function (done) {
console.info('aceNapiTest060 START');
napitest.getNamedProperty()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0700
* @tc.name aceNapiTest061
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest061', 0, async function (done) {
console.info('aceNapiTest061 START');
napitest.hasNamedProperty()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0710
* @tc.name aceNapiTest062
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest062', 0, async function (done) {
console.info('aceNapiTest062 START');
napitest.setElement()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0720
* @tc.name aceNapiTest063
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest063', 0, async function (done) {
console.info('aceNapiTest063 START');
napitest.getElement()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0730
* @tc.name aceNapiTest064
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest064', 0, async function (done) {
console.info('aceNapiTest064 START');
napitest.hasElement()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0740
* @tc.name aceNapiTest065
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest065', 0, async function (done) {
console.info('aceNapiTest065 START');
napitest.deleteElement()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0750
* @tc.name aceNapiTest066
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest066', 0, async function (done) {
console.info('aceNapiTest066 START');
napitest.defineProperties()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0760
* @tc.name aceNapiTest067
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest067', 0, async function (done) {
console.info('aceNapiTest067 START');
napitest.getNewTarget()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0770
* @tc.name aceNapiTest068
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest068', 0, async function (done) {
console.info('aceNapiTest068 START');
napitest.wrap()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0780
* @tc.name aceNapiTest069
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest069', 0, async function (done) {
console.info('aceNapiTest069 START');
napitest.unwrap()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0790
* @tc.name aceNapiTest070
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest070', 0, async function (done) {
console.info('aceNapiTest070 START');
napitest.removeWrap()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0800
* @tc.name aceNapiTest071
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest071', 0, async function (done) {
console.info('aceNapiTest071 START');
napitest.getVersion()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0810
* @tc.name aceNapiTest072
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest072', 0, async function (done) {
console.info('aceNapiTest072 START');
napitest.createPromise()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0820
* @tc.name aceNapiTest073
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest073', 0, async function (done) {
console.info('aceNapiTest073 START');
napitest.resolveAndRejectDeferred()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0830
* @tc.name aceNapiTest074
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest074', 0, async function (done) {
console.info('aceNapiTest074 START');
napitest.isPromise()
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0840
* @tc.name aceNapiTest075
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest075', 0, async function (done) {
console.info('aceNapiTest075 START');
napitest.runScript()
done();
});
})
}
\ No newline at end of file
arkui/ace_napi_test/entry/src/main/ets/test/NativeApiStringTest.ets
浏览文件 @ 0d5d5b9f
// @ts-nocheck
/* /*
* Copyright (c) 2021 Huawei Device Co., Ltd. * Copyright (c) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
...@@ -23,12 +22,13 @@ export default function nativeApiStringJsunit() { ...@@ -23,12 +22,13 @@ export default function nativeApiStringJsunit() {
describe('napiStringTest', function () { describe('napiStringTest', function () {
const empty = 'hh'; const empty = 'hh';
var value; let value;
let obj;
async function sleep(time) { async function sleep(time) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
setTimeout(() => { setTimeout(() => {
resolve() resolve("ok")
}, time) }, time)
}).then(() => { }).then(() => {
console.info( `sleep ${time} over...`) console.info( `sleep ${time} over...`)
...@@ -44,7 +44,7 @@ export default function nativeApiStringJsunit() { ...@@ -44,7 +44,7 @@ export default function nativeApiStringJsunit() {
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0100 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0001
* @tc.name napiStringTest001 * @tc.name napiStringTest001
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
...@@ -57,66 +57,53 @@ export default function nativeApiStringJsunit() { ...@@ -57,66 +57,53 @@ export default function nativeApiStringJsunit() {
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0200 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0002
* @tc.name napCreateArrayBuffer * @tc.name napCreateArrayBuffer002
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napCreateArrayBuffer002', 0, async function (done) { it('napiCreateArrayBuffer002', 0, async function (done) {
console.info('napiCreateArrayBuffer002 START'); console.info('napiCreateArrayBuffer002 START');
value = napitest.napCreateArrayBuffer(); value = napitest.napCreateArrayBuffer();
console.info('apiCreateArrayBuffer testString result is: ' + JSON.stringify(value)); console.info('napiCreateArrayBuffer testString result is: ' + JSON.stringify(value));
expect(value instanceof ArrayBuffer).assertTrue(); expect(value instanceof ArrayBuffer).assertTrue();
done(); done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0300 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0003
* @tc.name naiGetArrayBufferInfo * @tc.name naiGetArrayBufferInfo003
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('naiGetArrayBufferInfo003', 0, async function (done) { it('napiGetArrayBufferInfo003', 0, async function (done) {
console.info('naiGetArrayBufferInfo003 START'); console.info('napiGetArrayBufferInfo003 START');
value = napitest.naiGetArrayBufferInfo(); value = napitest.naiGetArrayBufferInfo();
console.info('naiGetArrayBufferInfo testString result is: ' + JSON.stringify(value)); console.info('napiGetArrayBufferInfo testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(1024); expect(value).assertEqual(1024);
done(); done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0400 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0004
* @tc.name napiCreateFunction * @tc.name napiCreateFunction004
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiCreateFunction004', 0, async function (done) { it('napiCreateFunction004', 0, async function (done) {
console.info('napiCreateFunction004 START'); console.info('napiCreateFunction004 START');
value = napitest.napiCreateFunction(); let func = napitest.napiCreateFunction();
value = func();
console.info('napiCreateFunction testString result is: ' + JSON.stringify(value)); console.info('napiCreateFunction testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(1); expect(value).assertEqual(666);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0500
* @tc.name napiNewInstance
* @tc.desc aceNapiEtsTest
*/
it('napiNewInstance005', 0, async function (done) {
console.info(' napiNewInstance005 START');
value = napitest.napiNewInstance('hello');
console.info('napiNewInstance testString result is: ' + JSON.stringify(value));
expect(value == undefined).assertTrue();
done(); done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0600 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0005
* @tc.name napiDefineClass * @tc.name napiDefineClass005
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiDefineClass006', 0, async function (done) { it('napiDefineClass005', 0, async function (done) {
console.info('napiDefineClass006 START'); console.info('napiDefineClass005 START');
value = napitest.napiDefineClass(); value = napitest.napiDefineClass();
console.info('napiDefineClass testString result is: ' + JSON.stringify(value)); console.info('napiDefineClass testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(0) expect(value).assertEqual(0)
...@@ -124,12 +111,12 @@ export default function nativeApiStringJsunit() { ...@@ -124,12 +111,12 @@ export default function nativeApiStringJsunit() {
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0700 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0006
* @tc.name napiCancelAsyncWork * @tc.name napiCancelAsyncWork006
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiCancelAsyncWork007', 0, async function (done) { it('napiCancelAsyncWork006', 0, async function (done) {
console.info('napiCancelAsyncWork007 START'); console.info('napiCancelAsyncWork006 START');
value = napitest.napiCancelAsyncWork(); value = napitest.napiCancelAsyncWork();
console.info('napiCancelAsyncWork testString result is: ' + JSON.stringify(value)); console.info('napiCancelAsyncWork testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(0) expect(value).assertEqual(0)
...@@ -137,134 +124,1219 @@ export default function nativeApiStringJsunit() { ...@@ -137,134 +124,1219 @@ export default function nativeApiStringJsunit() {
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0900 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0007
* @tc.name napiRunScriptPath * @tc.name napiRunScriptPath007
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiRunScriptPath009', 0, async function (done) { it('napiRunScriptPath007', 0, async function (done) {
console.info('napiRunScriptPath START'); console.info('napiRunScriptPath START');
value = napitest.napiRunScriptPath(); value = napitest.napiRunScriptPath();
console.info('napiRunScriptPath testString result is: ' + JSON.stringify(value)); console.info('napiRunScriptPath testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(0) expect(value).assertEqual(0)
done(); done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0100 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0008
* @tc.name napiCallThreadsafeFunction * @tc.name napiCallThreadsafeFunction008
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiCallThreadsafeFunction010', 0, async function (done) { it('napiCallThreadsafeFunction008', 0, async function (done) {
console.info('napiCallThreadsafeFunction START'); console.info('napiCallThreadsafeFunction START');
value = napitest.napiCallThreadsafeFunction(); value = napitest.napiCallThreadsafeFunction();
console.info('napiCallThreadsafeFunction testString result is: ' + JSON.stringify(value)); console.info('napiCallThreadsafeFunction testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(0) expect(value).assertEqual(0)
done(); done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0009
* @tc.name napiCreateThreadsafeFunction009
* @tc.desc aceNapiEtsTest
*/
it('napiCreateThreadsafeFunction009', 0, async function (done) {
console.info('napiCreateThreadsafeFunction START');
value = napitest.napiCreateThreadsafeFunction();
console.info('napiCreateThreadsafeFunction testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(0)
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0010
* @tc.name napiRefthreadSafeFunction010
* @tc.desc aceNapiEtsTest
*/
it('napiRefthreadSafeFunction010', 0, async function (done) {
console.info('napiRefthreadSafeFunction START');
value = napitest.napiRefthreadSafeFunction();
console.info('napiRefthreadSafeFunction testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(0)
done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0011 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0011
* @tc.name napiCreateThreadsafeFunction * @tc.name napiCreateDate011
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiCreateThreadsafeFunction011', 0, async function (done) { it('napiCreateDate011', 0, async function (done) {
console.info('napiCreateThreadsafeFunction START'); console.info('napiCreateDate START');
value = napitest.napiCreateThreadsafeFunction(); value = napitest.napiCreateDate();
console.info('napiCreateThreadsafeFunction testString result is: ' + JSON.stringify(value)); console.info('napiCreateDate testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(0) expect(value).assertEqual(1)
done(); done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0012 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0012
* @tc.name napiRefthreadSafeFunction * @tc.name napiCreateBigintUint64012
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiRefthreadSafeFunction012', 0, async function (done) { it('napiCreateBigintUint64012', 0, async function (done) {
console.info('napiRefthreadSafeFunction START'); console.info('napiCreateBigintUint64 START');
value = napitest.napiRefthreadSafeFunction(); value = napitest.napiCreateBigintUint64();
console.info('napiRefthreadSafeFunction testString result is: ' + JSON.stringify(value)); console.info('napiCreateBigintUint64 testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(0) expect(value).assertEqual(1)
done(); done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0013 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0013
* @tc.name napiCreateDate * @tc.name napiCreateBigintInt64013
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiCreateDate013', 0, async function (done) { it('napiCreateBigintInt64013', 0, async function (done) {
console.info('napiCreateDate START'); console.info('napiCreateBigintInt64 START');
value = napitest.napiCreateDate(); value = napitest.napiCreateBigintInt64();
console.info('napiCreateDate testString result is: ' + JSON.stringify(value)); console.info('napiCreateBigintInt64 testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(1) expect(value).assertEqual(1)
done(); done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0014 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0014
* @tc.name napiCreateBigintUint64 * @tc.name napiCreateBigintWords014
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiCreateBigintUint64014', 0, async function (done) { it('napiCreateBigintWords014', 0, async function (done) {
console.info('napiCreateBigintUint64 START'); console.info('napiCreateBigintWords START');
value = napitest.napiCreateBigintUint64(); value = napitest.napiCreateBigintWords();
console.info('napiCreateBigintUint64 testString result is: ' + JSON.stringify(value)); console.info('napiCreateBigintWords testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(1) expect(value).assertEqual(1)
done(); done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0015 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0015
* @tc.name napiCreateBigintInt64 * @tc.name napiGetCbInfo015
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiCreateBigintInt64015', 0, async function (done) { it('napiGetCbInfo015', 0, async function (done) {
console.info('napiCreateBigintInt64 START'); console.info('napiGetCbInfo015 START');
value = napitest.napiCreateBigintInt64(); value = napitest.napiGetCbInfo(12.06);
console.info('napiCreateBigintInt64 testString result is: ' + JSON.stringify(value)); console.info('napiGetCbInfo015 testString result is: ' + JSON.stringify(value));
expect(value).assertEqual(1) expect(value == 12.06).assertTrue
done(); done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0016
* @tc.name aceNapiTest016
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest016', 0, async function (done) {
console.info('aceNapiTest016 START');
value = napitest.referenceRefAndUnref();
console.info('aceNapiTest016 testString result is: ' + value + "---" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0017
* @tc.name napicreateSymbol017
* @tc.desc aceNapiEtsTest
*/
it('napicreateSymbol017', 0, async function (done) {
console.info('napicreateSymbol017 START');
let value = napitest.createSymbol('symbol');
console.info('napicreateSymbol017 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0018
* @tc.name napicreateAndGetInt018
* @tc.desc aceNapiEtsTest
*/
it('napicreateAndGetInt018', 0, async function (done) {
console.info('napicreateAndGetInt018 START');
let value = napitest.createAndGetInt64(6);
console.info('napicreateAndGetInt018 testString result is: '+ value + "---" + JSON.stringify(value));
expect(value).assertEqual(6);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0019
* @tc.name aceNapiTest019
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest019', 0, async function (done) {
console.info('aceNapiTest019 START');
value = napitest.getTypedArrayInfo();
console.info('aceNapiTest019 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0020
* @tc.name napigetDataView020
* @tc.desc aceNapiEtsTest
*/
it('napigetDataView020', 0, async function (done) {
console.info('napigetDataView020 START');
var buffer = new ArrayBuffer(2);
let dView = new DataView(buffer).setInt16(0, 256, true);
let value = napitest.getDataViewInfo(dView);
console.info('napigetDataView020 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0021
* @tc.name aceNapiTest021
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest021', 0, async function (done) {
console.info('aceNapiTest021 START');
let value = napitest.openAndCloseHandleScope();
console.info('aceNapiTest021 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value == undefined).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0022
* @tc.name aceNapiTest022
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest022', 0, async function (done) {
console.info('aceNapiTest022 START');
value = napitest.openAndCloseEscapableHandleScope();
console.info('aceNapiTest022 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof Object).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0023
* @tc.name aceNapiTest023
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest023', 0, async function (done) {
console.info('aceNapiTest023 START');
let value = napitest.createReference();
console.info('aceNapiTest023 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0024
* @tc.name aceNapiTest024
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest024', 0, async function (done) {
console.info('aceNapiTest024 START');
var array = [1,2];
let value = napitest.createArrayAndGetLength(array);
console.info('aceNapiTest024 testString result is: ' + value + "--" + JSON.stringify(value));
let obj = JSON.stringify(value);
expect(obj).assertEqual('[1,2]');
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0025
* @tc.name aceNapiTest025
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest025', 0, async function (done) {
console.info('aceNapiTest025 START');
let value = napitest.getArrayWithLength([1,2]);
console.info('aceNapiTest025 testString result is: ' + value + "--" + JSON.stringify(value));
obj = JSON.stringify(value);
expect(obj).assertEqual('[0,1,2,3]');
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0026
* @tc.name aceNapiTest026
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest026', 0, async function (done) {
console.info('aceNapiTest026 START');
let value = napitest.createExternal();
console.info('aceNapiTest026 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0027
* @tc.name aceNapiTest027
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest027', 0, async function (done) {
console.info('aceNapiTest027 START');
let value = napitest.createExternalArraybuffer();
console.info('aceNapiTest027 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof ArrayBuffer).assertTrue();
let view = new Int32Array(value);
expect(view[0]).assertEqual(666);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0028
* @tc.name aceNapiTest028
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest028', 0, async function (done) {
console.info('aceNapiTest028 START');
value = napitest.createObject();
console.info('aceNapiTest028 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof Object).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0029
* @tc.name aceNapiTest029
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest029', 0, async function (done) {
console.info('aceNapiTest029 START');
let value = napitest.createSymbol("teststr");
console.info('aceNapiTest029 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0030
* @tc.name aceNapiTest030
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest030', 0, async function (done) {
console.info('aceNapiTest030 START');
let value = napitest.createTypeArray();
console.info('aceNapiTest030 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof Int32Array).assertTrue();
expect(value.length).assertEqual(4);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0031
* @tc.name aceNapiTest031
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest031', 0, async function (done) {
console.info('aceNapiTest031 START');
let value = napitest.createDataView();
console.info('aceNapiTest031 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof DataView).assertTrue();
value.setInt16(1, 42);
expect(value.getInt16(1)).assertEqual(42);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0032
* @tc.name aceNapiTest032
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest032', 0, async function (done) {
console.info('aceNapiTest032 START');
let value = napitest.createAndGetInt32(32);
console.info('aceNapiTest032 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(32);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0033
* @tc.name aceNapiTest033
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest033', 0, async function (done) {
console.info('aceNapiTest033 START');
let value = napitest.createAndGetUInt32(12);
console.info('aceNapiTest033 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(12);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0034
* @tc.name aceNapiTest034
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest034', 0, async function (done) {
console.info('aceNapiTest034 START');
let value = napitest.createAndGetInt64(23);
console.info('aceNapiTest034 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(23);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0035
* @tc.name aceNapiTest035
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest035', 0, async function (done) {
console.info('aceNapiTest035 START');
let value = napitest.createDouble(24.67);
console.info('aceNapiTest035 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(24.67);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0036
* @tc.name aceNapiTest036
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest036', 0, async function (done) {
console.info('aceNapiTest036 START');
let value = napitest.createAndGetStringLatin1("tst");
console.info('aceNapiTest036 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual("tst");
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0037
* @tc.name aceNapiTest037
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest037', 0, async function (done) {
console.info('aceNapiTest037 START');
let value = napitest.createAndGetStringUtf8('he');
console.info('aceNapiTest037 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual('he');
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0038
* @tc.name aceNapiTest038
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest038', 0, async function (done) {
console.info('aceNapiTest038 START');
value = napitest.getPrototype();
console.info('aceNapiTest038 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof Object).assertTrue();
function testFunc() {
this.a = 0
}
value = napitest.getPrototype2(testFunc);
console.info('aceNapiTest038 testString result is: ' + value + "--" + JSON.stringify(value));
console.info('aceNapiTest038 testString Object.getPrototypeOf(testObj) is: ' + Object.getPrototypeOf(testFunc) + "--" + JSON.stringify(Object.getPrototypeOf(testFunc)));
expect(value === Object.getPrototypeOf(testFunc)).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0039
* @tc.name aceNapiTest039
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest039', 0, async function (done) {
console.info('aceNapiTest039 START');
let value = napitest.getValueBool(false);
console.info('aceNapiTest039 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertFalse();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0040
* @tc.name aceNapiTest040
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest040', 0, async function (done) {
console.info('aceNapiTest040 START');
value = napitest.getValueDouble(24.5);
console.info('aceNapiTest040 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value === 24.5).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0041
* @tc.name aceNapiTest041
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest041', 0, async function (done) {
console.info('aceNapiTest041 START');
let value = napitest.getValueExternal();
console.info('aceNapiTest041 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0042
* @tc.name aceNapiTest042
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest042', 0, async function (done) {
console.info('aceNapiTest042 START');
let value = napitest.getNull();
console.info('aceNapiTest042 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0043
* @tc.name aceNapiTest043
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest043', 0, async function (done) {
console.info('aceNapiTest043 START');
let value = napitest.getUndefined();
console.info('aceNapiTest043 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_00044
* @tc.name aceNapiTest044
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest044', 0, async function (done) {
console.info('aceNapiTest044 START');
value = napitest.coerceToBool(0);
console.info('aceNapiTest044 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertFalse();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0045
* @tc.name aceNapiTest045
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest045', 0, async function (done) {
console.info('aceNapiTest045 START');
value = napitest.coerceToNumber('12');
console.info('aceNapiTest045 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(12);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0046
* @tc.name aceNapiTest046
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest046', 0, async function (done) {
console.info('aceNapiTest046 START');
let value = napitest.coerceToObject([2,3]);
console.info('aceNapiTest046 testString result is: ' + value + "--" + JSON.stringify(value));
let obj = JSON.stringify(value);
expect(obj).assertEqual('[2,3]');
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0047
* @tc.name aceNapiTest047
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest047', 0, async function (done) {
console.info('aceNapiTest047 START');
value = napitest.coerceToString(123);
console.info('aceNapiTest047 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual('123');
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0048
* @tc.name aceNapiTest048
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest048', 0, async function (done) {
console.info('aceNapiTest048 START');
let value = napitest.instanceOf();
console.info('aceNapiTest048 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0049
* @tc.name aceNapiTest049
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest049', 0, async function (done) {
console.info('aceNapiTest049 START');
let value = napitest.isArray();
console.info('aceNapiTest049 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/* @tc.number SUB_ACE_BASIC_ETS_NAPI_0050
* @tc.name aceNapiTest050
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest050', 0, async function (done) {
console.info('aceNapiTest050 START');
const date1 = new Date('December 17, 1995 03:24:00');
value = napitest.isDate(date1);
console.info('aceNapiTest050 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0051
* @tc.name aceNapiTest051
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest051', 0, async function (done) {
console.info('aceNapiTest051 START');
let value = napitest.strictEquals();
console.info('aceNapiTest051 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0052
* @tc.name aceNapiTest052
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest052', 0, async function (done) {
console.info('aceNapiTest052 START');
let value = napitest.getPropertyNames();
console.info('aceNapiTest052 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0053
* @tc.name aceNapiTest053
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest053', 0, async function (done) {
console.info('aceNapiTest053 START');
let value = napitest.setProperty();
console.info('aceNapiTest053 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof Object).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0054
* @tc.name aceNapiTest054
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest054', 0, async function (done) {
console.info('aceNapiTest054 START');
let value = napitest.getProperty();
console.info('aceNapiTest054 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof Object).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0055
* @tc.name aceNapiTest055
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest055', 0, async function (done) {
console.info('aceNapiTest055 START');
let value = napitest.hasProperty();
console.info('aceNapiTest055 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0056
* @tc.name aceNapiTest056
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest056', 0, async function (done) {
console.info('aceNapiTest056 START');
let testObj = {
'a':1,
'b':2
}
value = napitest.setAndDeleteProperty(testObj, 'a');
console.info('aceNapiTest056 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value === 0).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0057
* @tc.name aceNapiTest057
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest057', 0, async function (done) {
console.info('aceNapiTest057 START');
let testObj = {
'a':1,
'b':2
}
value = napitest.hasOwnProperty(testObj, 'a');
console.info('aceNapiTest057 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertTrue();
done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0016 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0058
* @tc.name napiCreateBigintWords * @tc.name aceNapiTest058
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest058', 0, async function (done) {
console.info('aceNapiTest058 START');
let value = napitest.setNamedProperty([1,2], "e", false);
console.info('aceNapiTest058 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0059
* @tc.name aceNapiTest059
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest059', 0, async function (done) {
console.info('aceNapiTest059 START');
let obj = {
foo: "bar",
age: 42,
baz: { myProp: 12 },
};
let value = napitest.getNamedProperty(obj, "foo");
console.info('aceNapiTest059 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual('bar');
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0060
* @tc.name aceNapiTest060
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest060', 0, async function (done) {
console.info('aceNapiTest060 START');
let obj = {
foo: "bar",
age: 42,
baz: { myProp: 12 },
};
let value = napitest.hasNamedProperty(obj, "foo");
console.info('aceNapiTest060 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0061
* @tc.name aceNapiTest061
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest061', 0, async function (done) {
console.info('aceNapiTest061 START');
let value = napitest.setElement();
console.info('aceNapiTest061 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof Object).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0062
* @tc.name aceNapiTest062
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest062', 0, async function (done) {
console.info('aceNapiTest062 START');
let value = napitest.getElement();
console.info('aceNapiTest062 testString result is: ' + value + "--" + JSON.stringify(value));
let fi = value.envIsNull;
expect(value instanceof Object).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0063
* @tc.name aceNapiTest063
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest063', 0, async function (done) {
console.info('aceNapiTest063 START');
let value = napitest.hasElement();
console.info('aceNapiTest063 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof Object).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0064
* @tc.name aceNapiTest064
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest064', 0, async function (done) {
console.info('aceNapiTest064 START');
let value = napitest.deleteElement();
console.info('aceNapiTest064 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof Object).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0065
* @tc.name aceNapiTest065
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest065', 0, async function (done) {
console.info('aceNapiTest065 START');
let value = napitest.defineProperties();
console.info('aceNapiTest065 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value instanceof Object).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0066
* @tc.name aceNapiTest066
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest066', 0, async function (done) {
console.info('aceNapiTest066 START');
let value = napitest.wrap();
console.info('aceNapiTest066 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0067
* @tc.name aceNapiTest067
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest067', 0, async function (done) {
console.info('aceNapiTest067 START');
let value = napitest.unwrap();
console.info('aceNapiTest067 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0068
* @tc.name aceNapiTest068
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest068', 0, async function (done) {
console.info('aceNapiTest068 START');
let value = napitest.removeWrap();
console.info('aceNapiTest068 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0069
* @tc.name aceNapiTest069
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest069', 0, async function (done) {
console.info('aceNapiTest069 START');
let value = napitest.getVersion();
console.info('aceNapiTest069 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(2147483647 );
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0070
* @tc.name aceNapiTest070
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest070', 0, async function (done) {
console.info('aceNapiTest070 START');
let value = napitest.createPromise();
console.info('aceNapiTest070 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0071
* @tc.name aceNapiTest071
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest071', 0, async function (done) {
console.info('aceNapiTest071 START');
let value = napitest.resolveAndRejectDeferred();
console.info('aceNapiTest071 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0072
* @tc.name aceNapiTest072
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest072', 0, async function (done) {
console.info('aceNapiTest072 START');
let value = napitest.isPromise();
console.info('aceNapiTest072 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0073
* @tc.name aceNapiTest073
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest073', 0, async function (done) {
console.info('aceNapiTest073 START');
let value = napitest.runScript("25");
console.info('aceNapiTest073 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value == undefined).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0074
* @tc.name aceNapiTest074
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiCreateBigintWords016', 0, async function (done) { it('aceNapiTest074', 0, async function (done) {
console.info('napiCreateBigintWords START'); console.info('aceNapiTest074 START');
value = napitest.napiCreateBigintWords(); function testFunc() {
console.info('napiCreateBigintWords testString result is: ' + JSON.stringify(value)); return 666;
expect(value).assertEqual(0) }
done(); value = napitest.callFunction(testFunc);
console.info('aceNapiTest074 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value === 666).assertTrue();
done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0017 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0075
* @tc.name napiFatalerror * @tc.name aceNapiTest075
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiFatalerror017', 0, async function (done) { it('aceNapiTest075', 0, async function (done) {
console.info('napiFatalerror START'); console.info('aceNapiTest075 START');
value = napitest.napiFatalerror(); value = napitest.getUvEventLoop();
console.info('napiFatalerror testString result is: ' + JSON.stringify(value)); console.info('aceNapiTest075 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0) expect(value === undefined).assertTrue();
done(); done();
}); });
/** /**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0018 * @tc.number SUB_ACE_BASIC_ETS_NAPI_0076
* @tc.name napiGetTypedarrayInfo * @tc.name aceNapiTest076
* @tc.desc aceNapiEtsTest * @tc.desc aceNapiEtsTest
*/ */
it('napiGetTypedarrayInfo018', 0, async function (done) { it('aceNapiTest076', 0, async function (done) {
console.info('napiFatalerror START'); console.info('aceNapiTest076 START');
value = napitest.napiGetTypedarrayInfo(); let myClass = new napitest.myClass();
console.info('napiGetTypedarrayInfo testString result is: ' + JSON.stringify(value)); value = myClass.sayHello();
expect(value).assertEqual(0) console.info('aceNapiTest076 testString result is: ' + value + "--" + JSON.stringify(value));
done(); expect(value === 666).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0077
* @tc.name aceNapiTest077
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest077', 0, async function (done) {
console.info('aceNapiTest077 START');
value = napitest.getGlobal();
console.info('aceNapiTest077 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value === undefined).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0078
* @tc.name aceNapiTest078
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest078', 0, async function (done) {
console.info('aceNapiTest078 START');
value = napitest.testAsyncWork(1000, (input) => {
console.info('testAsyncWork ' + (input * 2));
return input * 2;
});
console.info('aceNapiTest078 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value === 0).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0079
* @tc.name aceNapiTest079
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest079', 0, async function (done) {
console.info('aceNapiTest079 START');
value = napitest.testPromise(1).then(
(result)=>{
console.info('aceNapiTest079 testString resolve1 result is: ' + result + "--" + JSON.stringify(result));
expect(result > 0).assertTrue();
done();
}, (result) =>{
console.info('aceNapiTest079 testString reject1 result is: ' + result + "--" + JSON.stringify(result));
expect(result < 0).assertTrue();
done();
}
);
value = napitest.testPromise(-1).then(
(result)=>{
console.info('aceNapiTest079 testString resolve2 result is: ' + result + "--" + JSON.stringify(result));
expect(result > 0).assertTrue();
done();
}, (result) =>{
console.info('aceNapiTest079 testString reject2 result is: ' + result + "--" + JSON.stringify(result));
expect(result < 0).assertTrue();
done();
}
);
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0080
* @tc.name aceNapiTest080
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest080', 0, async function (done) {
console.info('aceNapiTest080 START');
value = napitest.ThreadSafeTest(() => {
return 666;
});
expect(value === 1).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0081
* @tc.name aceNapiTest081
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest081', 0, async function (done) {
console.info('aceNapiTest081 START');
try {
napitest.getAndClearLastException();
console.info('aceNapiTest081 testString result is: ' + value + "--" + JSON.stringify(value));
} catch (err) {
console.info('aceNapiTest081 testString result is err: ' + err + "--" + JSON.stringify(err));
let er = JSON.stringify(err)
expect(er === '{"code":"600"}').assertTrue();
}
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0082
* @tc.name aceNapiTest082
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest082', 0, async function (done) {
console.info('aceNapiTest082 START');
let value = napitest.getLastErrorInfo();
console.info('aceNapiTest082 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(6);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0083
* @tc.name aceNapiTest083
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest083', 0, async function (done) {
console.info('aceNapiTest083 START');
let value = napitest.cleanUpErrorInfo();
console.info('aceNapiTest083 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertTrue();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0084
* @tc.name aceNapiTest084
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest084', 0, async function (done) {
console.info('aceNapiTest084 START');
try {
let value = napitest.throwExistingError();
console.info('aceNapiTest084 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
} catch (err) {
console.info('aceNapiTest084 testString result is err: ' + err + "--" + JSON.stringify(err));
let er = JSON.stringify(err)
expect(er).assertEqual('{"code":"600"}');
done();
}
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0085
* @tc.name aceNapiTest085
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest085', 0, async function (done) {
console.info('aceNapiTest085 START');
try {
let value = napitest.throwError();
console.info('aceNapiTest085 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
} catch (err) {
console.info('aceNapiTest085 testString result is err: ' + err + "--" + JSON.stringify(err));
let er = JSON.stringify(err)
expect(er).assertEqual('{"code":"500"}');
done();
}
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0086
* @tc.name aceNapiTest086
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest086', 0, async function (done) {
console.info('aceNapiTest086 START');
try {
let value = napitest.throwTypeError();
console.info('aceNapiTest086 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
} catch (err) {
console.info('aceNapiTest086 testString result is err: ' + err + "--" + JSON.stringify(err));
expect(err instanceof TypeError).assertTrue();
done();
}
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0087
* @tc.name aceNapiTest087
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest087', 0, async function (done) {
console.info('aceNapiTest087 START');
try {
let value = napitest.throwRangeError();
console.info('aceNapiTest087 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
} catch (err) {
console.info('aceNapiTest087 testString result is err: ' + err + "--" + JSON.stringify(err));
expect(err instanceof RangeError).assertTrue();
done();
}
}); });
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0088
* @tc.name aceNapiTest088
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest088', 0, async function (done) {
console.info('aceNapiTest088 START');
let value = napitest.isError(false);
console.info('aceNapiTest088 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertFalse();
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0089
* @tc.name aceNapiTest089
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest089', 0, async function (done) {
console.info('aceNapiTest089 START');
let value = napitest.createError();
console.info('aceNapiTest089 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0090
* @tc.name aceNapiTest090
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest090', 0, async function (done) {
console.info('aceNapiTest090 START');
let value = napitest.createTypeError();
console.info('aceNapiTest090 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0091
* @tc.name aceNapiTest091
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest091', 0, async function (done) {
console.info('aceNapiTest091 START');
let value = napitest.createRangeError();
console.info('aceNapiTest091 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
/**
* @tc.number SUB_ACE_BASIC_ETS_NAPI_0092
* @tc.name aceNapiTest092
* @tc.desc aceNapiEtsTest
*/
it('aceNapiTest092', 0, async function (done) {
console.info('aceNapiTest092 START');
let value = napitest.isExceptionPending();
console.info('aceNapiTest092 testString result is: ' + value + "--" + JSON.stringify(value));
expect(value).assertEqual(0);
done();
});
}) })
} }
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或