YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rework the public API (#4829)

Browse Source 
Related to #4186.

Some notable changes:
  - The term 'Error' now strictly refers to native Error objects defined in
    the ECMA standard, which are ordinary objects. All other uses of
    'error' or 'error reference' where the term refers to a thrown value is
    now called 'exception'.

  - Simplified the naming scheme of many String API functions. These functions
    will now also take an 'encoding' argument to specify the desired
    encoding in which to operate.

  - Removed the substring-copy-to-buffer functions. These functions
    behaved awkwardly, as they use character index to specify the
    start/end positions, and were mostly used incorrectly with byte
    offsets instead. The functionality can still be replicated with
    other functions if necessary.

  - String-to-buffer functions will no longer fail if the buffer is not
    sufficiently large, the string will instead be cropped.

  - Fixed the usage of the '_sz' prefix in many API functions. The term
    'sz' means zero-terminated string in hungarian notation, this was
    used incorrectly in many cases.

  - Renamed most of the public API functions to have shorter, more on-point
    names, rather than the often too long descriptive names. Functions are now
    also grouped by the type of value they operate on, where this makes
    sense.

JerryScript-DCO-1.0-Signed-off-by: Dániel Bátyai dbatyai@inf.u-szeged.hu
This commit is contained in:
Dániel Bátyai
2021-12-06 10:20:09 +01:00
committed by GitHub
parent 81d2319144
commit 9860d66a56
180 changed files with 10738 additions and 11025 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/debugger/do_abort.expected
+1 -1
View File
@@ -9,4 +9,4 @@ Stopped at tests/debugger/do_abort.js:20 (in g() at line:19, col:1)
(jerry-debugger) s
Stopped at tests/debugger/do_abort.js:16 (in f() at line:15, col:1)
(jerry-debugger) abort new Error('Fatal error :)')
err: Error: Fatal error :)
err: Unhandled exception: Error: Fatal error :)
tests/debugger/do_throw.expected
+1 -1
View File
@@ -17,4 +17,4 @@ Stopped at tests/debugger/do_throw.js:34
(jerry-debugger) eval e.message.length
538
(jerry-debugger) throw new Error('Exit')
err: Error: Exit
err: Unhandled exception: Error: Exit
tests/debugger/do_throw_adv.expected
+1 -1
View File
@@ -39,4 +39,4 @@ Exception throw detected (to disable automatic stop type exception 0)
Exception hint: 16
Stopped at tests/debugger/do_throw_adv.js:18 (in f() at line:17, col:1)
(jerry-debugger) c
err: 16
err: Unhandled exception: 16
tests/unit-core/test-abort.c
+26 -26
View File
@@ -25,8 +25,8 @@ callback_func (const jerry_call_info_t *call_info_p, const jerry_value_t args_p[
JERRY_UNUSED (args_p);
JERRY_UNUSED (args_count);
jerry_value_t value = jerry_create_string ((jerry_char_t *) "Abort run!");
value = jerry_create_abort_from_value (value, true);
jerry_value_t value = jerry_string_sz ("Abort run!");
value = jerry_throw_abort (value, true);
return value;
} /* callback_func */
@@ -37,16 +37,16 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t global = jerry_get_global_object ();
jerry_value_t callback_name = jerry_create_string ((jerry_char_t *) "callback");
jerry_value_t func = jerry_create_external_function (callback_func);
jerry_value_t res = jerry_set_property (global, callback_name, func);
TEST_ASSERT (!jerry_value_is_error (res));
jerry_value_t global = jerry_current_realm ();
jerry_value_t callback_name = jerry_string_sz ("callback");
jerry_value_t func = jerry_function_external (callback_func);
jerry_value_t res = jerry_object_set (global, callback_name, func);
TEST_ASSERT (!jerry_value_is_exception (res));
jerry_release_value (res);
jerry_release_value (func);
jerry_release_value (callback_name);
jerry_release_value (global);
jerry_value_free (res);
jerry_value_free (func);
jerry_value_free (callback_name);
jerry_value_free (global);
const jerry_char_t inf_loop_code_src1[] = TEST_STRING_LITERAL ("while(true) {\n"
" with ({}) {\n"
@@ -60,13 +60,13 @@ main (void)
jerry_value_t parsed_code_val = jerry_parse (inf_loop_code_src1, sizeof (inf_loop_code_src1) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
res = jerry_run (parsed_code_val);
TEST_ASSERT (jerry_value_is_abort (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_value_free (res);
jerry_value_free (parsed_code_val);
const jerry_char_t inf_loop_code_src2[] = TEST_STRING_LITERAL ("function f() {"
" while(true) {\n"
@@ -89,32 +89,32 @@ main (void)
parsed_code_val = jerry_parse (inf_loop_code_src2, sizeof (inf_loop_code_src2) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
res = jerry_run (parsed_code_val);
TEST_ASSERT (jerry_value_is_abort (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_value_free (res);
jerry_value_free (parsed_code_val);
/* Test flag overwrites. */
jerry_value_t value = jerry_create_string ((jerry_char_t *) "Error description");
jerry_value_t value = jerry_string_sz ("Error description");
TEST_ASSERT (!jerry_value_is_abort (value));
TEST_ASSERT (!jerry_value_is_error (value));
TEST_ASSERT (!jerry_value_is_exception (value));
value = jerry_create_abort_from_value (value, true);
value = jerry_throw_abort (value, true);
TEST_ASSERT (jerry_value_is_abort (value));
TEST_ASSERT (jerry_value_is_error (value));
TEST_ASSERT (jerry_value_is_exception (value));
value = jerry_create_error_from_value (value, true);
value = jerry_throw_value (value, true);
TEST_ASSERT (!jerry_value_is_abort (value));
TEST_ASSERT (jerry_value_is_error (value));
TEST_ASSERT (jerry_value_is_exception (value));
value = jerry_create_abort_from_value (value, true);
value = jerry_throw_abort (value, true);
TEST_ASSERT (jerry_value_is_abort (value));
TEST_ASSERT (jerry_value_is_error (value));
TEST_ASSERT (jerry_value_is_exception (value));
jerry_release_value (value);
jerry_value_free (value);
jerry_cleanup ();
return 0;
tests/unit-core/test-api-binary-operations-arithmetics.c
+131 -167
View File
@@ -35,7 +35,7 @@
typedef struct
{
jerry_binary_operation_t op;
jerry_binary_op_t op;
jerry_value_t lhs;
jerry_value_t rhs;
jerry_value_t expected;
@@ -43,7 +43,7 @@ typedef struct
typedef struct
{
jerry_binary_operation_t op;
jerry_binary_op_t op;
jerry_value_t lhs;
jerry_value_t rhs;
} test_nan_entry_t;
@@ -57,230 +57,194 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t obj1 = jerry_eval ((const jerry_char_t *) "o={x:1};o", 9, JERRY_PARSE_NO_OPTS);
jerry_value_t obj2 = jerry_eval ((const jerry_char_t *) "o={x:1};o", 9, JERRY_PARSE_NO_OPTS);
jerry_value_t err1 = jerry_create_error (JERRY_ERROR_SYNTAX, (const jerry_char_t *) "error");
jerry_value_t obj1 = jerry_eval ((jerry_char_t *) "o={x:1};o", 9, JERRY_PARSE_NO_OPTS);
jerry_value_t obj2 = jerry_eval ((jerry_char_t *) "o={x:1};o", 9, JERRY_PARSE_NO_OPTS);
jerry_value_t err1 = jerry_throw_sz (JERRY_ERROR_SYNTAX, "error");
test_nan_entry_t test_nans[] = {
/* Testing addition (+) */
T_NAN (JERRY_BIN_OP_ADD, jerry_create_number (3.1), jerry_create_undefined ()),
T_NAN (JERRY_BIN_OP_ADD, jerry_create_undefined (), jerry_create_undefined ()),
T_NAN (JERRY_BIN_OP_ADD, jerry_create_undefined (), jerry_create_null ()),
T_NAN (JERRY_BIN_OP_ADD, jerry_number (3.1), jerry_undefined ()),
T_NAN (JERRY_BIN_OP_ADD, jerry_undefined (), jerry_undefined ()),
T_NAN (JERRY_BIN_OP_ADD, jerry_undefined (), jerry_null ()),
/* Testing subtraction (-), multiplication (*), division (/), remainder (%) */
T_ARI (jerry_create_number (3.1), jerry_create_undefined ()),
T_ARI (jerry_create_string ((const jerry_char_t *) "foo"), jerry_create_string ((const jerry_char_t *) "bar")),
T_ARI (jerry_create_string ((const jerry_char_t *) "foo"), jerry_create_undefined ()),
T_ARI (jerry_create_string ((const jerry_char_t *) "foo"), jerry_create_null ()),
T_ARI (jerry_create_string ((const jerry_char_t *) "foo"), jerry_create_number (5.0)),
T_ARI (jerry_create_undefined (), jerry_create_string ((const jerry_char_t *) "foo")),
T_ARI (jerry_create_null (), jerry_create_string ((const jerry_char_t *) "foo")),
T_ARI (jerry_create_number (5.0), jerry_create_string ((const jerry_char_t *) "foo")),
T_ARI (jerry_create_undefined (), jerry_create_undefined ()),
T_ARI (jerry_create_undefined (), jerry_create_null ()),
T_ARI (jerry_create_null (), jerry_create_undefined ()),
T_ARI (jerry_acquire_value (obj1), jerry_acquire_value (obj1)),
T_ARI (jerry_acquire_value (obj1), jerry_acquire_value (obj2)),
T_ARI (jerry_acquire_value (obj2), jerry_acquire_value (obj1)),
T_ARI (jerry_acquire_value (obj2), jerry_create_undefined ()),
T_ARI (jerry_acquire_value (obj1), jerry_create_string ((const jerry_char_t *) "foo")),
T_ARI (jerry_acquire_value (obj1), jerry_create_null ()),
T_ARI (jerry_acquire_value (obj1), jerry_create_boolean (true)),
T_ARI (jerry_acquire_value (obj1), jerry_create_boolean (false)),
T_ARI (jerry_acquire_value (obj1), jerry_create_number (5.0)),
T_ARI (jerry_number (3.1), jerry_undefined ()),
T_ARI (jerry_string_sz ("foo"), jerry_string_sz ("bar")),
T_ARI (jerry_string_sz ("foo"), jerry_undefined ()),
T_ARI (jerry_string_sz ("foo"), jerry_null ()),
T_ARI (jerry_string_sz ("foo"), jerry_number (5.0)),
T_ARI (jerry_undefined (), jerry_string_sz ("foo")),
T_ARI (jerry_null (), jerry_string_sz ("foo")),
T_ARI (jerry_number (5.0), jerry_string_sz ("foo")),
T_ARI (jerry_undefined (), jerry_undefined ()),
T_ARI (jerry_undefined (), jerry_null ()),
T_ARI (jerry_null (), jerry_undefined ()),
T_ARI (jerry_value_copy (obj1), jerry_value_copy (obj1)),
T_ARI (jerry_value_copy (obj1), jerry_value_copy (obj2)),
T_ARI (jerry_value_copy (obj2), jerry_value_copy (obj1)),
T_ARI (jerry_value_copy (obj2), jerry_undefined ()),
T_ARI (jerry_value_copy (obj1), jerry_string_sz ("foo")),
T_ARI (jerry_value_copy (obj1), jerry_null ()),
T_ARI (jerry_value_copy (obj1), jerry_boolean (true)),
T_ARI (jerry_value_copy (obj1), jerry_boolean (false)),
T_ARI (jerry_value_copy (obj1), jerry_number (5.0)),
/* Testing division (/) */
T_NAN (JERRY_BIN_OP_DIV, jerry_create_boolean (false), jerry_create_boolean (false)),
T_NAN (JERRY_BIN_OP_DIV, jerry_create_number (0.0), jerry_create_number (0.0)),
T_NAN (JERRY_BIN_OP_DIV, jerry_create_null (), jerry_create_null ()),
T_NAN (JERRY_BIN_OP_DIV, jerry_boolean (false), jerry_boolean (false)),
T_NAN (JERRY_BIN_OP_DIV, jerry_number (0.0), jerry_number (0.0)),
T_NAN (JERRY_BIN_OP_DIV, jerry_null (), jerry_null ()),
/* Testing remainder (%) */
T_NAN (JERRY_BIN_OP_REM, jerry_create_boolean (true), jerry_create_boolean (false)),
T_NAN (JERRY_BIN_OP_REM, jerry_create_boolean (false), jerry_create_boolean (false)),
T_NAN (JERRY_BIN_OP_REM, jerry_create_number (0.0), jerry_create_number (0.0)),
T_NAN (JERRY_BIN_OP_REM, jerry_create_null (), jerry_create_null ()),
T_NAN (JERRY_BIN_OP_REM, jerry_boolean (true), jerry_boolean (false)),
T_NAN (JERRY_BIN_OP_REM, jerry_boolean (false), jerry_boolean (false)),
T_NAN (JERRY_BIN_OP_REM, jerry_number (0.0), jerry_number (0.0)),
T_NAN (JERRY_BIN_OP_REM, jerry_null (), jerry_null ()),
};
for (uint32_t idx = 0; idx < sizeof (test_nans) / sizeof (test_nan_entry_t); idx++)
{
jerry_value_t result = jerry_binary_operation (test_nans[idx].op, test_nans[idx].lhs, test_nans[idx].rhs);
jerry_value_t result = jerry_binary_op (test_nans[idx].op, test_nans[idx].lhs, test_nans[idx].rhs);
TEST_ASSERT (jerry_value_is_number (result));
double num = jerry_get_number_value (result);
double num = jerry_value_as_number (result);
TEST_ASSERT (num != num);
jerry_release_value (test_nans[idx].lhs);
jerry_release_value (test_nans[idx].rhs);
jerry_release_value (result);
jerry_value_free (test_nans[idx].lhs);
jerry_value_free (test_nans[idx].rhs);
jerry_value_free (result);
}
test_entry_t tests[] = {
/* Testing addition (+) */
T (JERRY_BIN_OP_ADD, jerry_create_number (5.0), jerry_create_number (5.0), jerry_create_number (10.0)),
T (JERRY_BIN_OP_ADD, jerry_create_number (3.1), jerry_create_number (10), jerry_create_number (13.1)),
T (JERRY_BIN_OP_ADD, jerry_create_number (3.1), jerry_create_boolean (true), jerry_create_number (4.1)),
T (JERRY_BIN_OP_ADD,
jerry_create_string ((const jerry_char_t *) "foo"),
jerry_create_string ((const jerry_char_t *) "bar"),
jerry_create_string ((const jerry_char_t *) "foobar")),
T (JERRY_BIN_OP_ADD,
jerry_create_string ((const jerry_char_t *) "foo"),
jerry_create_undefined (),
jerry_create_string ((const jerry_char_t *) "fooundefined")),
T (JERRY_BIN_OP_ADD,
jerry_create_string ((const jerry_char_t *) "foo"),
jerry_create_null (),
jerry_create_string ((const jerry_char_t *) "foonull")),
T (JERRY_BIN_OP_ADD,
jerry_create_string ((const jerry_char_t *) "foo"),
jerry_create_number (5.0),
jerry_create_string ((const jerry_char_t *) "foo5")),
T (JERRY_BIN_OP_ADD, jerry_number (5.0), jerry_number (5.0), jerry_number (10.0)),
T (JERRY_BIN_OP_ADD, jerry_number (3.1), jerry_number (10), jerry_number (13.1)),
T (JERRY_BIN_OP_ADD, jerry_number (3.1), jerry_boolean (true), jerry_number (4.1)),
T (JERRY_BIN_OP_ADD, jerry_string_sz ("foo"), jerry_string_sz ("bar"), jerry_string_sz ("foobar")),
T (JERRY_BIN_OP_ADD, jerry_string_sz ("foo"), jerry_undefined (), jerry_string_sz ("fooundefined")),
T (JERRY_BIN_OP_ADD, jerry_string_sz ("foo"), jerry_null (), jerry_string_sz ("foonull")),
T (JERRY_BIN_OP_ADD, jerry_string_sz ("foo"), jerry_number (5.0), jerry_string_sz ("foo5")),
T (JERRY_BIN_OP_ADD, jerry_create_null (), jerry_create_null (), jerry_create_number (0.0)),
T (JERRY_BIN_OP_ADD, jerry_create_boolean (true), jerry_create_boolean (true), jerry_create_number (2.0)),
T (JERRY_BIN_OP_ADD, jerry_create_boolean (true), jerry_create_boolean (false), jerry_create_number (1.0)),
T (JERRY_BIN_OP_ADD, jerry_create_boolean (false), jerry_create_boolean (true), jerry_create_number (1.0)),
T (JERRY_BIN_OP_ADD, jerry_create_boolean (false), jerry_create_boolean (false), jerry_create_number (0.0)),
T (JERRY_BIN_OP_ADD, jerry_null (), jerry_null (), jerry_number (0.0)),
T (JERRY_BIN_OP_ADD, jerry_boolean (true), jerry_boolean (true), jerry_number (2.0)),
T (JERRY_BIN_OP_ADD, jerry_boolean (true), jerry_boolean (false), jerry_number (1.0)),
T (JERRY_BIN_OP_ADD, jerry_boolean (false), jerry_boolean (true), jerry_number (1.0)),
T (JERRY_BIN_OP_ADD, jerry_boolean (false), jerry_boolean (false), jerry_number (0.0)),
T (JERRY_BIN_OP_ADD,
jerry_acquire_value (obj1),
jerry_acquire_value (obj1),
jerry_create_string ((const jerry_char_t *) "[object Object][object Object]")),
jerry_value_copy (obj1),
jerry_value_copy (obj1),
jerry_string_sz ("[object Object][object Object]")),
T (JERRY_BIN_OP_ADD,
jerry_acquire_value (obj1),
jerry_acquire_value (obj2),
jerry_create_string ((const jerry_char_t *) "[object Object][object Object]")),
jerry_value_copy (obj1),
jerry_value_copy (obj2),
jerry_string_sz ("[object Object][object Object]")),
T (JERRY_BIN_OP_ADD,
jerry_acquire_value (obj2),
jerry_acquire_value (obj1),
jerry_create_string ((const jerry_char_t *) "[object Object][object Object]")),
T (JERRY_BIN_OP_ADD,
jerry_acquire_value (obj1),
jerry_create_null (),
jerry_create_string ((const jerry_char_t *) "[object Object]null")),
T (JERRY_BIN_OP_ADD,
jerry_acquire_value (obj1),
jerry_create_undefined (),
jerry_create_string ((const jerry_char_t *) "[object Object]undefined")),
T (JERRY_BIN_OP_ADD,
jerry_acquire_value (obj1),
jerry_create_boolean (true),
jerry_create_string ((const jerry_char_t *) "[object Object]true")),
T (JERRY_BIN_OP_ADD,
jerry_acquire_value (obj1),
jerry_create_boolean (false),
jerry_create_string ((const jerry_char_t *) "[object Object]false")),
T (JERRY_BIN_OP_ADD,
jerry_acquire_value (obj1),
jerry_create_number (5.0),
jerry_create_string ((const jerry_char_t *) "[object Object]5")),
T (JERRY_BIN_OP_ADD,
jerry_acquire_value (obj1),
jerry_create_string ((const jerry_char_t *) "foo"),
jerry_create_string ((const jerry_char_t *) "[object Object]foo")),
jerry_value_copy (obj2),
jerry_value_copy (obj1),
jerry_string_sz ("[object Object][object Object]")),
T (JERRY_BIN_OP_ADD, jerry_value_copy (obj1), jerry_null (), jerry_string_sz ("[object Object]null")),
T (JERRY_BIN_OP_ADD, jerry_value_copy (obj1), jerry_undefined (), jerry_string_sz ("[object Object]undefined")),
T (JERRY_BIN_OP_ADD, jerry_value_copy (obj1), jerry_boolean (true), jerry_string_sz ("[object Object]true")),
T (JERRY_BIN_OP_ADD, jerry_value_copy (obj1), jerry_boolean (false), jerry_string_sz ("[object Object]false")),
T (JERRY_BIN_OP_ADD, jerry_value_copy (obj1), jerry_number (5.0), jerry_string_sz ("[object Object]5")),
T (JERRY_BIN_OP_ADD, jerry_value_copy (obj1), jerry_string_sz ("foo"), jerry_string_sz ("[object Object]foo")),
/* Testing subtraction (-) */
T (JERRY_BIN_OP_SUB, jerry_create_number (5.0), jerry_create_number (5.0), jerry_create_number (0.0)),
T (JERRY_BIN_OP_SUB, jerry_create_number (3.1), jerry_create_number (10), jerry_create_number (-6.9)),
T (JERRY_BIN_OP_SUB, jerry_create_number (3.1), jerry_create_boolean (true), jerry_create_number (2.1)),
T (JERRY_BIN_OP_SUB, jerry_create_boolean (true), jerry_create_boolean (true), jerry_create_number (0.0)),
T (JERRY_BIN_OP_SUB, jerry_create_boolean (true), jerry_create_boolean (false), jerry_create_number (1.0)),
T (JERRY_BIN_OP_SUB, jerry_create_boolean (false), jerry_create_boolean (true), jerry_create_number (-1.0)),
T (JERRY_BIN_OP_SUB, jerry_create_boolean (false), jerry_create_boolean (false), jerry_create_number (0.0)),
T (JERRY_BIN_OP_SUB, jerry_create_null (), jerry_create_null (), jerry_create_number (-0.0)),
T (JERRY_BIN_OP_SUB, jerry_number (5.0), jerry_number (5.0), jerry_number (0.0)),
T (JERRY_BIN_OP_SUB, jerry_number (3.1), jerry_number (10), jerry_number (-6.9)),
T (JERRY_BIN_OP_SUB, jerry_number (3.1), jerry_boolean (true), jerry_number (2.1)),
T (JERRY_BIN_OP_SUB, jerry_boolean (true), jerry_boolean (true), jerry_number (0.0)),
T (JERRY_BIN_OP_SUB, jerry_boolean (true), jerry_boolean (false), jerry_number (1.0)),
T (JERRY_BIN_OP_SUB, jerry_boolean (false), jerry_boolean (true), jerry_number (-1.0)),
T (JERRY_BIN_OP_SUB, jerry_boolean (false), jerry_boolean (false), jerry_number (0.0)),
T (JERRY_BIN_OP_SUB, jerry_null (), jerry_null (), jerry_number (-0.0)),
/* Testing multiplication (*) */
T (JERRY_BIN_OP_MUL, jerry_create_number (5.0), jerry_create_number (5.0), jerry_create_number (25.0)),
T (JERRY_BIN_OP_MUL, jerry_create_number (3.1), jerry_create_number (10), jerry_create_number (31)),
T (JERRY_BIN_OP_MUL, jerry_create_number (3.1), jerry_create_boolean (true), jerry_create_number (3.1)),
T (JERRY_BIN_OP_MUL, jerry_create_boolean (true), jerry_create_boolean (true), jerry_create_number (1.0)),
T (JERRY_BIN_OP_MUL, jerry_create_boolean (true), jerry_create_boolean (false), jerry_create_number (0.0)),
T (JERRY_BIN_OP_MUL, jerry_create_boolean (false), jerry_create_boolean (true), jerry_create_number (0.0)),
T (JERRY_BIN_OP_MUL, jerry_create_boolean (false), jerry_create_boolean (false), jerry_create_number (0.0)),
T (JERRY_BIN_OP_MUL, jerry_create_null (), jerry_create_null (), jerry_create_number (0.0)),
T (JERRY_BIN_OP_MUL, jerry_number (5.0), jerry_number (5.0), jerry_number (25.0)),
T (JERRY_BIN_OP_MUL, jerry_number (3.1), jerry_number (10), jerry_number (31)),
T (JERRY_BIN_OP_MUL, jerry_number (3.1), jerry_boolean (true), jerry_number (3.1)),
T (JERRY_BIN_OP_MUL, jerry_boolean (true), jerry_boolean (true), jerry_number (1.0)),
T (JERRY_BIN_OP_MUL, jerry_boolean (true), jerry_boolean (false), jerry_number (0.0)),
T (JERRY_BIN_OP_MUL, jerry_boolean (false), jerry_boolean (true), jerry_number (0.0)),
T (JERRY_BIN_OP_MUL, jerry_boolean (false), jerry_boolean (false), jerry_number (0.0)),
T (JERRY_BIN_OP_MUL, jerry_null (), jerry_null (), jerry_number (0.0)),
/* Testing division (/) */
T (JERRY_BIN_OP_DIV, jerry_create_number (5.0), jerry_create_number (5.0), jerry_create_number (1.0)),
T (JERRY_BIN_OP_DIV, jerry_create_number (3.1), jerry_create_number (10), jerry_create_number (0.31)),
T (JERRY_BIN_OP_DIV, jerry_create_number (3.1), jerry_create_boolean (true), jerry_create_number (3.1)),
T (JERRY_BIN_OP_DIV, jerry_create_boolean (true), jerry_create_boolean (true), jerry_create_number (1.0)),
T (JERRY_BIN_OP_DIV,
jerry_create_boolean (true),
jerry_create_boolean (false),
jerry_create_number_infinity (false)),
T (JERRY_BIN_OP_DIV, jerry_create_boolean (false), jerry_create_boolean (true), jerry_create_number (0.0)),
T (JERRY_BIN_OP_DIV, jerry_number (5.0), jerry_number (5.0), jerry_number (1.0)),
T (JERRY_BIN_OP_DIV, jerry_number (3.1), jerry_number (10), jerry_number (0.31)),
T (JERRY_BIN_OP_DIV, jerry_number (3.1), jerry_boolean (true), jerry_number (3.1)),
T (JERRY_BIN_OP_DIV, jerry_boolean (true), jerry_boolean (true), jerry_number (1.0)),
T (JERRY_BIN_OP_DIV, jerry_boolean (true), jerry_boolean (false), jerry_infinity (false)),
T (JERRY_BIN_OP_DIV, jerry_boolean (false), jerry_boolean (true), jerry_number (0.0)),
/* Testing remainder (%) */
T (JERRY_BIN_OP_REM, jerry_create_number (5.0), jerry_create_number (5.0), jerry_create_number (0.0)),
T (JERRY_BIN_OP_REM, jerry_create_number (5.0), jerry_create_number (2.0), jerry_create_number (1.0)),
T (JERRY_BIN_OP_REM, jerry_create_number (3.1), jerry_create_number (10), jerry_create_number (3.1)),
T (JERRY_BIN_OP_REM,
jerry_create_number (3.1),
jerry_create_boolean (true),
jerry_create_number (0.10000000000000009)),
T (JERRY_BIN_OP_REM, jerry_create_boolean (true), jerry_create_boolean (true), jerry_create_number (0.0)),
T (JERRY_BIN_OP_REM, jerry_create_boolean (false), jerry_create_boolean (true), jerry_create_number (0.0)),
T (JERRY_BIN_OP_REM, jerry_number (5.0), jerry_number (5.0), jerry_number (0.0)),
T (JERRY_BIN_OP_REM, jerry_number (5.0), jerry_number (2.0), jerry_number (1.0)),
T (JERRY_BIN_OP_REM, jerry_number (3.1), jerry_number (10), jerry_number (3.1)),
T (JERRY_BIN_OP_REM, jerry_number (3.1), jerry_boolean (true), jerry_number (0.10000000000000009)),
T (JERRY_BIN_OP_REM, jerry_boolean (true), jerry_boolean (true), jerry_number (0.0)),
T (JERRY_BIN_OP_REM, jerry_boolean (false), jerry_boolean (true), jerry_number (0.0)),
};
for (uint32_t idx = 0; idx < sizeof (tests) / sizeof (test_entry_t); idx++)
{
jerry_value_t result = jerry_binary_operation (tests[idx].op, tests[idx].lhs, tests[idx].rhs);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_value_t result = jerry_binary_op (tests[idx].op, tests[idx].lhs, tests[idx].rhs);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_t equals = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, result, tests[idx].expected);
jerry_value_t equals = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, result, tests[idx].expected);
TEST_ASSERT (jerry_value_is_boolean (equals) && jerry_value_is_true (equals));
jerry_release_value (equals);
jerry_value_free (equals);
jerry_release_value (tests[idx].lhs);
jerry_release_value (tests[idx].rhs);
jerry_release_value (tests[idx].expected);
jerry_release_value (result);
jerry_value_free (tests[idx].lhs);
jerry_value_free (tests[idx].rhs);
jerry_value_free (tests[idx].expected);
jerry_value_free (result);
}
jerry_value_t obj3 = jerry_eval ((const jerry_char_t *) "o={valueOf:function(){throw 5}};o", 33, JERRY_PARSE_NO_OPTS);
jerry_value_t obj3 = jerry_eval ((jerry_char_t *) "o={valueOf:function(){throw 5}};o", 33, JERRY_PARSE_NO_OPTS);
test_error_entry_t error_tests[] = {
/* Testing addition (+) */
T_ERR (JERRY_BIN_OP_ADD, jerry_acquire_value (err1), jerry_acquire_value (err1)),
T_ERR (JERRY_BIN_OP_ADD, jerry_acquire_value (err1), jerry_create_undefined ()),
T_ERR (JERRY_BIN_OP_ADD, jerry_create_undefined (), jerry_acquire_value (err1)),
T_ERR (JERRY_BIN_OP_ADD, jerry_value_copy (err1), jerry_value_copy (err1)),
T_ERR (JERRY_BIN_OP_ADD, jerry_value_copy (err1), jerry_undefined ()),
T_ERR (JERRY_BIN_OP_ADD, jerry_undefined (), jerry_value_copy (err1)),
/* Testing subtraction (-), multiplication (*), division (/), remainder (%) */
T_ARI (jerry_acquire_value (err1), jerry_acquire_value (err1)),
T_ARI (jerry_acquire_value (err1), jerry_create_undefined ()),
T_ARI (jerry_create_undefined (), jerry_acquire_value (err1)),
T_ARI (jerry_value_copy (err1), jerry_value_copy (err1)),
T_ARI (jerry_value_copy (err1), jerry_undefined ()),
T_ARI (jerry_undefined (), jerry_value_copy (err1)),
/* Testing addition (+) */
T_ERR (JERRY_BIN_OP_ADD, jerry_acquire_value (obj3), jerry_create_undefined ()),
T_ERR (JERRY_BIN_OP_ADD, jerry_acquire_value (obj3), jerry_create_null ()),
T_ERR (JERRY_BIN_OP_ADD, jerry_acquire_value (obj3), jerry_create_boolean (true)),
T_ERR (JERRY_BIN_OP_ADD, jerry_acquire_value (obj3), jerry_create_boolean (false)),
T_ERR (JERRY_BIN_OP_ADD, jerry_acquire_value (obj3), jerry_acquire_value (obj2)),
T_ERR (JERRY_BIN_OP_ADD, jerry_acquire_value (obj3), jerry_create_string ((const jerry_char_t *) "foo")),
T_ERR (JERRY_BIN_OP_ADD, jerry_value_copy (obj3), jerry_undefined ()),
T_ERR (JERRY_BIN_OP_ADD, jerry_value_copy (obj3), jerry_null ()),
T_ERR (JERRY_BIN_OP_ADD, jerry_value_copy (obj3), jerry_boolean (true)),
T_ERR (JERRY_BIN_OP_ADD, jerry_value_copy (obj3), jerry_boolean (false)),
T_ERR (JERRY_BIN_OP_ADD, jerry_value_copy (obj3), jerry_value_copy (obj2)),
T_ERR (JERRY_BIN_OP_ADD, jerry_value_copy (obj3), jerry_string_sz ("foo")),
/* Testing subtraction (-), multiplication (*), division (/), remainder (%) */
T_ARI (jerry_acquire_value (obj3), jerry_create_undefined ()),
T_ARI (jerry_acquire_value (obj3), jerry_create_null ()),
T_ARI (jerry_acquire_value (obj3), jerry_create_boolean (true)),
T_ARI (jerry_acquire_value (obj3), jerry_create_boolean (false)),
T_ARI (jerry_acquire_value (obj3), jerry_acquire_value (obj2)),
T_ARI (jerry_acquire_value (obj3), jerry_create_string ((const jerry_char_t *) "foo")),
T_ARI (jerry_value_copy (obj3), jerry_undefined ()),
T_ARI (jerry_value_copy (obj3), jerry_null ()),
T_ARI (jerry_value_copy (obj3), jerry_boolean (true)),
T_ARI (jerry_value_copy (obj3), jerry_boolean (false)),
T_ARI (jerry_value_copy (obj3), jerry_value_copy (obj2)),
T_ARI (jerry_value_copy (obj3), jerry_string_sz ("foo")),
};
for (uint32_t idx = 0; idx < sizeof (error_tests) / sizeof (test_error_entry_t); idx++)
{
jerry_value_t result = jerry_binary_operation (tests[idx].op, error_tests[idx].lhs, error_tests[idx].rhs);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (error_tests[idx].lhs);
jerry_release_value (error_tests[idx].rhs);
jerry_release_value (result);
jerry_value_t result = jerry_binary_op (tests[idx].op, error_tests[idx].lhs, error_tests[idx].rhs);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (error_tests[idx].lhs);
jerry_value_free (error_tests[idx].rhs);
jerry_value_free (result);
}
jerry_release_value (obj1);
jerry_release_value (obj2);
jerry_release_value (obj3);
jerry_release_value (err1);
jerry_value_free (obj1);
jerry_value_free (obj2);
jerry_value_free (obj3);
jerry_value_free (err1);
jerry_cleanup ();
tests/unit-core/test-api-binary-operations-comparisons.c
+133 -181
View File
@@ -24,7 +24,7 @@
typedef struct
{
jerry_binary_operation_t op;
jerry_binary_op_t op;
jerry_value_t lhs;
jerry_value_t rhs;
bool expected;
@@ -39,213 +39,165 @@ main (void)
jerry_value_t obj1 = jerry_eval ((const jerry_char_t *) "o={x:1};o", 9, JERRY_PARSE_NO_OPTS);
jerry_value_t obj2 = jerry_eval ((const jerry_char_t *) "o={x:1};o", 9, JERRY_PARSE_NO_OPTS);
jerry_value_t err1 = jerry_create_error (JERRY_ERROR_SYNTAX, (const jerry_char_t *) "error");
jerry_value_t err1 = jerry_throw_sz (JERRY_ERROR_SYNTAX, "error");
test_entry_t tests[] = {
/* Testing strict equal comparison */
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_number (5.0), jerry_create_number (5.0), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_number (3.1), jerry_create_number (10), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_number (3.1), jerry_create_undefined (), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_number (3.1), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_STRICT_EQUAL,
jerry_create_string ((const jerry_char_t *) "example string"),
jerry_create_string ((const jerry_char_t *) "example string"),
true),
T (JERRY_BIN_OP_STRICT_EQUAL,
jerry_create_string ((const jerry_char_t *) "example string"),
jerry_create_undefined (),
false),
T (JERRY_BIN_OP_STRICT_EQUAL,
jerry_create_string ((const jerry_char_t *) "example string"),
jerry_create_null (),
false),
T (JERRY_BIN_OP_STRICT_EQUAL,
jerry_create_string ((const jerry_char_t *) "example string"),
jerry_create_number (5.0),
false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_undefined (), jerry_create_undefined (), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_undefined (), jerry_create_null (), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_null (), jerry_create_null (), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_boolean (true), jerry_create_boolean (true), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_boolean (true), jerry_create_boolean (false), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_boolean (false), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_boolean (false), jerry_create_boolean (false), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_acquire_value (obj1), jerry_acquire_value (obj1), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_acquire_value (obj1), jerry_acquire_value (obj2), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_acquire_value (obj2), jerry_acquire_value (obj1), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_acquire_value (obj1), jerry_create_null (), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_acquire_value (obj1), jerry_create_undefined (), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_acquire_value (obj1), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_acquire_value (obj1), jerry_create_boolean (false), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_acquire_value (obj1), jerry_create_number (5.0), false),
T (JERRY_BIN_OP_STRICT_EQUAL,
jerry_acquire_value (obj1),
jerry_create_string ((const jerry_char_t *) "example string"),
false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_number (5.0), jerry_number (5.0), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_number (3.1), jerry_number (10), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_number (3.1), jerry_undefined (), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_number (3.1), jerry_boolean (true), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_string_sz ("example string"), jerry_string_sz ("example string"), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_string_sz ("example string"), jerry_undefined (), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_string_sz ("example string"), jerry_null (), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_string_sz ("example string"), jerry_number (5.0), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_undefined (), jerry_undefined (), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_undefined (), jerry_null (), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_null (), jerry_null (), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_boolean (true), jerry_boolean (true), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_boolean (true), jerry_boolean (false), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_boolean (false), jerry_boolean (true), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_boolean (false), jerry_boolean (false), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_value_copy (obj1), jerry_value_copy (obj1), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_value_copy (obj1), jerry_value_copy (obj2), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_value_copy (obj2), jerry_value_copy (obj1), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_value_copy (obj1), jerry_null (), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_value_copy (obj1), jerry_undefined (), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_value_copy (obj1), jerry_boolean (true), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_value_copy (obj1), jerry_boolean (false), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_value_copy (obj1), jerry_number (5.0), false),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_value_copy (obj1), jerry_string_sz ("example string"), false),
/* Testing equal comparison */
T (JERRY_BIN_OP_EQUAL, jerry_create_number (5.0), jerry_create_number (5.0), true),
T (JERRY_BIN_OP_EQUAL, jerry_create_number (3.1), jerry_create_number (10), false),
T (JERRY_BIN_OP_EQUAL, jerry_create_number (3.1), jerry_create_undefined (), false),
T (JERRY_BIN_OP_EQUAL, jerry_create_number (3.1), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_EQUAL,
jerry_create_string ((const jerry_char_t *) "example string"),
jerry_create_string ((const jerry_char_t *) "example string"),
true),
T (JERRY_BIN_OP_EQUAL,
jerry_create_string ((const jerry_char_t *) "example string"),
jerry_create_undefined (),
false),
T (JERRY_BIN_OP_EQUAL, jerry_create_string ((const jerry_char_t *) "example string"), jerry_create_null (), false),
T (JERRY_BIN_OP_EQUAL,
jerry_create_string ((const jerry_char_t *) "example string"),
jerry_create_number (5.0),
false),
T (JERRY_BIN_OP_EQUAL, jerry_create_undefined (), jerry_create_undefined (), true),
T (JERRY_BIN_OP_EQUAL, jerry_create_undefined (), jerry_create_null (), true),
T (JERRY_BIN_OP_EQUAL, jerry_create_null (), jerry_create_null (), true),
T (JERRY_BIN_OP_EQUAL, jerry_create_boolean (true), jerry_create_boolean (true), true),
T (JERRY_BIN_OP_EQUAL, jerry_create_boolean (true), jerry_create_boolean (false), false),
T (JERRY_BIN_OP_EQUAL, jerry_create_boolean (false), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_EQUAL, jerry_create_boolean (false), jerry_create_boolean (false), true),
T (JERRY_BIN_OP_EQUAL, jerry_acquire_value (obj1), jerry_acquire_value (obj1), true),
T (JERRY_BIN_OP_EQUAL, jerry_acquire_value (obj1), jerry_acquire_value (obj2), false),
T (JERRY_BIN_OP_EQUAL, jerry_acquire_value (obj2), jerry_acquire_value (obj1), false),
T (JERRY_BIN_OP_EQUAL, jerry_acquire_value (obj1), jerry_create_null (), false),
T (JERRY_BIN_OP_EQUAL, jerry_acquire_value (obj1), jerry_create_undefined (), false),
T (JERRY_BIN_OP_EQUAL, jerry_acquire_value (obj1), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_EQUAL, jerry_acquire_value (obj1), jerry_create_boolean (false), false),
T (JERRY_BIN_OP_EQUAL, jerry_acquire_value (obj1), jerry_create_number (5.0), false),
T (JERRY_BIN_OP_EQUAL,
jerry_acquire_value (obj1),
jerry_create_string ((const jerry_char_t *) "example string"),
false),
T (JERRY_BIN_OP_EQUAL, jerry_number (5.0), jerry_number (5.0), true),
T (JERRY_BIN_OP_EQUAL, jerry_number (3.1), jerry_number (10), false),
T (JERRY_BIN_OP_EQUAL, jerry_number (3.1), jerry_undefined (), false),
T (JERRY_BIN_OP_EQUAL, jerry_number (3.1), jerry_boolean (true), false),
T (JERRY_BIN_OP_EQUAL, jerry_string_sz ("example string"), jerry_string_sz ("example string"), true),
T (JERRY_BIN_OP_EQUAL, jerry_string_sz ("example string"), jerry_undefined (), false),
T (JERRY_BIN_OP_EQUAL, jerry_string_sz ("example string"), jerry_null (), false),
T (JERRY_BIN_OP_EQUAL, jerry_string_sz ("example string"), jerry_number (5.0), false),
T (JERRY_BIN_OP_EQUAL, jerry_undefined (), jerry_undefined (), true),
T (JERRY_BIN_OP_EQUAL, jerry_undefined (), jerry_null (), true),
T (JERRY_BIN_OP_EQUAL, jerry_null (), jerry_null (), true),
T (JERRY_BIN_OP_EQUAL, jerry_boolean (true), jerry_boolean (true), true),
T (JERRY_BIN_OP_EQUAL, jerry_boolean (true), jerry_boolean (false), false),
T (JERRY_BIN_OP_EQUAL, jerry_boolean (false), jerry_boolean (true), false),
T (JERRY_BIN_OP_EQUAL, jerry_boolean (false), jerry_boolean (false), true),
T (JERRY_BIN_OP_EQUAL, jerry_value_copy (obj1), jerry_value_copy (obj1), true),
T (JERRY_BIN_OP_EQUAL, jerry_value_copy (obj1), jerry_value_copy (obj2), false),
T (JERRY_BIN_OP_EQUAL, jerry_value_copy (obj2), jerry_value_copy (obj1), false),
T (JERRY_BIN_OP_EQUAL, jerry_value_copy (obj1), jerry_null (), false),
T (JERRY_BIN_OP_EQUAL, jerry_value_copy (obj1), jerry_undefined (), false),
T (JERRY_BIN_OP_EQUAL, jerry_value_copy (obj1), jerry_boolean (true), false),
T (JERRY_BIN_OP_EQUAL, jerry_value_copy (obj1), jerry_boolean (false), false),
T (JERRY_BIN_OP_EQUAL, jerry_value_copy (obj1), jerry_number (5.0), false),
T (JERRY_BIN_OP_EQUAL, jerry_value_copy (obj1), jerry_string_sz ("example string"), false),
/* Testing less comparison */
T (JERRY_BIN_OP_LESS, jerry_create_number (5.0), jerry_create_number (5.0), false),
T (JERRY_BIN_OP_LESS, jerry_create_number (3.1), jerry_create_number (10), true),
T (JERRY_BIN_OP_LESS, jerry_create_number (3.1), jerry_create_undefined (), false),
T (JERRY_BIN_OP_LESS, jerry_create_number (3.1), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_LESS,
jerry_create_string ((const jerry_char_t *) "1"),
jerry_create_string ((const jerry_char_t *) "2"),
true),
T (JERRY_BIN_OP_LESS, jerry_create_string ((const jerry_char_t *) "1"), jerry_create_undefined (), false),
T (JERRY_BIN_OP_LESS, jerry_create_string ((const jerry_char_t *) "1"), jerry_create_null (), false),
T (JERRY_BIN_OP_LESS, jerry_create_string ((const jerry_char_t *) "1"), jerry_create_number (5.0), true),
T (JERRY_BIN_OP_LESS, jerry_create_undefined (), jerry_create_undefined (), false),
T (JERRY_BIN_OP_LESS, jerry_create_undefined (), jerry_create_null (), false),
T (JERRY_BIN_OP_LESS, jerry_create_null (), jerry_create_null (), false),
T (JERRY_BIN_OP_LESS, jerry_create_boolean (true), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_LESS, jerry_create_boolean (true), jerry_create_boolean (false), false),
T (JERRY_BIN_OP_LESS, jerry_create_boolean (false), jerry_create_boolean (true), true),
T (JERRY_BIN_OP_LESS, jerry_create_boolean (false), jerry_create_boolean (false), false),
T (JERRY_BIN_OP_LESS, jerry_number (5.0), jerry_number (5.0), false),
T (JERRY_BIN_OP_LESS, jerry_number (3.1), jerry_number (10), true),
T (JERRY_BIN_OP_LESS, jerry_number (3.1), jerry_undefined (), false),
T (JERRY_BIN_OP_LESS, jerry_number (3.1), jerry_boolean (true), false),
T (JERRY_BIN_OP_LESS, jerry_string_sz ("1"), jerry_string_sz ("2"), true),
T (JERRY_BIN_OP_LESS, jerry_string_sz ("1"), jerry_undefined (), false),
T (JERRY_BIN_OP_LESS, jerry_string_sz ("1"), jerry_null (), false),
T (JERRY_BIN_OP_LESS, jerry_string_sz ("1"), jerry_number (5.0), true),
T (JERRY_BIN_OP_LESS, jerry_undefined (), jerry_undefined (), false),
T (JERRY_BIN_OP_LESS, jerry_undefined (), jerry_null (), false),
T (JERRY_BIN_OP_LESS, jerry_null (), jerry_null (), false),
T (JERRY_BIN_OP_LESS, jerry_boolean (true), jerry_boolean (true), false),
T (JERRY_BIN_OP_LESS, jerry_boolean (true), jerry_boolean (false), false),
T (JERRY_BIN_OP_LESS, jerry_boolean (false), jerry_boolean (true), true),
T (JERRY_BIN_OP_LESS, jerry_boolean (false), jerry_boolean (false), false),
/* Testing less or equal comparison */
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_number (5.0), jerry_create_number (5.0), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_number (5.1), jerry_create_number (5.0), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_number (3.1), jerry_create_number (10), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_number (3.1), jerry_create_undefined (), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_number (3.1), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_LESS_EQUAL,
jerry_create_string ((const jerry_char_t *) "1"),
jerry_create_string ((const jerry_char_t *) "2"),
true),
T (JERRY_BIN_OP_LESS_EQUAL,
jerry_create_string ((const jerry_char_t *) "1"),
jerry_create_string ((const jerry_char_t *) "1"),
true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_string ((const jerry_char_t *) "1"), jerry_create_undefined (), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_string ((const jerry_char_t *) "1"), jerry_create_null (), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_string ((const jerry_char_t *) "1"), jerry_create_number (5.0), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_string ((const jerry_char_t *) "5.0"), jerry_create_number (5.0), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_undefined (), jerry_create_undefined (), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_undefined (), jerry_create_null (), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_null (), jerry_create_null (), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_boolean (true), jerry_create_boolean (true), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_boolean (true), jerry_create_boolean (false), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_boolean (false), jerry_create_boolean (true), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_create_boolean (false), jerry_create_boolean (false), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_number (5.0), jerry_number (5.0), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_number (5.1), jerry_number (5.0), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_number (3.1), jerry_number (10), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_number (3.1), jerry_undefined (), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_number (3.1), jerry_boolean (true), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_string_sz ("1"), jerry_string_sz ("2"), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_string_sz ("1"), jerry_string_sz ("1"), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_string_sz ("1"), jerry_undefined (), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_string_sz ("1"), jerry_null (), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_string_sz ("1"), jerry_number (5.0), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_string_sz ("5.0"), jerry_number (5.0), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_undefined (), jerry_undefined (), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_undefined (), jerry_null (), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_null (), jerry_null (), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_boolean (true), jerry_boolean (true), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_boolean (true), jerry_boolean (false), false),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_boolean (false), jerry_boolean (true), true),
T (JERRY_BIN_OP_LESS_EQUAL, jerry_boolean (false), jerry_boolean (false), true),
/* Testing greater comparison */
T (JERRY_BIN_OP_GREATER, jerry_create_number (5.0), jerry_create_number (5.0), false),
T (JERRY_BIN_OP_GREATER, jerry_create_number (10), jerry_create_number (3.1), true),
T (JERRY_BIN_OP_GREATER, jerry_create_number (3.1), jerry_create_undefined (), false),
T (JERRY_BIN_OP_GREATER, jerry_create_number (3.1), jerry_create_boolean (true), true),
T (JERRY_BIN_OP_GREATER,
jerry_create_string ((const jerry_char_t *) "2"),
jerry_create_string ((const jerry_char_t *) "1"),
true),
T (JERRY_BIN_OP_GREATER,
jerry_create_string ((const jerry_char_t *) "1"),
jerry_create_string ((const jerry_char_t *) "2"),
false),
T (JERRY_BIN_OP_GREATER, jerry_create_string ((const jerry_char_t *) "1"), jerry_create_undefined (), false),
T (JERRY_BIN_OP_GREATER, jerry_create_string ((const jerry_char_t *) "1"), jerry_create_null (), true),
T (JERRY_BIN_OP_GREATER, jerry_create_number (5.0), jerry_create_string ((const jerry_char_t *) "1"), true),
T (JERRY_BIN_OP_GREATER, jerry_create_undefined (), jerry_create_undefined (), false),
T (JERRY_BIN_OP_GREATER, jerry_create_undefined (), jerry_create_null (), false),
T (JERRY_BIN_OP_GREATER, jerry_create_null (), jerry_create_null (), false),
T (JERRY_BIN_OP_GREATER, jerry_create_boolean (true), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_GREATER, jerry_create_boolean (true), jerry_create_boolean (false), true),
T (JERRY_BIN_OP_GREATER, jerry_create_boolean (false), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_GREATER, jerry_create_boolean (false), jerry_create_boolean (false), false),
T (JERRY_BIN_OP_GREATER, jerry_number (5.0), jerry_number (5.0), false),
T (JERRY_BIN_OP_GREATER, jerry_number (10), jerry_number (3.1), true),
T (JERRY_BIN_OP_GREATER, jerry_number (3.1), jerry_undefined (), false),
T (JERRY_BIN_OP_GREATER, jerry_number (3.1), jerry_boolean (true), true),
T (JERRY_BIN_OP_GREATER, jerry_string_sz ("2"), jerry_string_sz ("1"), true),
T (JERRY_BIN_OP_GREATER, jerry_string_sz ("1"), jerry_string_sz ("2"), false),
T (JERRY_BIN_OP_GREATER, jerry_string_sz ("1"), jerry_undefined (), false),
T (JERRY_BIN_OP_GREATER, jerry_string_sz ("1"), jerry_null (), true),
T (JERRY_BIN_OP_GREATER, jerry_number (5.0), jerry_string_sz ("1"), true),
T (JERRY_BIN_OP_GREATER, jerry_undefined (), jerry_undefined (), false),
T (JERRY_BIN_OP_GREATER, jerry_undefined (), jerry_null (), false),
T (JERRY_BIN_OP_GREATER, jerry_null (), jerry_null (), false),
T (JERRY_BIN_OP_GREATER, jerry_boolean (true), jerry_boolean (true), false),
T (JERRY_BIN_OP_GREATER, jerry_boolean (true), jerry_boolean (false), true),
T (JERRY_BIN_OP_GREATER, jerry_boolean (false), jerry_boolean (true), false),
T (JERRY_BIN_OP_GREATER, jerry_boolean (false), jerry_boolean (false), false),
/* Testing greater or equal comparison */
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_number (5.0), jerry_create_number (5.0), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_number (5.0), jerry_create_number (5.1), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_number (10), jerry_create_number (3.1), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_number (3.1), jerry_create_undefined (), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_number (3.1), jerry_create_boolean (true), true),
T (JERRY_BIN_OP_GREATER_EQUAL,
jerry_create_string ((const jerry_char_t *) "2"),
jerry_create_string ((const jerry_char_t *) "1"),
true),
T (JERRY_BIN_OP_GREATER_EQUAL,
jerry_create_string ((const jerry_char_t *) "1"),
jerry_create_string ((const jerry_char_t *) "1"),
true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_string ((const jerry_char_t *) "1"), jerry_create_undefined (), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_string ((const jerry_char_t *) "1"), jerry_create_null (), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_number (5.0), jerry_create_string ((const jerry_char_t *) "1"), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_string ((const jerry_char_t *) "5.0"), jerry_create_number (5.0), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_undefined (), jerry_create_undefined (), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_undefined (), jerry_create_null (), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_null (), jerry_create_null (), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_boolean (true), jerry_create_boolean (true), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_boolean (true), jerry_create_boolean (false), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_boolean (false), jerry_create_boolean (true), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_create_boolean (false), jerry_create_boolean (false), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_number (5.0), jerry_number (5.0), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_number (5.0), jerry_number (5.1), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_number (10), jerry_number (3.1), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_number (3.1), jerry_undefined (), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_number (3.1), jerry_boolean (true), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_string_sz ("2"), jerry_string_sz ("1"), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_string_sz ("1"), jerry_string_sz ("1"), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_string_sz ("1"), jerry_undefined (), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_string_sz ("1"), jerry_null (), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_number (5.0), jerry_string_sz ("1"), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_string_sz ("5.0"), jerry_number (5.0), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_undefined (), jerry_undefined (), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_undefined (), jerry_null (), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_null (), jerry_null (), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_boolean (true), jerry_boolean (true), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_boolean (true), jerry_boolean (false), true),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_boolean (false), jerry_boolean (true), false),
T (JERRY_BIN_OP_GREATER_EQUAL, jerry_boolean (false), jerry_boolean (false), true),
};
for (uint32_t idx = 0; idx < sizeof (tests) / sizeof (test_entry_t); idx++)
{
jerry_value_t result = jerry_binary_operation (tests[idx].op, tests[idx].lhs, tests[idx].rhs);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_value_t result = jerry_binary_op (tests[idx].op, tests[idx].lhs, tests[idx].rhs);
TEST_ASSERT (!jerry_value_is_exception (result));
TEST_ASSERT (jerry_value_is_true (result) == tests[idx].expected);
jerry_release_value (tests[idx].lhs);
jerry_release_value (tests[idx].rhs);
jerry_release_value (result);
jerry_value_free (tests[idx].lhs);
jerry_value_free (tests[idx].rhs);
jerry_value_free (result);
}
test_entry_t error_tests[] = {
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_acquire_value (err1), jerry_acquire_value (err1), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_acquire_value (err1), jerry_create_undefined (), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_create_undefined (), jerry_acquire_value (err1), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_value_copy (err1), jerry_value_copy (err1), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_value_copy (err1), jerry_undefined (), true),
T (JERRY_BIN_OP_STRICT_EQUAL, jerry_undefined (), jerry_value_copy (err1), true),
};
for (uint32_t idx = 0; idx < sizeof (error_tests) / sizeof (test_entry_t); idx++)
{
jerry_value_t result = jerry_binary_operation (tests[idx].op, error_tests[idx].lhs, error_tests[idx].rhs);
TEST_ASSERT (jerry_value_is_error (result) == error_tests[idx].expected);
jerry_release_value (error_tests[idx].lhs);
jerry_release_value (error_tests[idx].rhs);
jerry_release_value (result);
jerry_value_t result = jerry_binary_op (tests[idx].op, error_tests[idx].lhs, error_tests[idx].rhs);
TEST_ASSERT (jerry_value_is_exception (result) == error_tests[idx].expected);
jerry_value_free (error_tests[idx].lhs);
jerry_value_free (error_tests[idx].rhs);
jerry_value_free (result);
}
jerry_release_value (obj1);
jerry_release_value (obj2);
jerry_release_value (err1);
jerry_value_free (obj1);
jerry_value_free (obj2);
jerry_value_free (err1);
jerry_cleanup ();
tests/unit-core/test-api-binary-operations-instanceof.c
+43 -47
View File
@@ -37,7 +37,7 @@ my_constructor (const jerry_call_info_t *call_info_p, /**< call information */
(void) call_info_p;
(void) argv;
(void) argc;
return jerry_create_undefined ();
return jerry_undefined ();
} /* my_constructor */
int
@@ -47,68 +47,64 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t base_obj = jerry_create_object ();
jerry_value_t constructor = jerry_create_external_function (my_constructor);
jerry_value_t base_obj = jerry_object ();
jerry_value_t constructor = jerry_function_external (my_constructor);
jerry_value_t no_proto_instance_val = jerry_construct_object (constructor, NULL, 0);
jerry_value_t no_proto_instance_val = jerry_construct (constructor, NULL, 0);
jerry_value_t prototype_str = jerry_create_string ((const jerry_char_t *) "prototype");
jerry_value_t res = jerry_set_property (constructor, prototype_str, base_obj);
jerry_release_value (prototype_str);
TEST_ASSERT (!jerry_value_is_error (res));
jerry_release_value (res);
jerry_value_t prototype_str = jerry_string_sz ("prototype");
jerry_value_t res = jerry_object_set (constructor, prototype_str, base_obj);
jerry_value_free (prototype_str);
TEST_ASSERT (!jerry_value_is_exception (res));
jerry_value_free (res);
jerry_value_t instance_val = jerry_construct_object (constructor, NULL, 0);
jerry_value_t instance_val = jerry_construct (constructor, NULL, 0);
jerry_value_t error = jerry_create_error_from_value (base_obj, false);
jerry_value_t error = jerry_throw_value (base_obj, false);
test_entry_t bool_tests[] = {
T (jerry_acquire_value (instance_val), jerry_acquire_value (constructor), true),
T (jerry_acquire_value (no_proto_instance_val), jerry_acquire_value (constructor), false),
T (jerry_acquire_value (base_obj), jerry_acquire_value (constructor), false)
};
test_entry_t bool_tests[] = { T (jerry_value_copy (instance_val), jerry_value_copy (constructor), true),
T (jerry_value_copy (no_proto_instance_val), jerry_value_copy (constructor), false),
T (jerry_value_copy (base_obj), jerry_value_copy (constructor), false) };
for (uint32_t idx = 0; idx < sizeof (bool_tests) / sizeof (test_entry_t); idx++)
{
jerry_value_t result = jerry_binary_operation (JERRY_BIN_OP_INSTANCEOF, bool_tests[idx].lhs, bool_tests[idx].rhs);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_value_t result = jerry_binary_op (JERRY_BIN_OP_INSTANCEOF, bool_tests[idx].lhs, bool_tests[idx].rhs);
TEST_ASSERT (!jerry_value_is_exception (result));
TEST_ASSERT (jerry_value_is_true (result) == bool_tests[idx].expected);
jerry_release_value (bool_tests[idx].lhs);
jerry_release_value (bool_tests[idx].rhs);
jerry_release_value (result);
jerry_value_free (bool_tests[idx].lhs);
jerry_value_free (bool_tests[idx].rhs);
jerry_value_free (result);
}
test_entry_t error_tests[] = {
T (jerry_acquire_value (constructor), jerry_acquire_value (instance_val), true),
T (jerry_create_undefined (), jerry_acquire_value (constructor), true),
T (jerry_acquire_value (instance_val), jerry_create_undefined (), true),
T (jerry_acquire_value (instance_val), jerry_acquire_value (base_obj), true),
T (jerry_acquire_value (error), jerry_acquire_value (constructor), true),
T (jerry_acquire_value (instance_val), jerry_acquire_value (error), true),
T (jerry_create_string ((const jerry_char_t *) ""), jerry_create_string ((const jerry_char_t *) ""), true),
T (jerry_create_string ((const jerry_char_t *) ""), jerry_create_number (5.0), true),
T (jerry_create_number (5.0), jerry_create_string ((const jerry_char_t *) ""), true),
T (jerry_create_array (1), jerry_create_array (1), true),
T (jerry_create_array (1), jerry_create_object (), true),
T (jerry_create_object (), jerry_create_array (1), true),
T (jerry_create_null (), jerry_create_object (), true),
T (jerry_create_object (), jerry_create_string ((const jerry_char_t *) ""), true)
};
test_entry_t error_tests[] = { T (jerry_value_copy (constructor), jerry_value_copy (instance_val), true),
T (jerry_undefined (), jerry_value_copy (constructor), true),
T (jerry_value_copy (instance_val), jerry_undefined (), true),
T (jerry_value_copy (instance_val), jerry_value_copy (base_obj), true),
T (jerry_value_copy (error), jerry_value_copy (constructor), true),
T (jerry_value_copy (instance_val), jerry_value_copy (error), true),
T (jerry_string_sz (""), jerry_string_sz (""), true),
T (jerry_string_sz (""), jerry_number (5.0), true),
T (jerry_number (5.0), jerry_string_sz (""), true),
T (jerry_array (1), jerry_array (1), true),
T (jerry_array (1), jerry_object (), true),
T (jerry_object (), jerry_array (1), true),
T (jerry_null (), jerry_object (), true),
T (jerry_object (), jerry_string_sz (""), true) };
for (uint32_t idx = 0; idx < sizeof (error_tests) / sizeof (test_entry_t); idx++)
{
jerry_value_t result = jerry_binary_operation (JERRY_BIN_OP_INSTANCEOF, error_tests[idx].lhs, error_tests[idx].rhs);
TEST_ASSERT (jerry_value_is_error (result) == error_tests[idx].expected);
jerry_release_value (error_tests[idx].lhs);
jerry_release_value (error_tests[idx].rhs);
jerry_release_value (result);
jerry_value_t result = jerry_binary_op (JERRY_BIN_OP_INSTANCEOF, error_tests[idx].lhs, error_tests[idx].rhs);
TEST_ASSERT (jerry_value_is_exception (result) == error_tests[idx].expected);
jerry_value_free (error_tests[idx].lhs);
jerry_value_free (error_tests[idx].rhs);
jerry_value_free (result);
}
jerry_release_value (base_obj);
jerry_release_value (constructor);
jerry_release_value (error);
jerry_release_value (instance_val);
jerry_release_value (no_proto_instance_val);
jerry_value_free (base_obj);
jerry_value_free (constructor);
jerry_value_free (error);
jerry_value_free (instance_val);
jerry_value_free (no_proto_instance_val);
jerry_cleanup ();
tests/unit-core/test-api-errortype.c
+18 -18
View File
@@ -29,45 +29,45 @@ main (void)
for (size_t idx = 0; idx < sizeof (errors) / sizeof (errors[0]); idx++)
{
jerry_value_t error_obj = jerry_create_error (errors[idx], (const jerry_char_t *) "test");
TEST_ASSERT (jerry_value_is_error (error_obj));
TEST_ASSERT (jerry_get_error_type (error_obj) == errors[idx]);
jerry_value_t error_obj = jerry_throw_sz (errors[idx], "test");
TEST_ASSERT (jerry_value_is_exception (error_obj));
TEST_ASSERT (jerry_error_type (error_obj) == errors[idx]);
error_obj = jerry_get_value_from_error (error_obj, true);
error_obj = jerry_exception_value (error_obj, true);
TEST_ASSERT (jerry_get_error_type (error_obj) == errors[idx]);
TEST_ASSERT (jerry_error_type (error_obj) == errors[idx]);
jerry_release_value (error_obj);
jerry_value_free (error_obj);
}
jerry_value_t test_values[] = {
jerry_create_number (11),
jerry_create_string ((const jerry_char_t *) "message"),
jerry_create_boolean (true),
jerry_create_object (),
jerry_number (11),
jerry_string_sz ("message"),
jerry_boolean (true),
jerry_object (),
};
for (size_t idx = 0; idx < sizeof (test_values) / sizeof (test_values[0]); idx++)
{
jerry_error_t error_type = jerry_get_error_type (test_values[idx]);
jerry_error_t error_type = jerry_error_type (test_values[idx]);
TEST_ASSERT (error_type == JERRY_ERROR_NONE);
jerry_release_value (test_values[idx]);
jerry_value_free (test_values[idx]);
}
char test_source[] = "\xF0\x9D\x84\x9E";
jerry_value_t result = jerry_parse ((const jerry_char_t *) test_source, sizeof (test_source) - 1, NULL);
TEST_ASSERT (jerry_value_is_error (result));
TEST_ASSERT (jerry_get_error_type (result) == JERRY_ERROR_SYNTAX);
TEST_ASSERT (jerry_value_is_exception (result));
TEST_ASSERT (jerry_error_type (result) == JERRY_ERROR_SYNTAX);
jerry_release_value (result);
jerry_value_free (result);
char test_invalid_error[] = "Object.create(Error.prototype)";
result = jerry_eval ((const jerry_char_t *) test_invalid_error, sizeof (test_invalid_error) - 1, JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (result) && jerry_value_is_object (result));
TEST_ASSERT (jerry_get_error_type (result) == JERRY_ERROR_NONE);
TEST_ASSERT (!jerry_value_is_exception (result) && jerry_value_is_object (result));
TEST_ASSERT (jerry_error_type (result) == JERRY_ERROR_NONE);
jerry_release_value (result);
jerry_value_free (result);
jerry_cleanup ();
} /* main */
tests/unit-core/test-api-functiontype.c
+15 -15
View File
@@ -31,9 +31,9 @@ typedef struct
{ \
TYPE, VALUE, true, false \
}
#define ENTRY_IF(TYPE, VALUE, FEATURE, ASYNC) \
{ \
TYPE, VALUE, jerry_is_feature_enabled (FEATURE), ASYNC \
#define ENTRY_IF(TYPE, VALUE, FEATURE, ASYNC) \
{ \
TYPE, VALUE, jerry_feature_enabled (FEATURE), ASYNC \
}
#define EVALUATE(BUFF) (jerry_eval ((BUFF), sizeof ((BUFF)) - 1, JERRY_PARSE_NO_OPTS))
static jerry_value_t
@@ -44,7 +44,7 @@ test_ext_function (const jerry_call_info_t *call_info_p, /**< call information *
(void) call_info_p;
(void) args_p;
(void) args_cnt;
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* test_ext_function */
int
@@ -67,15 +67,15 @@ main (void)
const jerry_char_t bound_function[] = "function f() {}; f.bind(1,2)";
test_entry_t entries[] = {
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_create_number (-33.0)),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_create_boolean (true)),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_create_undefined ()),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_create_null ()),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_create_string ((const jerry_char_t *) "foo")),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_create_error (JERRY_ERROR_TYPE, (const jerry_char_t *) "error")),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_number (-33.0)),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_boolean (true)),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_undefined ()),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_null ()),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_string_sz ("foo")),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_throw_sz (JERRY_ERROR_TYPE, "error")),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_create_object ()),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_create_array (10)),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_object ()),
ENTRY (JERRY_FUNCTION_TYPE_NONE, jerry_array (10)),
ENTRY_IF (JERRY_FUNCTION_TYPE_ARROW, EVALUATE (arrow_function), JERRY_FEATURE_SYMBOL, false),
ENTRY_IF (JERRY_FUNCTION_TYPE_ARROW, EVALUATE (async_arrow_function), JERRY_FEATURE_SYMBOL, true),
@@ -85,18 +85,18 @@ main (void)
ENTRY (JERRY_FUNCTION_TYPE_GENERIC, EVALUATE (builtin_function)),
ENTRY (JERRY_FUNCTION_TYPE_GENERIC, EVALUATE (simple_function)),
ENTRY (JERRY_FUNCTION_TYPE_BOUND, EVALUATE (bound_function)),
ENTRY (JERRY_FUNCTION_TYPE_GENERIC, jerry_create_external_function (test_ext_function)),
ENTRY (JERRY_FUNCTION_TYPE_GENERIC, jerry_function_external (test_ext_function)),
ENTRY (JERRY_FUNCTION_TYPE_ACCESSOR, EVALUATE (getter_function)),
ENTRY (JERRY_FUNCTION_TYPE_ACCESSOR, EVALUATE (setter_function)),
};
for (size_t idx = 0; idx < sizeof (entries) / sizeof (entries[0]); idx++)
{
jerry_function_type_t type_info = jerry_function_get_type (entries[idx].value);
jerry_function_type_t type_info = jerry_function_type (entries[idx].value);
TEST_ASSERT (!entries[idx].active
|| (type_info == entries[idx].type_info
&& jerry_value_is_async_function (entries[idx].value) == entries[idx].is_async));
jerry_release_value (entries[idx].value);
jerry_value_free (entries[idx].value);
}
jerry_cleanup ();
tests/unit-core/test-api-iteratortype.c
+13 -13
View File
@@ -30,9 +30,9 @@ typedef struct
{ \
TYPE, VALUE, true \
}
#define ENTRY_IF(TYPE, VALUE, FEATURE) \
{ \
TYPE, VALUE, jerry_is_feature_enabled (FEATURE) \
#define ENTRY_IF(TYPE, VALUE, FEATURE) \
{ \
TYPE, VALUE, jerry_feature_enabled (FEATURE) \
}
#define EVALUATE(BUFF) (jerry_eval ((BUFF), sizeof ((BUFF)) - 1, JERRY_PARSE_NO_OPTS))
@@ -66,15 +66,15 @@ main (void)
const jerry_char_t set_iterator_symbol_iterator[] = "new Set([1, 2, 3])[Symbol.iterator]()";
test_entry_t entries[] = {
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_create_number (-33.0)),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_create_boolean (true)),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_create_undefined ()),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_create_null ()),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_create_string ((const jerry_char_t *) "foo")),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_create_error (JERRY_ERROR_TYPE, (const jerry_char_t *) "error")),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_number (-33.0)),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_boolean (true)),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_undefined ()),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_null ()),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_string_sz ("foo")),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_throw_sz (JERRY_ERROR_TYPE, "error")),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_create_object ()),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_create_array (10)),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_object ()),
ENTRY (JERRY_ITERATOR_TYPE_NONE, jerry_array (10)),
ENTRY_IF (JERRY_ITERATOR_TYPE_ARRAY, EVALUATE (array_iterator_keys), JERRY_FEATURE_SYMBOL),
ENTRY_IF (JERRY_ITERATOR_TYPE_ARRAY, EVALUATE (array_iterator_values), JERRY_FEATURE_SYMBOL),
@@ -101,9 +101,9 @@ main (void)
for (size_t idx = 0; idx < sizeof (entries) / sizeof (entries[0]); idx++)
{
jerry_iterator_type_t type_info = jerry_iterator_get_type (entries[idx].value);
jerry_iterator_type_t type_info = jerry_iterator_type (entries[idx].value);
TEST_ASSERT (!entries[idx].active || type_info == entries[idx].type_info);
jerry_release_value (entries[idx].value);
jerry_value_free (entries[idx].value);
}
jerry_cleanup ();
tests/unit-core/test-api-object-property-names.c
+69 -70
View File
@@ -26,33 +26,33 @@ static jerry_char_t buffer[256] = { 0 };
static void
create_and_set_property (const jerry_value_t object, const char *prop_name)
{
jerry_value_t jprop_name = jerry_create_string ((const jerry_char_t *) prop_name);
jerry_value_t ret_val = jerry_set_property (object, jprop_name, jerry_create_undefined ());
jerry_value_t jprop_name = jerry_string_sz (prop_name);
jerry_value_t ret_val = jerry_object_set (object, jprop_name, jerry_undefined ());
jerry_release_value (jprop_name);
jerry_release_value (ret_val);
jerry_value_free (jprop_name);
jerry_value_free (ret_val);
} /* create_and_set_property */
static void
compare_prop_name (const jerry_value_t object, const char *prop_name, uint32_t idx)
{
jerry_value_t name = jerry_get_property_by_index (object, idx);
jerry_value_t name = jerry_object_get_index (object, idx);
TEST_ASSERT (jerry_value_is_string (name) || jerry_value_is_number (name));
if (jerry_value_is_string (name))
{
jerry_size_t name_size = jerry_get_string_size (name);
jerry_size_t name_size = jerry_string_size (name, JERRY_ENCODING_CESU8);
TEST_ASSERT (name_size < sizeof (buffer));
jerry_size_t ret_size = jerry_string_to_char_buffer (name, buffer, sizeof (buffer));
jerry_size_t ret_size = jerry_string_to_buffer (name, JERRY_ENCODING_CESU8, buffer, sizeof (buffer));
TEST_ASSERT (name_size == ret_size);
buffer[name_size] = '\0';
TEST_ASSERT (strcmp ((const char *) buffer, prop_name) == 0);
}
else
{
TEST_ASSERT ((int) jerry_get_number_value (name) == atoi (prop_name));
TEST_ASSERT ((int) jerry_value_as_number (name) == atoi (prop_name));
}
jerry_release_value (name);
jerry_value_free (name);
} /* compare_prop_name */
static void
@@ -61,27 +61,27 @@ define_property (const jerry_value_t object,
jerry_property_descriptor_t *prop_desc_p,
bool is_symbol)
{
jerry_value_t jname = jerry_create_string ((const jerry_char_t *) prop_name);
jerry_value_t jname = jerry_string_sz (prop_name);
jerry_value_t ret_val;
if (is_symbol)
{
jerry_value_t symbol = jerry_create_symbol (jname);
ret_val = jerry_define_own_property (object, symbol, prop_desc_p);
jerry_release_value (symbol);
jerry_value_t symbol = jerry_symbol_with_description (jname);
ret_val = jerry_object_define_own_prop (object, symbol, prop_desc_p);
jerry_value_free (symbol);
}
else
{
ret_val = jerry_define_own_property (object, jname, prop_desc_p);
ret_val = jerry_object_define_own_prop (object, jname, prop_desc_p);
}
jerry_release_value (jname);
jerry_release_value (ret_val);
jerry_value_free (jname);
jerry_value_free (ret_val);
} /* define_property */
int
main (void)
{
if (!jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
if (!jerry_feature_enabled (JERRY_FEATURE_SYMBOL))
{
return 0;
}
@@ -89,61 +89,61 @@ main (void)
TEST_INIT ();
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t error_value = jerry_object_get_property_names (jerry_create_undefined (), JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_value_is_error (error_value) && jerry_get_error_type (error_value) == JERRY_ERROR_TYPE);
jerry_release_value (error_value);
jerry_value_t error_value = jerry_object_property_names (jerry_undefined (), JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_value_is_exception (error_value) && jerry_error_type (error_value) == JERRY_ERROR_TYPE);
jerry_value_free (error_value);
jerry_value_t test_object = jerry_create_object ();
jerry_value_t test_object = jerry_object ();
create_and_set_property (test_object, prop_names[0]);
create_and_set_property (test_object, prop_names[1]);
jerry_value_t names;
jerry_property_descriptor_t prop_desc = jerry_property_descriptor_create ();
jerry_property_descriptor_t prop_desc = jerry_property_descriptor ();
prop_desc.flags |= (JERRY_PROP_IS_CONFIGURABLE_DEFINED | JERRY_PROP_IS_CONFIGURABLE | JERRY_PROP_IS_WRITABLE_DEFINED
| JERRY_PROP_IS_WRITABLE | JERRY_PROP_IS_ENUMERABLE_DEFINED);
// Test enumerable - non-enumerable filter
define_property (test_object, prop_names[2], &prop_desc, false);
names = jerry_object_get_property_names (test_object,
JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_NON_ENUMERABLE);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 2);
jerry_release_value (names);
names = jerry_object_get_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 3);
names =
jerry_object_property_names (test_object, JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_NON_ENUMERABLE);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 2);
jerry_value_free (names);
names = jerry_object_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 3);
compare_prop_name (names, prop_names[2], 2);
jerry_release_value (names);
jerry_value_free (names);
prop_desc.flags |= JERRY_PROP_IS_ENUMERABLE;
// Test configurable - non-configurable filter
prop_desc.flags &= (uint16_t) ~JERRY_PROP_IS_CONFIGURABLE;
define_property (test_object, prop_names[3], &prop_desc, false);
names = jerry_object_get_property_names (test_object,
JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_NON_CONFIGURABLE);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 3);
jerry_release_value (names);
names = jerry_object_get_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 4);
names = jerry_object_property_names (test_object,
JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_NON_CONFIGURABLE);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 3);
jerry_value_free (names);
names = jerry_object_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 4);
compare_prop_name (names, prop_names[3], 3);
jerry_release_value (names);
jerry_value_free (names);
prop_desc.flags |= JERRY_PROP_IS_CONFIGURABLE;
// Test writable - non-writable filter
prop_desc.flags &= (uint16_t) ~JERRY_PROP_IS_WRITABLE;
define_property (test_object, prop_names[4], &prop_desc, false);
names = jerry_object_get_property_names (test_object,
JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_NON_WRITABLE);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 4);
jerry_release_value (names);
names = jerry_object_get_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 5);
names =
jerry_object_property_names (test_object, JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_NON_WRITABLE);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 4);
jerry_value_free (names);
names = jerry_object_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 5);
compare_prop_name (names, prop_names[4], 4);
jerry_release_value (names);
jerry_value_free (names);
prop_desc.flags |= JERRY_PROP_IS_WRITABLE;
// Test all property filter
names = jerry_object_get_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
jerry_length_t array_len = jerry_get_array_length (names);
names = jerry_object_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
jerry_length_t array_len = jerry_array_length (names);
TEST_ASSERT (array_len == (uint32_t) 5);
for (uint32_t i = 0; i < array_len; i++)
@@ -151,42 +151,41 @@ main (void)
compare_prop_name (names, prop_names[i], i);
}
jerry_release_value (names);
jerry_value_free (names);
// Test number and string index exclusion
define_property (test_object, prop_names[5], &prop_desc, false);
names = jerry_object_get_property_names (test_object,
JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_STRINGS
| JERRY_PROPERTY_FILTER_INTEGER_INDICES_AS_NUMBER);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 1);
names = jerry_object_property_names (test_object,
JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_STRINGS
| JERRY_PROPERTY_FILTER_INTEGER_INDICES_AS_NUMBER);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 1);
compare_prop_name (names, prop_names[5], 0);
jerry_release_value (names);
names = jerry_object_get_property_names (test_object,
JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_INTEGER_INDICES);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 5);
jerry_release_value (names);
jerry_value_free (names);
names = jerry_object_property_names (test_object,
JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_INTEGER_INDICES);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 5);
jerry_value_free (names);
// Test prototype chain traversion
names = jerry_object_get_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 6);
jerry_release_value (names);
names = jerry_object_get_property_names (test_object,
JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_TRAVERSE_PROTOTYPE_CHAIN);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 18);
jerry_release_value (names);
names = jerry_object_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 6);
jerry_value_free (names);
names = jerry_object_property_names (test_object,
JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_TRAVERSE_PROTOTYPE_CHAIN);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 18);
jerry_value_free (names);
// Test symbol exclusion
define_property (test_object, prop_names[6], &prop_desc, true);
names =
jerry_object_get_property_names (test_object, JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_SYMBOLS);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 6);
jerry_release_value (names);
names = jerry_object_get_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_get_array_length (names) == (uint32_t) 7);
jerry_release_value (names);
names = jerry_object_property_names (test_object, JERRY_PROPERTY_FILTER_ALL | JERRY_PROPERTY_FILTER_EXCLUDE_SYMBOLS);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 6);
jerry_value_free (names);
names = jerry_object_property_names (test_object, JERRY_PROPERTY_FILTER_ALL);
TEST_ASSERT (jerry_array_length (names) == (uint32_t) 7);
jerry_value_free (names);
jerry_property_descriptor_free (&prop_desc);
jerry_release_value (test_object);
jerry_value_free (test_object);
jerry_cleanup ();
return 0;
} /* main */
tests/unit-core/test-api-objecttype.c
+28 -28
View File
@@ -30,9 +30,9 @@ typedef struct
{ \
TYPE, VALUE, true \
}
#define ENTRY_IF(TYPE, VALUE, FEATURE) \
{ \
TYPE, VALUE, jerry_is_feature_enabled (FEATURE) \
#define ENTRY_IF(TYPE, VALUE, FEATURE) \
{ \
TYPE, VALUE, jerry_feature_enabled (FEATURE) \
}
#define EVALUATE(BUFF) (jerry_eval ((BUFF), sizeof ((BUFF)) - 1, JERRY_PARSE_NO_OPTS))
#define PARSE(OPTS) (jerry_parse ((const jerry_char_t *) "", 0, (OPTS)))
@@ -44,7 +44,7 @@ test_ext_function (const jerry_call_info_t *call_info_p, /**< call information *
(void) call_info_p;
(void) args_p;
(void) args_cnt;
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* test_ext_function */
static jerry_object_type_t
@@ -52,19 +52,19 @@ test_namespace (const jerry_parse_options_t module_parse_options) /** module opt
{
jerry_value_t module = jerry_parse ((const jerry_char_t *) "", 0, &module_parse_options);
jerry_value_t module_linked = jerry_module_link (module, NULL, NULL);
jerry_object_type_t namespace = jerry_module_get_namespace (module);
jerry_release_value (module_linked);
jerry_release_value (module);
jerry_object_type_t namespace = jerry_module_namespace (module);
jerry_value_free (module_linked);
jerry_value_free (module);
return namespace;
} /* test_namespace */
static jerry_value_t
test_dataview (void)
{
jerry_value_t arraybuffer = jerry_create_arraybuffer (10);
jerry_value_t dataview = jerry_create_dataview (arraybuffer, 0, 4);
jerry_value_t arraybuffer = jerry_arraybuffer (10);
jerry_value_t dataview = jerry_dataview (arraybuffer, 0, 4);
jerry_release_value (arraybuffer);
jerry_value_free (arraybuffer);
return dataview;
} /* test_dataview */
@@ -109,16 +109,16 @@ main (void)
module_parse_options.options = JERRY_PARSE_MODULE;
test_entry_t entries[] = {
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_create_number (-33.0)),
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_create_boolean (true)),
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_create_undefined ()),
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_create_null ()),
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_create_string ((const jerry_char_t *) "foo")),
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_create_error (JERRY_ERROR_TYPE, (const jerry_char_t *) "error")),
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_number (-33.0)),
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_boolean (true)),
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_undefined ()),
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_null ()),
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_string_sz ("foo")),
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_throw_sz (JERRY_ERROR_TYPE, "error")),
ENTRY (JERRY_OBJECT_TYPE_GENERIC, jerry_create_object ()),
ENTRY (JERRY_OBJECT_TYPE_GENERIC, jerry_object ()),
ENTRY_IF (JERRY_OBJECT_TYPE_MODULE_NAMESPACE, test_namespace (module_parse_options), JERRY_FEATURE_MODULE),
ENTRY (JERRY_OBJECT_TYPE_ARRAY, jerry_create_array (10)),
ENTRY (JERRY_OBJECT_TYPE_ARRAY, jerry_array (10)),
ENTRY_IF (JERRY_OBJECT_TYPE_PROXY, EVALUATE (proxy_object), JERRY_FEATURE_PROXY),
ENTRY_IF (JERRY_OBJECT_TYPE_TYPEDARRAY, EVALUATE (typedarray_object), JERRY_FEATURE_TYPEDARRAY),
@@ -127,7 +127,7 @@ main (void)
ENTRY (JERRY_OBJECT_TYPE_SCRIPT, PARSE (NULL)),
ENTRY_IF (JERRY_OBJECT_TYPE_MODULE, PARSE (&module_parse_options), JERRY_FEATURE_MODULE),
ENTRY_IF (JERRY_OBJECT_TYPE_PROMISE, jerry_create_promise (), JERRY_FEATURE_PROMISE),
ENTRY_IF (JERRY_OBJECT_TYPE_PROMISE, jerry_promise (), JERRY_FEATURE_PROMISE),
ENTRY_IF (JERRY_OBJECT_TYPE_DATAVIEW, test_dataview (), JERRY_FEATURE_DATAVIEW),
ENTRY_IF (JERRY_OBJECT_TYPE_FUNCTION, EVALUATE (arrow_function), JERRY_FEATURE_SYMBOL),
ENTRY_IF (JERRY_OBJECT_TYPE_FUNCTION, EVALUATE (async_arrow_function), JERRY_FEATURE_SYMBOL),
@@ -137,11 +137,11 @@ main (void)
ENTRY (JERRY_OBJECT_TYPE_FUNCTION, EVALUATE (builtin_function)),
ENTRY (JERRY_OBJECT_TYPE_FUNCTION, EVALUATE (simple_function)),
ENTRY (JERRY_OBJECT_TYPE_FUNCTION, EVALUATE (bound_function)),
ENTRY (JERRY_OBJECT_TYPE_FUNCTION, jerry_create_external_function (test_ext_function)),
ENTRY (JERRY_OBJECT_TYPE_FUNCTION, jerry_function_external (test_ext_function)),
ENTRY (JERRY_OBJECT_TYPE_FUNCTION, EVALUATE (getter_function)),
ENTRY (JERRY_OBJECT_TYPE_FUNCTION, EVALUATE (setter_function)),
ENTRY_IF (JERRY_OBJECT_TYPE_ERROR, EVALUATE (error_object), JERRY_FEATURE_ERROR_MESSAGES),
ENTRY_IF (JERRY_OBJECT_TYPE_ARRAYBUFFER, jerry_create_arraybuffer (10), JERRY_FEATURE_TYPEDARRAY),
ENTRY_IF (JERRY_OBJECT_TYPE_ARRAYBUFFER, jerry_arraybuffer (10), JERRY_FEATURE_TYPEDARRAY),
ENTRY (JERRY_OBJECT_TYPE_ARGUMENTS, EVALUATE (mapped_arguments)),
ENTRY (JERRY_OBJECT_TYPE_ARGUMENTS, EVALUATE (unmapped_arguments)),
@@ -158,25 +158,25 @@ main (void)
for (size_t idx = 0; idx < sizeof (entries) / sizeof (entries[0]); idx++)
{
jerry_object_type_t type_info = jerry_object_get_type (entries[idx].value);
jerry_object_type_t type_info = jerry_object_type (entries[idx].value);
TEST_ASSERT (!entries[idx].active || type_info == entries[idx].type_info);
jerry_release_value (entries[idx].value);
jerry_value_free (entries[idx].value);
}
if (jerry_is_feature_enabled (JERRY_FEATURE_REALM))
if (jerry_feature_enabled (JERRY_FEATURE_REALM))
{
jerry_value_t new_realm = jerry_create_realm ();
jerry_object_type_t new_realm_object_type = jerry_object_get_type (new_realm);
jerry_value_t new_realm = jerry_realm ();
jerry_object_type_t new_realm_object_type = jerry_object_type (new_realm);
TEST_ASSERT (new_realm_object_type == JERRY_OBJECT_TYPE_GENERIC);
jerry_value_t old_realm = jerry_set_realm (new_realm);
jerry_object_type_t old_realm_object_type = jerry_object_get_type (old_realm);
jerry_object_type_t old_realm_object_type = jerry_object_type (old_realm);
TEST_ASSERT (old_realm_object_type == JERRY_OBJECT_TYPE_GENERIC);
jerry_set_realm (old_realm);
jerry_release_value (new_realm);
jerry_value_free (new_realm);
}
jerry_cleanup ();
tests/unit-core/test-api-promise.c
+61 -62
View File
@@ -22,135 +22,134 @@
static void
test_promise_resolve_success (void)
{
jerry_value_t my_promise = jerry_create_promise ();
jerry_value_t my_promise = jerry_promise ();
// A created promise has an undefined promise result by default and a pending state
{
jerry_value_t promise_result = jerry_get_promise_result (my_promise);
jerry_value_t promise_result = jerry_promise_result (my_promise);
TEST_ASSERT (jerry_value_is_undefined (promise_result));
jerry_promise_state_t promise_state = jerry_get_promise_state (my_promise);
jerry_promise_state_t promise_state = jerry_promise_state (my_promise);
TEST_ASSERT (promise_state == JERRY_PROMISE_STATE_PENDING);
jerry_release_value (promise_result);
jerry_value_free (promise_result);
}
jerry_value_t resolve_value = jerry_create_object ();
jerry_value_t resolve_value = jerry_object ();
{
jerry_value_t obj_key = jerry_create_string ((const jerry_char_t *) "key_one");
jerry_value_t set_result = jerry_set_property (resolve_value, obj_key, jerry_create_number (3));
jerry_value_t obj_key = jerry_string_sz ("key_one");
jerry_value_t set_result = jerry_object_set (resolve_value, obj_key, jerry_number (3));
TEST_ASSERT (jerry_value_is_boolean (set_result) && (jerry_value_is_true (set_result)));
jerry_release_value (set_result);
jerry_release_value (obj_key);
jerry_value_free (set_result);
jerry_value_free (obj_key);
}
// A resolved promise should have the result of from the resolve call and a fulfilled state
{
jerry_value_t resolve_result = jerry_resolve_or_reject_promise (my_promise, resolve_value, true);
jerry_value_t resolve_result = jerry_promise_resolve (my_promise, resolve_value);
// Release "old" value of resolve.
jerry_release_value (resolve_value);
jerry_value_free (resolve_value);
jerry_value_t promise_result = jerry_get_promise_result (my_promise);
jerry_value_t promise_result = jerry_promise_result (my_promise);
{
TEST_ASSERT (jerry_value_is_object (promise_result));
jerry_value_t obj_key = jerry_create_string ((const jerry_char_t *) "key_one");
jerry_value_t get_result = jerry_get_property (promise_result, obj_key);
jerry_value_t obj_key = jerry_string_sz ("key_one");
jerry_value_t get_result = jerry_object_get (promise_result, obj_key);
TEST_ASSERT (jerry_value_is_number (get_result));
TEST_ASSERT (jerry_get_number_value (get_result) == 3.0);
TEST_ASSERT (jerry_value_as_number (get_result) == 3.0);
jerry_release_value (get_result);
jerry_release_value (obj_key);
jerry_value_free (get_result);
jerry_value_free (obj_key);
}
jerry_promise_state_t promise_state = jerry_get_promise_state (my_promise);
jerry_promise_state_t promise_state = jerry_promise_state (my_promise);
TEST_ASSERT (promise_state == JERRY_PROMISE_STATE_FULFILLED);
jerry_release_value (promise_result);
jerry_value_free (promise_result);
jerry_release_value (resolve_result);
jerry_value_free (resolve_result);
}
// Resolvind a promise again does not change the result/state
{
jerry_value_t resolve_result = jerry_resolve_or_reject_promise (my_promise, jerry_create_number (50), false);
jerry_value_t resolve_result = jerry_promise_reject (my_promise, jerry_number (50));
jerry_value_t promise_result = jerry_get_promise_result (my_promise);
jerry_value_t promise_result = jerry_promise_result (my_promise);
{
TEST_ASSERT (jerry_value_is_object (promise_result));
jerry_value_t obj_key = jerry_create_string ((const jerry_char_t *) "key_one");
jerry_value_t get_result = jerry_get_property (promise_result, obj_key);
jerry_value_t obj_key = jerry_string_sz ("key_one");
jerry_value_t get_result = jerry_object_get (promise_result, obj_key);
TEST_ASSERT (jerry_value_is_number (get_result));
TEST_ASSERT (jerry_get_number_value (get_result) == 3.0);
TEST_ASSERT (jerry_value_as_number (get_result) == 3.0);
jerry_release_value (get_result);
jerry_release_value (obj_key);
jerry_value_free (get_result);
jerry_value_free (obj_key);
}
jerry_promise_state_t promise_state = jerry_get_promise_state (my_promise);
jerry_promise_state_t promise_state = jerry_promise_state (my_promise);
TEST_ASSERT (promise_state == JERRY_PROMISE_STATE_FULFILLED);
jerry_release_value (promise_result);
jerry_value_free (promise_result);
jerry_release_value (resolve_result);
jerry_value_free (resolve_result);
}
jerry_release_value (my_promise);
jerry_value_free (my_promise);
} /* test_promise_resolve_success */
static void
test_promise_resolve_fail (void)
{
jerry_value_t my_promise = jerry_create_promise ();
jerry_value_t my_promise = jerry_promise ();
// A created promise has an undefined promise result by default and a pending state
{
jerry_value_t promise_result = jerry_get_promise_result (my_promise);
jerry_value_t promise_result = jerry_promise_result (my_promise);
TEST_ASSERT (jerry_value_is_undefined (promise_result));
jerry_promise_state_t promise_state = jerry_get_promise_state (my_promise);
jerry_promise_state_t promise_state = jerry_promise_state (my_promise);
TEST_ASSERT (promise_state == JERRY_PROMISE_STATE_PENDING);
jerry_release_value (promise_result);
jerry_value_free (promise_result);
}
// A resolved promise should have the result of from the resolve call and a fulfilled state
{
jerry_value_t error_value = jerry_create_error (JERRY_ERROR_TYPE, (const jerry_char_t *) "resolve_fail");
jerry_value_t error_obj = jerry_get_value_from_error (error_value, true);
jerry_value_t resolve_result = jerry_resolve_or_reject_promise (my_promise, error_obj, false);
jerry_release_value (error_obj);
jerry_value_t error_obj = jerry_error_sz (JERRY_ERROR_TYPE, "resolve_fail");
jerry_value_t resolve_result = jerry_promise_reject (my_promise, error_obj);
jerry_value_free (error_obj);
jerry_value_t promise_result = jerry_get_promise_result (my_promise);
jerry_value_t promise_result = jerry_promise_result (my_promise);
// The error is not throw that's why it is only an error object.
TEST_ASSERT (jerry_value_is_object (promise_result));
TEST_ASSERT (jerry_get_error_type (promise_result) == JERRY_ERROR_TYPE);
TEST_ASSERT (jerry_error_type (promise_result) == JERRY_ERROR_TYPE);
jerry_promise_state_t promise_state = jerry_get_promise_state (my_promise);
jerry_promise_state_t promise_state = jerry_promise_state (my_promise);
TEST_ASSERT (promise_state == JERRY_PROMISE_STATE_REJECTED);
jerry_release_value (promise_result);
jerry_value_free (promise_result);
jerry_release_value (resolve_result);
jerry_value_free (resolve_result);
}
// Resolvind a promise again does not change the result/state
{
jerry_value_t resolve_result = jerry_resolve_or_reject_promise (my_promise, jerry_create_number (50), true);
jerry_value_t resolve_result = jerry_promise_resolve (my_promise, jerry_number (50));
jerry_value_t promise_result = jerry_get_promise_result (my_promise);
jerry_value_t promise_result = jerry_promise_result (my_promise);
TEST_ASSERT (jerry_value_is_object (promise_result));
TEST_ASSERT (jerry_get_error_type (promise_result) == JERRY_ERROR_TYPE);
TEST_ASSERT (jerry_error_type (promise_result) == JERRY_ERROR_TYPE);
jerry_promise_state_t promise_state = jerry_get_promise_state (my_promise);
jerry_promise_state_t promise_state = jerry_promise_state (my_promise);
TEST_ASSERT (promise_state == JERRY_PROMISE_STATE_REJECTED);
jerry_release_value (promise_result);
jerry_value_free (promise_result);
jerry_release_value (resolve_result);
jerry_value_free (resolve_result);
}
jerry_release_value (my_promise);
jerry_value_free (my_promise);
} /* test_promise_resolve_fail */
static void
@@ -159,31 +158,31 @@ test_promise_from_js (void)
const jerry_char_t test_source[] = "(new Promise(function(rs, rj) { rs(30); })).then(function(v) { return v + 1; })";
jerry_value_t parsed_code_val = jerry_parse (test_source, sizeof (test_source) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);
TEST_ASSERT (jerry_value_is_promise (res));
TEST_ASSERT (jerry_get_promise_state (res) == JERRY_PROMISE_STATE_PENDING);
TEST_ASSERT (jerry_promise_state (res) == JERRY_PROMISE_STATE_PENDING);
jerry_value_t run_result = jerry_run_all_enqueued_jobs ();
jerry_value_t run_result = jerry_run_jobs ();
TEST_ASSERT (jerry_value_is_undefined (run_result));
jerry_release_value (run_result);
jerry_value_free (run_result);
TEST_ASSERT (jerry_get_promise_state (res) == JERRY_PROMISE_STATE_FULFILLED);
jerry_value_t promise_result = jerry_get_promise_result (res);
TEST_ASSERT (jerry_promise_state (res) == JERRY_PROMISE_STATE_FULFILLED);
jerry_value_t promise_result = jerry_promise_result (res);
TEST_ASSERT (jerry_value_is_number (promise_result));
TEST_ASSERT (jerry_get_number_value (promise_result) == 31.0);
TEST_ASSERT (jerry_value_as_number (promise_result) == 31.0);
jerry_release_value (promise_result);
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_value_free (promise_result);
jerry_value_free (res);
jerry_value_free (parsed_code_val);
} /* test_promise_from_js */
int
main (void)
{
if (!jerry_is_feature_enabled (JERRY_FEATURE_PROMISE))
if (!jerry_feature_enabled (JERRY_FEATURE_PROMISE))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Promise is disabled!\n");
return 0;
tests/unit-core/test-api-property.c
+51 -51
View File
@@ -25,47 +25,47 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
/* Test: init property descriptor */
jerry_property_descriptor_t prop_desc = jerry_property_descriptor_create ();
jerry_property_descriptor_t prop_desc = jerry_property_descriptor ();
TEST_ASSERT (prop_desc.flags == JERRY_PROP_NO_OPTS);
TEST_ASSERT (jerry_value_is_undefined (prop_desc.value));
TEST_ASSERT (jerry_value_is_undefined (prop_desc.getter));
TEST_ASSERT (jerry_value_is_undefined (prop_desc.setter));
/* Test: define own properties */
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "my_defined_property");
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t prop_name = jerry_string_sz ("my_defined_property");
prop_desc.flags |= JERRY_PROP_IS_VALUE_DEFINED;
prop_desc.value = jerry_acquire_value (prop_name);
jerry_value_t res = jerry_define_own_property (global_obj_val, prop_name, &prop_desc);
prop_desc.value = jerry_value_copy (prop_name);
jerry_value_t res = jerry_object_define_own_prop (global_obj_val, prop_name, &prop_desc);
TEST_ASSERT (jerry_value_is_boolean (res) && jerry_value_is_true (res));
jerry_release_value (res);
jerry_value_free (res);
jerry_property_descriptor_free (&prop_desc);
/* Test: define own property with error */
prop_desc = jerry_property_descriptor_create ();
prop_desc = jerry_property_descriptor ();
prop_desc.flags |= JERRY_PROP_IS_VALUE_DEFINED | JERRY_PROP_SHOULD_THROW;
prop_desc.value = jerry_create_number (3.14);
res = jerry_define_own_property (global_obj_val, prop_name, &prop_desc);
TEST_ASSERT (jerry_value_is_error (res));
jerry_release_value (res);
prop_desc.value = jerry_number (3.14);
res = jerry_object_define_own_prop (global_obj_val, prop_name, &prop_desc);
TEST_ASSERT (jerry_value_is_exception (res));
jerry_value_free (res);
jerry_property_descriptor_free (&prop_desc);
/* Test: test define own property failure without throw twice */
prop_desc = jerry_property_descriptor_create ();
prop_desc = jerry_property_descriptor ();
prop_desc.flags |= JERRY_PROP_IS_VALUE_DEFINED | JERRY_PROP_IS_GET_DEFINED;
res = jerry_define_own_property (prop_name, prop_name, &prop_desc);
res = jerry_object_define_own_prop (prop_name, prop_name, &prop_desc);
TEST_ASSERT (jerry_value_is_boolean (res) && !jerry_value_is_true (res));
jerry_release_value (res);
res = jerry_define_own_property (global_obj_val, prop_name, &prop_desc);
jerry_value_free (res);
res = jerry_object_define_own_prop (global_obj_val, prop_name, &prop_desc);
TEST_ASSERT (jerry_value_is_boolean (res) && !jerry_value_is_true (res));
jerry_release_value (res);
jerry_value_free (res);
jerry_property_descriptor_free (&prop_desc);
/* Test: get own property descriptor */
prop_desc = jerry_property_descriptor_create ();
jerry_value_t is_ok = jerry_get_own_property_descriptor (global_obj_val, prop_name, &prop_desc);
prop_desc = jerry_property_descriptor ();
jerry_value_t is_ok = jerry_object_get_own_prop (global_obj_val, prop_name, &prop_desc);
TEST_ASSERT (jerry_value_is_boolean (is_ok) && jerry_value_is_true (is_ok));
jerry_release_value (is_ok);
jerry_value_free (is_ok);
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_VALUE_DEFINED);
TEST_ASSERT (jerry_value_is_string (prop_desc.value));
TEST_ASSERT (!(prop_desc.flags & JERRY_PROP_IS_WRITABLE));
@@ -77,61 +77,61 @@ main (void)
TEST_ASSERT (jerry_value_is_undefined (prop_desc.setter));
jerry_property_descriptor_free (&prop_desc);
if (jerry_is_feature_enabled (JERRY_FEATURE_PROXY))
if (jerry_feature_enabled (JERRY_FEATURE_PROXY))
{
/* Note: update this test when the internal method is implemented */
jerry_value_t target = jerry_create_object ();
jerry_value_t handler = jerry_create_object ();
jerry_value_t proxy = jerry_create_proxy (target, handler);
jerry_value_t target = jerry_object ();
jerry_value_t handler = jerry_object ();
jerry_value_t proxy = jerry_proxy (target, handler);
jerry_release_value (target);
jerry_release_value (handler);
is_ok = jerry_get_own_property_descriptor (proxy, prop_name, &prop_desc);
jerry_value_free (target);
jerry_value_free (handler);
is_ok = jerry_object_get_own_prop (proxy, prop_name, &prop_desc);
TEST_ASSERT (jerry_value_is_boolean (is_ok) && !jerry_value_is_true (is_ok));
jerry_release_value (is_ok);
jerry_release_value (proxy);
jerry_value_free (is_ok);
jerry_value_free (proxy);
}
jerry_release_value (prop_name);
jerry_value_free (prop_name);
/* Test: define and get own property descriptor */
prop_desc.flags |= JERRY_PROP_IS_ENUMERABLE;
prop_name = jerry_create_string ((const jerry_char_t *) "enumerable-property");
res = jerry_define_own_property (global_obj_val, prop_name, &prop_desc);
TEST_ASSERT (!jerry_value_is_error (res));
prop_name = jerry_string_sz ("enumerable-property");
res = jerry_object_define_own_prop (global_obj_val, prop_name, &prop_desc);
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (jerry_value_is_boolean (res));
TEST_ASSERT (jerry_value_is_true (res));
jerry_release_value (res);
jerry_value_free (res);
jerry_property_descriptor_free (&prop_desc);
is_ok = jerry_get_own_property_descriptor (global_obj_val, prop_name, &prop_desc);
is_ok = jerry_object_get_own_prop (global_obj_val, prop_name, &prop_desc);
TEST_ASSERT (jerry_value_is_boolean (is_ok) && jerry_value_is_true (is_ok));
jerry_release_value (is_ok);
jerry_value_free (is_ok);
TEST_ASSERT (!(prop_desc.flags & JERRY_PROP_IS_WRITABLE));
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_ENUMERABLE);
TEST_ASSERT (!(prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE));
jerry_release_value (prop_name);
jerry_release_value (global_obj_val);
jerry_value_free (prop_name);
jerry_value_free (global_obj_val);
/* Test: define own property descriptor error */
prop_desc = jerry_property_descriptor_create ();
prop_desc = jerry_property_descriptor ();
prop_desc.flags |= JERRY_PROP_IS_VALUE_DEFINED;
prop_desc.value = jerry_create_number (11);
prop_desc.value = jerry_number (11);
jerry_value_t obj_val = jerry_create_object ();
prop_name = jerry_create_string ((const jerry_char_t *) "property_key");
res = jerry_define_own_property (obj_val, prop_name, &prop_desc);
TEST_ASSERT (!jerry_value_is_error (res));
jerry_release_value (res);
jerry_value_t obj_val = jerry_object ();
prop_name = jerry_string_sz ("property_key");
res = jerry_object_define_own_prop (obj_val, prop_name, &prop_desc);
TEST_ASSERT (!jerry_value_is_exception (res));
jerry_value_free (res);
jerry_release_value (prop_desc.value);
prop_desc.value = jerry_create_number (22);
res = jerry_define_own_property (obj_val, prop_name, &prop_desc);
TEST_ASSERT (jerry_value_is_error (res));
jerry_release_value (res);
jerry_value_free (prop_desc.value);
prop_desc.value = jerry_number (22);
res = jerry_object_define_own_prop (obj_val, prop_name, &prop_desc);
TEST_ASSERT (jerry_value_is_exception (res));
jerry_value_free (res);
jerry_release_value (prop_name);
jerry_release_value (obj_val);
jerry_value_free (prop_name);
jerry_value_free (obj_val);
jerry_cleanup ();
tests/unit-core/test-api-set-and-clear-error-flag.c
+127 -127
View File
@@ -18,12 +18,12 @@
#include "test-common.h"
static void
compare_str (jerry_value_t value, const jerry_char_t *str_p, size_t str_len)
compare_str (jerry_value_t value, const char *str_p, size_t str_len)
{
jerry_size_t size = jerry_get_string_size (value);
jerry_size_t size = jerry_string_size (value, JERRY_ENCODING_CESU8);
TEST_ASSERT (str_len == size);
JERRY_VLA (jerry_char_t, str_buff, size);
jerry_string_to_utf8_char_buffer (value, str_buff, size);
jerry_string_to_buffer (value, JERRY_ENCODING_CESU8, str_buff, size);
TEST_ASSERT (!memcmp (str_p, str_buff, str_len));
} /* compare_str */
@@ -34,174 +34,174 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t obj_val = jerry_create_object ();
obj_val = jerry_create_error_from_value (obj_val, true);
jerry_value_t err_val = jerry_acquire_value (obj_val);
jerry_value_t obj_val = jerry_object ();
obj_val = jerry_throw_value (obj_val, true);
jerry_value_t err_val = jerry_value_copy (obj_val);
obj_val = jerry_get_value_from_error (err_val, true);
obj_val = jerry_exception_value (err_val, true);
TEST_ASSERT (obj_val != err_val);
jerry_release_value (err_val);
jerry_release_value (obj_val);
jerry_value_free (err_val);
jerry_value_free (obj_val);
const jerry_char_t pterodactylus[] = "Pterodactylus";
const char pterodactylus[] = "Pterodactylus";
const size_t pterodactylus_size = sizeof (pterodactylus) - 1;
jerry_value_t str = jerry_create_string (pterodactylus);
jerry_value_t error = jerry_create_error_from_value (str, true);
str = jerry_get_value_from_error (error, true);
jerry_value_t str = jerry_string_sz (pterodactylus);
jerry_value_t error = jerry_throw_value (str, true);
str = jerry_exception_value (error, true);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
jerry_value_free (str);
str = jerry_create_string (pterodactylus);
error = jerry_create_error_from_value (str, false);
jerry_release_value (str);
str = jerry_get_value_from_error (error, true);
str = jerry_string_sz (pterodactylus);
error = jerry_throw_value (str, false);
jerry_value_free (str);
str = jerry_exception_value (error, true);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
jerry_value_free (str);
str = jerry_create_string (pterodactylus);
error = jerry_create_abort_from_value (str, true);
str = jerry_get_value_from_error (error, true);
str = jerry_string_sz (pterodactylus);
error = jerry_throw_abort (str, true);
str = jerry_exception_value (error, true);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
jerry_value_free (str);
str = jerry_create_string (pterodactylus);
error = jerry_create_abort_from_value (str, false);
jerry_release_value (str);
str = jerry_get_value_from_error (error, true);
str = jerry_string_sz (pterodactylus);
error = jerry_throw_abort (str, false);
jerry_value_free (str);
str = jerry_exception_value (error, true);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
jerry_value_free (str);
str = jerry_create_string (pterodactylus);
error = jerry_create_error_from_value (str, true);
error = jerry_create_abort_from_value (error, true);
str = jerry_string_sz (pterodactylus);
error = jerry_throw_value (str, true);
error = jerry_throw_abort (error, true);
TEST_ASSERT (jerry_value_is_abort (error));
str = jerry_get_value_from_error (error, true);
str = jerry_exception_value (error, true);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
jerry_value_free (str);
str = jerry_create_string (pterodactylus);
error = jerry_create_error_from_value (str, true);
jerry_value_t error2 = jerry_create_abort_from_value (error, false);
str = jerry_string_sz (pterodactylus);
error = jerry_throw_value (str, true);
jerry_value_t error2 = jerry_throw_abort (error, false);
TEST_ASSERT (jerry_value_is_abort (error2));
jerry_release_value (error);
str = jerry_get_value_from_error (error2, true);
jerry_value_free (error);
str = jerry_exception_value (error2, true);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
jerry_value_free (str);
double test_num = 3.1415926;
jerry_value_t num = jerry_create_number (test_num);
jerry_value_t num2 = jerry_create_error_from_value (num, false);
TEST_ASSERT (jerry_value_is_error (num2));
jerry_release_value (num);
num2 = jerry_get_value_from_error (num2, true);
TEST_ASSERT (jerry_get_number_value (num2) == test_num);
jerry_release_value (num2);
jerry_value_t num = jerry_number (test_num);
jerry_value_t num2 = jerry_throw_value (num, false);
TEST_ASSERT (jerry_value_is_exception (num2));
jerry_value_free (num);
num2 = jerry_exception_value (num2, true);
TEST_ASSERT (jerry_value_as_number (num2) == test_num);
jerry_value_free (num2);
num = jerry_create_number (test_num);
num2 = jerry_create_error_from_value (num, true);
TEST_ASSERT (jerry_value_is_error (num2));
num2 = jerry_get_value_from_error (num2, true);
TEST_ASSERT (jerry_get_number_value (num2) == test_num);
jerry_release_value (num2);
num = jerry_number (test_num);
num2 = jerry_throw_value (num, true);
TEST_ASSERT (jerry_value_is_exception (num2));
num2 = jerry_exception_value (num2, true);
TEST_ASSERT (jerry_value_as_number (num2) == test_num);
jerry_value_free (num2);
num = jerry_create_number (test_num);
num2 = jerry_create_error_from_value (num, false);
TEST_ASSERT (jerry_value_is_error (num2));
jerry_release_value (num);
jerry_value_t num3 = jerry_create_error_from_value (num2, false);
TEST_ASSERT (jerry_value_is_error (num3));
jerry_release_value (num2);
num2 = jerry_get_value_from_error (num3, true);
TEST_ASSERT (jerry_get_number_value (num2) == test_num);
jerry_release_value (num2);
num = jerry_number (test_num);
num2 = jerry_throw_value (num, false);
TEST_ASSERT (jerry_value_is_exception (num2));
jerry_value_free (num);
jerry_value_t num3 = jerry_throw_value (num2, false);
TEST_ASSERT (jerry_value_is_exception (num3));
jerry_value_free (num2);
num2 = jerry_exception_value (num3, true);
TEST_ASSERT (jerry_value_as_number (num2) == test_num);
jerry_value_free (num2);
num = jerry_create_number (test_num);
num2 = jerry_create_error_from_value (num, true);
TEST_ASSERT (jerry_value_is_error (num2));
num3 = jerry_create_error_from_value (num2, true);
TEST_ASSERT (jerry_value_is_error (num3));
num2 = jerry_get_value_from_error (num3, true);
TEST_ASSERT (jerry_get_number_value (num2) == test_num);
jerry_release_value (num2);
num = jerry_number (test_num);
num2 = jerry_throw_value (num, true);
TEST_ASSERT (jerry_value_is_exception (num2));
num3 = jerry_throw_value (num2, true);
TEST_ASSERT (jerry_value_is_exception (num3));
num2 = jerry_exception_value (num3, true);
TEST_ASSERT (jerry_value_as_number (num2) == test_num);
jerry_value_free (num2);
num = jerry_create_number (test_num);
error = jerry_create_abort_from_value (num, true);
num = jerry_number (test_num);
error = jerry_throw_abort (num, true);
TEST_ASSERT (jerry_value_is_abort (error));
num2 = jerry_create_error_from_value (error, true);
TEST_ASSERT (jerry_value_is_error (num2));
num = jerry_get_value_from_error (num2, true);
TEST_ASSERT (jerry_get_number_value (num) == test_num);
jerry_release_value (num);
num2 = jerry_throw_value (error, true);
TEST_ASSERT (jerry_value_is_exception (num2));
num = jerry_exception_value (num2, true);
TEST_ASSERT (jerry_value_as_number (num) == test_num);
jerry_value_free (num);
num = jerry_create_number (test_num);
error = jerry_create_abort_from_value (num, false);
jerry_release_value (num);
num = jerry_number (test_num);
error = jerry_throw_abort (num, false);
jerry_value_free (num);
TEST_ASSERT (jerry_value_is_abort (error));
num2 = jerry_create_error_from_value (error, true);
TEST_ASSERT (jerry_value_is_error (num2));
num = jerry_get_value_from_error (num2, true);
TEST_ASSERT (jerry_get_number_value (num) == test_num);
jerry_release_value (num);
num2 = jerry_throw_value (error, true);
TEST_ASSERT (jerry_value_is_exception (num2));
num = jerry_exception_value (num2, true);
TEST_ASSERT (jerry_value_as_number (num) == test_num);
jerry_value_free (num);
num = jerry_create_number (test_num);
error = jerry_create_abort_from_value (num, true);
num = jerry_number (test_num);
error = jerry_throw_abort (num, true);
TEST_ASSERT (jerry_value_is_abort (error));
num2 = jerry_create_error_from_value (error, false);
jerry_release_value (error);
TEST_ASSERT (jerry_value_is_error (num2));
num = jerry_get_value_from_error (num2, true);
TEST_ASSERT (jerry_get_number_value (num) == test_num);
jerry_release_value (num);
num2 = jerry_throw_value (error, false);
jerry_value_free (error);
TEST_ASSERT (jerry_value_is_exception (num2));
num = jerry_exception_value (num2, true);
TEST_ASSERT (jerry_value_as_number (num) == test_num);
jerry_value_free (num);
num = jerry_create_number (test_num);
error = jerry_create_abort_from_value (num, false);
jerry_release_value (num);
num = jerry_number (test_num);
error = jerry_throw_abort (num, false);
jerry_value_free (num);
TEST_ASSERT (jerry_value_is_abort (error));
num2 = jerry_create_error_from_value (error, false);
jerry_release_value (error);
TEST_ASSERT (jerry_value_is_error (num2));
num = jerry_get_value_from_error (num2, true);
TEST_ASSERT (jerry_get_number_value (num) == test_num);
jerry_release_value (num);
num2 = jerry_throw_value (error, false);
jerry_value_free (error);
TEST_ASSERT (jerry_value_is_exception (num2));
num = jerry_exception_value (num2, true);
TEST_ASSERT (jerry_value_as_number (num) == test_num);
jerry_value_free (num);
jerry_value_t value = jerry_create_number (42);
value = jerry_get_value_from_error (value, true);
jerry_release_value (value);
jerry_value_t value = jerry_number (42);
value = jerry_exception_value (value, true);
jerry_value_free (value);
value = jerry_create_number (42);
jerry_value_t value2 = jerry_get_value_from_error (value, false);
jerry_release_value (value);
jerry_release_value (value2);
value = jerry_number (42);
jerry_value_t value2 = jerry_exception_value (value, false);
jerry_value_free (value);
jerry_value_free (value2);
value = jerry_create_number (42);
error = jerry_create_error_from_value (value, true);
error = jerry_create_error_from_value (error, true);
jerry_release_value (error);
value = jerry_number (42);
error = jerry_throw_value (value, true);
error = jerry_throw_value (error, true);
jerry_value_free (error);
value = jerry_create_number (42);
error = jerry_create_abort_from_value (value, true);
error = jerry_create_abort_from_value (error, true);
jerry_release_value (error);
value = jerry_number (42);
error = jerry_throw_abort (value, true);
error = jerry_throw_abort (error, true);
jerry_value_free (error);
value = jerry_create_number (42);
error = jerry_create_error_from_value (value, true);
error2 = jerry_create_error_from_value (error, false);
jerry_release_value (error);
jerry_release_value (error2);
value = jerry_number (42);
error = jerry_throw_value (value, true);
error2 = jerry_throw_value (error, false);
jerry_value_free (error);
jerry_value_free (error2);
value = jerry_create_number (42);
error = jerry_create_abort_from_value (value, true);
error2 = jerry_create_abort_from_value (error, false);
jerry_release_value (error);
jerry_release_value (error2);
value = jerry_number (42);
error = jerry_throw_abort (value, true);
error2 = jerry_throw_abort (error, false);
jerry_value_free (error);
jerry_value_free (error2);
jerry_cleanup ();
} /* main */
tests/unit-core/test-api-strings.c
+59 -185
View File
@@ -23,14 +23,14 @@ strict_equals (jerry_value_t a, /**< the first string to compare */
{
const jerry_char_t is_equal_src[] = "var isEqual = function(a, b) { return (a === b); }; isEqual";
jerry_value_t is_equal_fn_val = jerry_eval (is_equal_src, sizeof (is_equal_src) - 1, JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (is_equal_fn_val));
TEST_ASSERT (!jerry_value_is_exception (is_equal_fn_val));
jerry_value_t args[2] = { a, b };
jerry_value_t res = jerry_call_function (is_equal_fn_val, jerry_create_undefined (), args, 2);
TEST_ASSERT (!jerry_value_is_error (res));
jerry_value_t res = jerry_call (is_equal_fn_val, jerry_undefined (), args, 2);
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (jerry_value_is_boolean (res));
bool is_strict_equal = jerry_value_is_true (res);
jerry_release_value (res);
jerry_release_value (is_equal_fn_val);
jerry_value_free (res);
jerry_value_free (is_equal_fn_val);
return is_strict_equal;
} /* strict_equals */
@@ -38,253 +38,127 @@ int
main (void)
{
jerry_size_t sz, utf8_sz, cesu8_sz;
jerry_length_t cesu8_length, utf8_length;
jerry_value_t args[2];
TEST_INIT ();
jerry_init (JERRY_INIT_EMPTY);
/* Test corner case for jerry_string_to_char_buffer */
args[0] = jerry_create_string ((jerry_char_t *) "");
sz = jerry_get_string_size (args[0]);
args[0] = jerry_string_sz ("");
sz = jerry_string_size (args[0], JERRY_ENCODING_CESU8);
TEST_ASSERT (sz == 0);
jerry_release_value (args[0]);
jerry_value_free (args[0]);
/* Test create_jerry_string_from_utf8 with 4-byte long unicode sequences,
* test string: 'str: {DESERET CAPITAL LETTER LONG I}'
*/
args[0] = jerry_create_string_from_utf8 ((jerry_char_t *) "\x73\x74\x72\x3a \xf0\x90\x90\x80");
args[1] = jerry_create_string ((jerry_char_t *) "\x73\x74\x72\x3a \xed\xa0\x81\xed\xb0\x80");
char *utf8_bytes_p = "\x73\x74\x72\x3a \xf0\x90\x90\x80";
char *cesu8_bytes_p = "\x73\x74\x72\x3a \xed\xa0\x81\xed\xb0\x80";
args[0] = jerry_string ((jerry_char_t *) utf8_bytes_p, (jerry_size_t) strlen (utf8_bytes_p), JERRY_ENCODING_UTF8);
args[1] = jerry_string ((jerry_char_t *) cesu8_bytes_p, (jerry_size_t) strlen (cesu8_bytes_p), JERRY_ENCODING_CESU8);
/* These sizes must be equal */
utf8_sz = jerry_get_string_size (args[0]);
cesu8_sz = jerry_get_string_size (args[1]);
utf8_sz = jerry_string_size (args[0], JERRY_ENCODING_CESU8);
cesu8_sz = jerry_string_size (args[1], JERRY_ENCODING_CESU8);
JERRY_VLA (char, string_from_utf8, utf8_sz);
JERRY_VLA (char, string_from_cesu8, cesu8_sz);
JERRY_VLA (jerry_char_t, string_from_utf8, utf8_sz);
JERRY_VLA (jerry_char_t, string_from_cesu8, cesu8_sz);
jerry_string_to_char_buffer (args[0], (jerry_char_t *) string_from_utf8, utf8_sz);
jerry_string_to_char_buffer (args[1], (jerry_char_t *) string_from_cesu8, cesu8_sz);
jerry_string_to_buffer (args[0], JERRY_ENCODING_CESU8, string_from_utf8, utf8_sz);
jerry_string_to_buffer (args[1], JERRY_ENCODING_CESU8, string_from_cesu8, cesu8_sz);
TEST_ASSERT (utf8_sz == cesu8_sz);
TEST_ASSERT (!strncmp (string_from_utf8, string_from_cesu8, utf8_sz));
jerry_release_value (args[0]);
jerry_release_value (args[1]);
TEST_ASSERT (!memcmp (string_from_utf8, string_from_cesu8, utf8_sz));
jerry_value_free (args[0]);
jerry_value_free (args[1]);
/* Test jerry_string_to_utf8_char_buffer, test string: 'str: {DESERET CAPITAL LETTER LONG I}' */
args[0] = jerry_create_string_from_utf8 ((jerry_char_t *) "\x73\x74\x72\x3a \xf0\x90\x90\x80");
args[1] = jerry_create_string ((jerry_char_t *) "\x73\x74\x72\x3a \xed\xa0\x81\xed\xb0\x80");
/* Test jerry_string_to_buffer, test string: 'str: {DESERET CAPITAL LETTER LONG I}' */
utf8_bytes_p = "\x73\x74\x72\x3a \xf0\x90\x90\x80";
cesu8_bytes_p = "\x73\x74\x72\x3a \xed\xa0\x81\xed\xb0\x80";
args[0] = jerry_string ((jerry_char_t *) utf8_bytes_p, (jerry_size_t) strlen (utf8_bytes_p), JERRY_ENCODING_UTF8);
args[1] = jerry_string ((jerry_char_t *) cesu8_bytes_p, (jerry_size_t) strlen (cesu8_bytes_p), JERRY_ENCODING_CESU8);
/* Test that the strings are equal / ensure hashes are equal */
TEST_ASSERT (strict_equals (args[0], args[1]));
/* These sizes must be equal */
utf8_sz = jerry_get_utf8_string_size (args[0]);
cesu8_sz = jerry_get_utf8_string_size (args[1]);
utf8_sz = jerry_string_size (args[0], JERRY_ENCODING_UTF8);
cesu8_sz = jerry_string_size (args[1], JERRY_ENCODING_UTF8);
TEST_ASSERT (utf8_sz == cesu8_sz && utf8_sz > 0);
JERRY_VLA (char, string_from_utf8_string, utf8_sz);
JERRY_VLA (char, string_from_cesu8_string, cesu8_sz);
JERRY_VLA (jerry_char_t, string_from_utf8_string, utf8_sz);
JERRY_VLA (jerry_char_t, string_from_cesu8_string, cesu8_sz);
jerry_string_to_utf8_char_buffer (args[0], (jerry_char_t *) string_from_utf8_string, utf8_sz);
jerry_string_to_utf8_char_buffer (args[1], (jerry_char_t *) string_from_cesu8_string, cesu8_sz);
jerry_string_to_buffer (args[0], JERRY_ENCODING_UTF8, string_from_utf8_string, utf8_sz);
jerry_string_to_buffer (args[1], JERRY_ENCODING_UTF8, string_from_cesu8_string, cesu8_sz);
TEST_ASSERT (!strncmp (string_from_utf8_string, string_from_cesu8_string, utf8_sz));
jerry_release_value (args[0]);
jerry_release_value (args[1]);
TEST_ASSERT (!memcmp (string_from_utf8_string, string_from_cesu8_string, utf8_sz));
jerry_value_free (args[0]);
jerry_value_free (args[1]);
/* Test string: 'str: {MATHEMATICAL FRAKTUR SMALL F}{MATHEMATICAL FRAKTUR SMALL G}' */
args[0] = jerry_create_string_from_utf8 ((jerry_char_t *) "\x73\x74\x72\x3a \xf0\x9d\x94\xa3 \xf0\x9d\x94\xa4");
utf8_bytes_p = "\x73\x74\x72\x3a \xf0\x9d\x94\xa3 \xf0\x9d\x94\xa4";
args[0] = jerry_string ((jerry_char_t *) utf8_bytes_p, (jerry_size_t) strlen (utf8_bytes_p), JERRY_ENCODING_UTF8);
cesu8_length = jerry_get_string_length (args[0]);
utf8_length = jerry_get_utf8_string_length (args[0]);
cesu8_sz = jerry_string_size (args[0], JERRY_ENCODING_CESU8);
utf8_sz = jerry_string_size (args[0], JERRY_ENCODING_UTF8);
cesu8_sz = jerry_get_string_size (args[0]);
utf8_sz = jerry_get_utf8_string_size (args[0]);
TEST_ASSERT (cesu8_length == 10 && utf8_length == 8);
TEST_ASSERT (jerry_string_length (args[0]) == 10);
TEST_ASSERT (cesu8_sz != utf8_sz);
TEST_ASSERT (utf8_sz == 14 && cesu8_sz == 18);
JERRY_VLA (char, test_string, utf8_sz);
TEST_ASSERT (jerry_string_to_utf8_char_buffer (args[0], (jerry_char_t *) test_string, utf8_sz) == 14);
TEST_ASSERT (!strncmp (test_string, "\x73\x74\x72\x3a \xf0\x9d\x94\xa3 \xf0\x9d\x94\xa4", utf8_sz));
TEST_ASSERT (jerry_string_to_buffer (args[0], JERRY_ENCODING_UTF8, (jerry_char_t *) test_string, utf8_sz) == 14);
TEST_ASSERT (!strncmp (test_string, utf8_bytes_p, utf8_sz));
sz = jerry_substring_to_utf8_char_buffer (args[0], 0, utf8_length, (jerry_char_t *) test_string, utf8_sz);
TEST_ASSERT (sz == 14);
TEST_ASSERT (!strncmp (test_string, "\x73\x74\x72\x3a \xf0\x9d\x94\xa3 \xf0\x9d\x94\xa4", sz));
sz = jerry_substring_to_utf8_char_buffer (args[0], 0, utf8_length + 1, (jerry_char_t *) test_string, utf8_sz);
TEST_ASSERT (sz == 14);
TEST_ASSERT (!strncmp (test_string, "\x73\x74\x72\x3a \xf0\x9d\x94\xa3 \xf0\x9d\x94\xa4", sz));
sz = jerry_substring_to_utf8_char_buffer (args[0], utf8_length, 0, (jerry_char_t *) test_string, utf8_sz);
TEST_ASSERT (sz == 0);
sz = jerry_substring_to_utf8_char_buffer (args[0], 0, utf8_length, (jerry_char_t *) test_string, utf8_sz - 1);
TEST_ASSERT (sz == 10);
TEST_ASSERT (!strncmp (test_string, "\x73\x74\x72\x3a \xf0\x9d\x94\xa3 ", sz));
sz = jerry_substring_to_utf8_char_buffer (args[0], 0, utf8_length - 1, (jerry_char_t *) test_string, utf8_sz);
TEST_ASSERT (sz == 10);
TEST_ASSERT (!strncmp (test_string, "\x73\x74\x72\x3a \xf0\x9d\x94\xa3 ", sz));
sz = jerry_substring_to_utf8_char_buffer (args[0],
utf8_length - 2,
utf8_length - 1,
(jerry_char_t *) test_string,
utf8_sz);
TEST_ASSERT (sz == 1);
TEST_ASSERT (!strncmp (test_string, " ", sz));
sz = jerry_substring_to_utf8_char_buffer (args[0],
utf8_length - 3,
utf8_length - 2,
(jerry_char_t *) test_string,
utf8_sz);
TEST_ASSERT (sz == 4);
TEST_ASSERT (!strncmp (test_string, "\xf0\x9d\x94\xa3", sz));
jerry_release_value (args[0]);
jerry_value_free (args[0]);
/* Test string: 'str: {DESERET CAPITAL LETTER LONG I}' */
args[0] = jerry_create_string ((jerry_char_t *) "\x73\x74\x72\x3a \xed\xa0\x81\xed\xb0\x80");
cesu8_bytes_p = "\x73\x74\x72\x3a \xed\xa0\x81\xed\xb0\x80";
args[0] = jerry_string ((jerry_char_t *) cesu8_bytes_p, (jerry_size_t) strlen (cesu8_bytes_p), JERRY_ENCODING_CESU8);
cesu8_length = jerry_get_string_length (args[0]);
utf8_length = jerry_get_utf8_string_length (args[0]);
cesu8_sz = jerry_string_size (args[0], JERRY_ENCODING_CESU8);
utf8_sz = jerry_string_size (args[0], JERRY_ENCODING_UTF8);
cesu8_sz = jerry_get_string_size (args[0]);
utf8_sz = jerry_get_utf8_string_size (args[0]);
TEST_ASSERT (cesu8_length == 7 && utf8_length == 6);
TEST_ASSERT (jerry_string_length (args[0]) == 7);
TEST_ASSERT (cesu8_sz != utf8_sz);
TEST_ASSERT (utf8_sz == 9 && cesu8_sz == 11);
jerry_release_value (args[0]);
jerry_value_free (args[0]);
/* Test string: 'price: 10{EURO SIGN}' */
args[0] = jerry_create_string_from_utf8 ((jerry_char_t *) "\x70\x72\x69\x63\x65\x3a \x31\x30\xe2\x82\xac");
utf8_bytes_p = "\x70\x72\x69\x63\x65\x3a \x31\x30\xe2\x82\xac";
args[0] = jerry_string ((jerry_char_t *) utf8_bytes_p, (jerry_size_t) strlen (utf8_bytes_p), JERRY_ENCODING_UTF8);
cesu8_length = jerry_get_string_length (args[0]);
utf8_length = jerry_get_utf8_string_length (args[0]);
cesu8_sz = jerry_string_size (args[0], JERRY_ENCODING_CESU8);
utf8_sz = jerry_string_size (args[0], JERRY_ENCODING_UTF8);
cesu8_sz = jerry_get_string_size (args[0]);
utf8_sz = jerry_get_utf8_string_size (args[0]);
TEST_ASSERT (cesu8_length == utf8_length);
TEST_ASSERT (cesu8_length == 10);
TEST_ASSERT (jerry_string_length (args[0]) == 10);
TEST_ASSERT (cesu8_sz == utf8_sz);
TEST_ASSERT (utf8_sz == 12);
jerry_release_value (args[0]);
jerry_value_free (args[0]);
/* Test string: '3' */
{
jerry_value_t test_str = jerry_create_string ((const jerry_char_t *) "3");
jerry_value_t test_str = jerry_string_sz ("3");
char result_string[1] = { 'E' };
jerry_size_t copied_utf8 =
jerry_substring_to_utf8_char_buffer (test_str, 0, 1, (jerry_char_t *) result_string, sizeof (result_string));
jerry_string_to_buffer (test_str, JERRY_ENCODING_UTF8, (jerry_char_t *) result_string, sizeof (result_string));
TEST_ASSERT (copied_utf8 == 1);
TEST_ASSERT (result_string[0] == '3');
result_string[0] = 'E';
jerry_size_t copied =
jerry_substring_to_char_buffer (test_str, 0, 1, (jerry_char_t *) result_string, sizeof (result_string));
jerry_string_to_buffer (test_str, JERRY_ENCODING_CESU8, (jerry_char_t *) result_string, sizeof (result_string));
TEST_ASSERT (copied == 1);
TEST_ASSERT (result_string[0] == '3');
jerry_release_value (test_str);
jerry_value_free (test_str);
}
/* Test jerry_substring_to_char_buffer */
args[0] = jerry_create_string ((jerry_char_t *) "an ascii string");
/* Buffer size */
cesu8_sz = 5;
JERRY_VLA (char, substring, cesu8_sz);
sz = jerry_substring_to_char_buffer (args[0], 3, 8, (jerry_char_t *) substring, cesu8_sz);
TEST_ASSERT (sz == 5);
TEST_ASSERT (!strncmp (substring, "ascii", sz));
/* Buffer size is 5, substring length is 11 => copied only the first 5 char */
sz = jerry_substring_to_char_buffer (args[0], 0, 11, (jerry_char_t *) substring, cesu8_sz);
TEST_ASSERT (sz == 5);
TEST_ASSERT (!strncmp (substring, "an as", sz));
/* Position of the first character is greater than the string length */
sz = jerry_substring_to_char_buffer (args[0], 16, 21, (jerry_char_t *) substring, cesu8_sz);
TEST_ASSERT (sz == 0);
sz = jerry_substring_to_char_buffer (args[0], 14, 15, (jerry_char_t *) substring, cesu8_sz);
TEST_ASSERT (sz == 1);
TEST_ASSERT (!strncmp (substring, "g", sz));
sz = jerry_substring_to_char_buffer (args[0], 0, 1, (jerry_char_t *) substring, cesu8_sz);
TEST_ASSERT (sz == 1);
TEST_ASSERT (!strncmp (substring, "a", sz));
cesu8_length = jerry_get_string_length (args[0]);
cesu8_sz = jerry_get_string_size (args[0]);
TEST_ASSERT (cesu8_length == 15);
TEST_ASSERT (cesu8_length == cesu8_sz);
JERRY_VLA (char, fullstring, cesu8_sz);
sz = jerry_substring_to_char_buffer (args[0], 0, cesu8_length, (jerry_char_t *) fullstring, cesu8_sz);
TEST_ASSERT (sz == 15);
TEST_ASSERT (!strncmp (fullstring, "an ascii string", sz));
jerry_release_value (args[0]);
/* Test jerry_substring_to_char_buffer: '0101' */
args[0] = jerry_create_string ((jerry_char_t *) "0101");
cesu8_sz = jerry_get_string_size (args[0]);
JERRY_VLA (char, number_substring, cesu8_sz);
sz = jerry_substring_to_char_buffer (args[0], 1, 3, (jerry_char_t *) number_substring, cesu8_sz);
TEST_ASSERT (sz == 2);
TEST_ASSERT (!strncmp (number_substring, "10", sz));
jerry_release_value (args[0]);
/* Test jerry_substring_to_char_buffer: 'str: {greek zero sign}' */
args[0] = jerry_create_string ((jerry_char_t *) "\x73\x74\x72\x3a \xed\xa0\x80\xed\xb6\x8a");
cesu8_sz = jerry_get_string_size (args[0]);
cesu8_length = jerry_get_string_length (args[0]);
TEST_ASSERT (cesu8_sz == 11);
TEST_ASSERT (cesu8_length = 7);
JERRY_VLA (char, supl_substring, cesu8_sz);
sz = jerry_substring_to_char_buffer (args[0], 0, cesu8_length, (jerry_char_t *) supl_substring, cesu8_sz);
TEST_ASSERT (sz == 11);
TEST_ASSERT (!strncmp (supl_substring, "\x73\x74\x72\x3a \xed\xa0\x80\xed\xb6\x8a", sz));
/* Decrease the buffer size => the low surrogate char will not fit into the buffer */
cesu8_sz -= 1;
sz = jerry_substring_to_char_buffer (args[0], 0, cesu8_length, (jerry_char_t *) supl_substring, cesu8_sz);
TEST_ASSERT (sz == 8);
TEST_ASSERT (!strncmp (supl_substring, "\x73\x74\x72\x3a \xed\xa0\x80", sz));
sz =
jerry_substring_to_char_buffer (args[0], cesu8_length - 1, cesu8_length, (jerry_char_t *) supl_substring, cesu8_sz);
TEST_ASSERT (sz == 3);
TEST_ASSERT (!strncmp (supl_substring, "\xed\xb6\x8a", sz));
sz = jerry_substring_to_char_buffer (args[0],
cesu8_length - 2,
cesu8_length - 1,
(jerry_char_t *) supl_substring,
cesu8_sz);
TEST_ASSERT (sz == 3);
TEST_ASSERT (!strncmp (supl_substring, "\xed\xa0\x80", sz));
jerry_release_value (args[0]);
jerry_cleanup ();
return 0;
tests/unit-core/test-api-value-type.c
+45 -44
View File
@@ -38,7 +38,7 @@ test_ext_function (const jerry_call_info_t *call_info_p, /**< call information *
(void) call_info_p;
(void) args_p;
(void) args_cnt;
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* test_ext_function */
int
@@ -48,103 +48,104 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
const jerry_char_t test_eval_function[] = "function demo(a) { return a + 1; }; demo";
const char test_eval_function[] = "function demo(a) { return a + 1; }; demo";
test_entry_t entries[] = {
ENTRY (JERRY_TYPE_NUMBER, jerry_create_number (-33.0)),
ENTRY (JERRY_TYPE_NUMBER, jerry_create_number (3)),
ENTRY (JERRY_TYPE_NUMBER, jerry_create_number_nan ()),
ENTRY (JERRY_TYPE_NUMBER, jerry_create_number_infinity (false)),
ENTRY (JERRY_TYPE_NUMBER, jerry_create_number_infinity (true)),
ENTRY (JERRY_TYPE_NUMBER, jerry_number (-33.0)),
ENTRY (JERRY_TYPE_NUMBER, jerry_number (3)),
ENTRY (JERRY_TYPE_NUMBER, jerry_nan ()),
ENTRY (JERRY_TYPE_NUMBER, jerry_infinity (false)),
ENTRY (JERRY_TYPE_NUMBER, jerry_infinity (true)),
ENTRY (JERRY_TYPE_BOOLEAN, jerry_create_boolean (true)),
ENTRY (JERRY_TYPE_BOOLEAN, jerry_create_boolean (false)),
ENTRY (JERRY_TYPE_BOOLEAN, jerry_boolean (true)),
ENTRY (JERRY_TYPE_BOOLEAN, jerry_boolean (false)),
ENTRY (JERRY_TYPE_UNDEFINED, jerry_create_undefined ()),
ENTRY (JERRY_TYPE_UNDEFINED, jerry_undefined ()),
ENTRY (JERRY_TYPE_OBJECT, jerry_create_object ()),
ENTRY (JERRY_TYPE_OBJECT, jerry_create_array (10)),
ENTRY (JERRY_TYPE_ERROR, jerry_create_error (JERRY_ERROR_TYPE, (const jerry_char_t *) "error")),
ENTRY (JERRY_TYPE_OBJECT, jerry_object ()),
ENTRY (JERRY_TYPE_OBJECT, jerry_array (10)),
ENTRY (JERRY_TYPE_EXCEPTION, jerry_throw_sz (JERRY_ERROR_TYPE, "error")),
ENTRY (JERRY_TYPE_NULL, jerry_create_null ()),
ENTRY (JERRY_TYPE_NULL, jerry_null ()),
ENTRY (JERRY_TYPE_FUNCTION, jerry_eval (test_eval_function, sizeof (test_eval_function) - 1, JERRY_PARSE_NO_OPTS)),
ENTRY (JERRY_TYPE_FUNCTION, jerry_create_external_function (test_ext_function)),
ENTRY (JERRY_TYPE_FUNCTION,
jerry_eval ((jerry_char_t *) test_eval_function, sizeof (test_eval_function) - 1, JERRY_PARSE_NO_OPTS)),
ENTRY (JERRY_TYPE_FUNCTION, jerry_function_external (test_ext_function)),
ENTRY (JERRY_TYPE_STRING, jerry_create_string (test_eval_function)),
ENTRY (JERRY_TYPE_STRING, jerry_create_string ((jerry_char_t *) "")),
ENTRY (JERRY_TYPE_STRING, jerry_string_sz (test_eval_function)),
ENTRY (JERRY_TYPE_STRING, jerry_string_sz ("")),
};
for (size_t idx = 0; idx < sizeof (entries) / sizeof (entries[0]); idx++)
{
jerry_type_t type_info = jerry_value_get_type (entries[idx].value);
jerry_type_t type_info = jerry_value_type (entries[idx].value);
TEST_ASSERT (type_info != JERRY_TYPE_NONE);
TEST_ASSERT (type_info == entries[idx].type_info);
jerry_release_value (entries[idx].value);
jerry_value_free (entries[idx].value);
}
if (jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
if (jerry_feature_enabled (JERRY_FEATURE_SYMBOL))
{
jerry_value_t symbol_desc_value = jerry_create_string ((jerry_char_t *) "foo");
jerry_value_t symbol_value = jerry_create_symbol (symbol_desc_value);
jerry_type_t type_info = jerry_value_get_type (symbol_value);
jerry_value_t symbol_desc_value = jerry_string_sz ("foo");
jerry_value_t symbol_value = jerry_symbol_with_description (symbol_desc_value);
jerry_type_t type_info = jerry_value_type (symbol_value);
TEST_ASSERT (type_info != JERRY_TYPE_NONE);
TEST_ASSERT (type_info == JERRY_TYPE_SYMBOL);
jerry_release_value (symbol_value);
jerry_release_value (symbol_desc_value);
jerry_value_free (symbol_value);
jerry_value_free (symbol_desc_value);
}
if (jerry_is_feature_enabled (JERRY_FEATURE_BIGINT))
if (jerry_feature_enabled (JERRY_FEATURE_BIGINT))
{
/* Check simple bigint value type */
uint64_t digits_buffer[2] = { 1, 0 };
jerry_value_t value_bigint = jerry_create_bigint (digits_buffer, 2, false);
jerry_type_t value_type_info = jerry_value_get_type (value_bigint);
jerry_value_t value_bigint = jerry_bigint (digits_buffer, 2, false);
jerry_type_t value_type_info = jerry_value_type (value_bigint);
TEST_ASSERT (value_type_info != JERRY_TYPE_NONE);
TEST_ASSERT (value_type_info == JERRY_TYPE_BIGINT);
jerry_release_value (value_bigint);
jerry_value_free (value_bigint);
/* Check bigint wrapped in object type */
jerry_char_t object_bigint_src[] = "Object(5n)";
jerry_value_t object_bigint = jerry_eval (object_bigint_src, sizeof (object_bigint_src) - 1, JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (object_bigint));
TEST_ASSERT (!jerry_value_is_exception (object_bigint));
jerry_type_t object_type_info = jerry_value_get_type (object_bigint);
jerry_type_t object_type_info = jerry_value_type (object_bigint);
TEST_ASSERT (object_type_info != JERRY_TYPE_NONE);
TEST_ASSERT (object_type_info == JERRY_TYPE_OBJECT);
jerry_release_value (object_bigint);
jerry_value_free (object_bigint);
}
if (jerry_is_feature_enabled (JERRY_FEATURE_REALM))
if (jerry_feature_enabled (JERRY_FEATURE_REALM))
{
jerry_value_t new_realm = jerry_create_realm ();
jerry_value_t new_realm = jerry_realm ();
jerry_value_t old_realm = jerry_set_realm (new_realm);
jerry_type_t new_realm_type = jerry_value_get_type (new_realm);
jerry_type_t new_realm_type = jerry_value_type (new_realm);
TEST_ASSERT (new_realm_type == JERRY_TYPE_OBJECT);
jerry_value_t new_realm_this = jerry_realm_get_this (new_realm);
jerry_type_t new_realm_this_type = jerry_value_get_type (new_realm_this);
jerry_value_t new_realm_this = jerry_realm_this (new_realm);
jerry_type_t new_realm_this_type = jerry_value_type (new_realm_this);
TEST_ASSERT (new_realm_this_type == JERRY_TYPE_OBJECT);
jerry_release_value (new_realm_this);
jerry_value_free (new_realm_this);
jerry_type_t old_realm_type = jerry_value_get_type (old_realm);
jerry_type_t old_realm_type = jerry_value_type (old_realm);
TEST_ASSERT (old_realm_type == JERRY_TYPE_OBJECT);
jerry_release_value (new_realm);
jerry_value_free (new_realm);
jerry_value_t old_realm_this = jerry_realm_get_this (old_realm);
jerry_type_t old_realm_this_type = jerry_value_get_type (old_realm_this);
jerry_value_t old_realm_this = jerry_realm_this (old_realm);
jerry_type_t old_realm_this_type = jerry_value_type (old_realm_this);
TEST_ASSERT (old_realm_this_type == JERRY_TYPE_OBJECT);
jerry_release_value (old_realm_this);
jerry_value_free (old_realm_this);
/* Restore the old realm as per docs */
jerry_set_realm (old_realm);
tests/unit-core/test-api.c
+356 -362
View File
File diff suppressed because it is too large Load Diff
tests/unit-core/test-arraybuffer.c
+80 -94
View File
@@ -26,16 +26,16 @@ static void
register_js_value (const char *name_p, /**< name of the function */
jerry_value_t value) /**< JS value */
{
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t name_val = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t result_val = jerry_set_property (global_obj_val, name_val, value);
jerry_value_t name_val = jerry_string_sz (name_p);
jerry_value_t result_val = jerry_object_set (global_obj_val, name_val, value);
TEST_ASSERT (jerry_value_is_boolean (result_val));
jerry_release_value (name_val);
jerry_release_value (global_obj_val);
jerry_value_free (name_val);
jerry_value_free (global_obj_val);
jerry_release_value (result_val);
jerry_value_free (result_val);
} /* register_js_value */
static jerry_value_t
@@ -47,17 +47,17 @@ assert_handler (const jerry_call_info_t *call_info_p, /**< call information */
if (args_cnt > 0 && jerry_value_is_true (args_p[0]))
{
return jerry_create_boolean (true);
return jerry_boolean (true);
}
if (args_cnt > 1 && jerry_value_is_string (args_p[1]))
{
jerry_length_t utf8_sz = jerry_get_string_size (args_p[1]);
jerry_length_t utf8_sz = jerry_string_size (args_p[1], JERRY_ENCODING_CESU8);
TEST_ASSERT (utf8_sz <= 127); /* 127 is the expected max assert fail message size. */
JERRY_VLA (char, string_from_utf8, utf8_sz + 1);
string_from_utf8[utf8_sz] = 0;
jerry_string_to_char_buffer (args_p[1], (jerry_char_t *) string_from_utf8, utf8_sz);
jerry_string_to_buffer (args_p[1], JERRY_ENCODING_CESU8, (jerry_char_t *) string_from_utf8, utf8_sz);
printf ("JS assert: %s\n", string_from_utf8);
}
@@ -78,9 +78,9 @@ test_read_with_offset (uint8_t offset) /**< offset for buffer read. */
jerry_value_t arraybuffer =
jerry_eval (eval_arraybuffer_src, sizeof (eval_arraybuffer_src) - 1, JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
TEST_ASSERT (!jerry_value_is_exception (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == 15);
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == 15);
uint8_t buffer[20];
memset (buffer, 120, 20);
@@ -95,7 +95,7 @@ test_read_with_offset (uint8_t offset) /**< offset for buffer read. */
}
TEST_ASSERT (buffer[15 - offset] == 120);
jerry_release_value (arraybuffer);
jerry_value_free (arraybuffer);
} /* test_read_with_offset */
/**
@@ -105,18 +105,18 @@ static void
test_write_with_offset (uint8_t offset) /**< offset for buffer write. */
{
{
jerry_value_t offset_val = jerry_create_number (offset);
jerry_value_t offset_val = jerry_number (offset);
register_js_value ("offset", offset_val);
jerry_release_value (offset_val);
jerry_value_free (offset_val);
}
const jerry_char_t eval_arraybuffer_src[] = "var array = new Uint8Array (15); array.buffer";
jerry_value_t arraybuffer =
jerry_eval (eval_arraybuffer_src, sizeof (eval_arraybuffer_src) - 1, JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
TEST_ASSERT (!jerry_value_is_exception (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == 15);
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == 15);
uint8_t buffer[20];
@@ -141,8 +141,8 @@ test_write_with_offset (uint8_t offset) /**< offset for buffer write. */
"};"
"assert (array[15] === undefined, 'ArrayBuffer out of bounds index should return undefined value');");
jerry_value_t res = jerry_eval (eval_test_arraybuffer, sizeof (eval_test_arraybuffer) - 1, JERRY_PARSE_STRICT_MODE);
jerry_release_value (res);
jerry_release_value (arraybuffer);
jerry_value_free (res);
jerry_value_free (arraybuffer);
} /* test_write_with_offset */
static int allocate_mode = 0;
@@ -205,39 +205,39 @@ main (void)
{
jerry_init (JERRY_INIT_EMPTY);
if (!jerry_is_feature_enabled (JERRY_FEATURE_TYPEDARRAY))
if (!jerry_feature_enabled (JERRY_FEATURE_TYPEDARRAY))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "ArrayBuffer is disabled!\n");
jerry_cleanup ();
return 0;
}
jerry_arraybuffer_set_compact_allocation_limit (4);
jerry_arraybuffer_set_allocator_callbacks (test_allocate_cb, test_free_cb, (void *) &allocate_mode);
jerry_arraybuffer_heap_allocation_limit (4);
jerry_arraybuffer_allocator (test_allocate_cb, test_free_cb, (void *) &allocate_mode);
jerry_value_t function_val = jerry_create_external_function (assert_handler);
jerry_value_t function_val = jerry_function_external (assert_handler);
register_js_value ("assert", function_val);
jerry_release_value (function_val);
jerry_value_free (function_val);
/* Test array buffer queries */
{
const jerry_char_t eval_arraybuffer_src[] = "new ArrayBuffer (10)";
jerry_value_t eval_arraybuffer =
jerry_eval (eval_arraybuffer_src, sizeof (eval_arraybuffer_src) - 1, JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (!jerry_value_is_error (eval_arraybuffer));
TEST_ASSERT (!jerry_value_is_exception (eval_arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (eval_arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (eval_arraybuffer) == 10);
jerry_release_value (eval_arraybuffer);
TEST_ASSERT (jerry_arraybuffer_size (eval_arraybuffer) == 10);
jerry_value_free (eval_arraybuffer);
}
/* Test array buffer creation */
{
const uint32_t length = 15;
jerry_value_t arraybuffer = jerry_create_arraybuffer (length);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
jerry_value_t arraybuffer = jerry_arraybuffer (length);
TEST_ASSERT (!jerry_value_is_exception (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
jerry_release_value (arraybuffer);
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == length);
jerry_value_free (arraybuffer);
}
/* Test array buffer read operations */
@@ -249,10 +249,10 @@ main (void)
/* Test zero length ArrayBuffer read */
{
const uint32_t length = 0;
jerry_value_t arraybuffer = jerry_create_arraybuffer (length);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
jerry_value_t arraybuffer = jerry_arraybuffer (length);
TEST_ASSERT (!jerry_value_is_exception (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == length);
uint8_t data[20];
memset (data, 11, 20);
@@ -265,7 +265,7 @@ main (void)
TEST_ASSERT (data[i] == 11);
}
jerry_release_value (arraybuffer);
jerry_value_free (arraybuffer);
}
/* Test array buffer write operations */
@@ -277,10 +277,10 @@ main (void)
/* Test zero length ArrayBuffer write */
{
const uint32_t length = 0;
jerry_value_t arraybuffer = jerry_create_arraybuffer (length);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
jerry_value_t arraybuffer = jerry_arraybuffer (length);
TEST_ASSERT (!jerry_value_is_exception (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == length);
uint8_t data[20];
memset (data, 11, 20);
@@ -288,17 +288,17 @@ main (void)
jerry_length_t bytes_written = jerry_arraybuffer_write (arraybuffer, 0, data, 20);
TEST_ASSERT (bytes_written == 0);
jerry_release_value (arraybuffer);
jerry_value_free (arraybuffer);
}
/* Test zero length external ArrayBuffer */
{
const uint32_t length = 0;
jerry_value_t arraybuffer = jerry_create_arraybuffer_external (length, NULL, NULL);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
jerry_value_t arraybuffer = jerry_arraybuffer_external (NULL, length, NULL);
TEST_ASSERT (!jerry_value_is_exception (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_is_arraybuffer_detachable (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
TEST_ASSERT (jerry_arraybuffer_is_detachable (arraybuffer));
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == length);
uint8_t data[20];
memset (data, 11, 20);
@@ -306,7 +306,7 @@ main (void)
jerry_length_t bytes_written = jerry_arraybuffer_write (arraybuffer, 0, data, 20);
TEST_ASSERT (bytes_written == 0);
jerry_release_value (arraybuffer);
jerry_value_free (arraybuffer);
}
/* Test ArrayBuffer with buffer allocated externally */
@@ -317,12 +317,12 @@ main (void)
uint8_t *buffer_p = (uint8_t *) malloc (buffer_size);
memset (buffer_p, base_value, buffer_size);
jerry_value_t arrayb = jerry_create_arraybuffer_external (buffer_size, buffer_p, NULL);
jerry_value_t arrayb = jerry_arraybuffer_external (buffer_p, buffer_size, NULL);
uint8_t new_value = 123;
jerry_length_t copied = jerry_arraybuffer_write (arrayb, 0, &new_value, 1);
TEST_ASSERT (copied == 1);
TEST_ASSERT (buffer_p[0] == new_value);
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arrayb) == buffer_size);
TEST_ASSERT (jerry_arraybuffer_size (arrayb) == buffer_size);
for (uint32_t i = 1; i < buffer_size; i++)
{
@@ -340,16 +340,16 @@ main (void)
}
TEST_ASSERT (jerry_value_is_arraybuffer (arrayb));
jerry_release_value (arrayb);
jerry_value_free (arrayb);
}
/* Test ArrayBuffer external memory map/unmap */
{
const uint32_t buffer_size = 20;
jerry_value_t input_buffer = jerry_create_arraybuffer_external (buffer_size, NULL, (void *) &allocate_count);
jerry_value_t input_buffer = jerry_arraybuffer_external (NULL, buffer_size, (void *) &allocate_count);
register_js_value ("input_buffer", input_buffer);
jerry_release_value (input_buffer);
jerry_value_free (input_buffer);
const jerry_char_t eval_arraybuffer_src[] = TEST_STRING_LITERAL ("var array = new Uint8Array(input_buffer);"
"for (var i = 0; i < array.length; i++)"
@@ -360,11 +360,11 @@ main (void)
jerry_value_t buffer =
jerry_eval (eval_arraybuffer_src, sizeof (eval_arraybuffer_src) - 1, JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (!jerry_value_is_error (buffer));
TEST_ASSERT (!jerry_value_is_exception (buffer));
TEST_ASSERT (jerry_value_is_arraybuffer (buffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (buffer) == 20);
TEST_ASSERT (jerry_arraybuffer_size (buffer) == 20);
uint8_t *const data = jerry_get_arraybuffer_pointer (buffer);
uint8_t *const data = jerry_arraybuffer_data (buffer);
TEST_ASSERT (data != NULL);
@@ -393,71 +393,57 @@ main (void)
"sum");
jerry_value_t res = jerry_eval (eval_test_arraybuffer, sizeof (eval_test_arraybuffer) - 1, JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (jerry_value_is_number (res));
TEST_ASSERT (jerry_get_number_value (res) == sum);
jerry_release_value (res);
TEST_ASSERT (jerry_value_as_number (res) == sum);
jerry_value_free (res);
jerry_release_value (buffer);
jerry_value_free (buffer);
}
/* Test internal ArrayBuffer detach */
{
const uint32_t length = 4;
jerry_value_t arraybuffer = jerry_create_arraybuffer (length);
jerry_value_t arraybuffer = jerry_arraybuffer (length);
TEST_ASSERT (jerry_arraybuffer_has_buffer (arraybuffer));
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
TEST_ASSERT (!jerry_value_is_exception (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == length);
TEST_ASSERT (jerry_arraybuffer_is_detachable (arraybuffer));
jerry_value_t is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
TEST_ASSERT (jerry_value_is_true (is_detachable));
jerry_release_value (is_detachable);
jerry_value_t res = jerry_detach_arraybuffer (arraybuffer);
jerry_value_t res = jerry_arraybuffer_detach (arraybuffer);
TEST_ASSERT (!jerry_arraybuffer_has_buffer (arraybuffer));
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (jerry_get_arraybuffer_pointer (arraybuffer) == NULL);
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == 0);
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (jerry_arraybuffer_data (arraybuffer) == NULL);
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == 0);
TEST_ASSERT (!jerry_arraybuffer_is_detachable (arraybuffer));
is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
TEST_ASSERT (jerry_value_is_false (is_detachable));
jerry_release_value (is_detachable);
jerry_release_value (res);
jerry_release_value (arraybuffer);
jerry_value_free (res);
jerry_value_free (arraybuffer);
}
/* Test external ArrayBuffer detach */
{
const uint32_t length = 64;
jerry_value_t arraybuffer = jerry_create_arraybuffer_external (length, NULL, NULL);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
jerry_value_t arraybuffer = jerry_arraybuffer_external (NULL, length, NULL);
TEST_ASSERT (!jerry_value_is_exception (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == length);
TEST_ASSERT (!jerry_arraybuffer_has_buffer (arraybuffer));
uint8_t buf[1] = { 1 };
TEST_ASSERT (jerry_arraybuffer_write (arraybuffer, 0, buf, 1) == 1);
TEST_ASSERT (jerry_arraybuffer_has_buffer (arraybuffer));
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == length);
TEST_ASSERT (jerry_arraybuffer_is_detachable (arraybuffer));
jerry_value_t is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
TEST_ASSERT (!jerry_value_is_error (is_detachable));
TEST_ASSERT (jerry_value_is_true (is_detachable));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
jerry_release_value (is_detachable);
jerry_value_t res = jerry_detach_arraybuffer (arraybuffer);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (jerry_get_arraybuffer_pointer (arraybuffer) == NULL);
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == 0);
is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
TEST_ASSERT (!jerry_value_is_error (is_detachable));
TEST_ASSERT (!jerry_value_is_true (is_detachable));
jerry_value_t res = jerry_arraybuffer_detach (arraybuffer);
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (jerry_arraybuffer_data (arraybuffer) == NULL);
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == 0);
TEST_ASSERT (!jerry_arraybuffer_has_buffer (arraybuffer));
jerry_release_value (is_detachable);
TEST_ASSERT (!jerry_arraybuffer_is_detachable (arraybuffer));
jerry_release_value (res);
jerry_release_value (arraybuffer);
jerry_value_free (res);
jerry_value_free (arraybuffer);
}
/* Test ArrayBuffer created in ECMAScript */
@@ -465,7 +451,7 @@ main (void)
{
const jerry_char_t source[] = TEST_STRING_LITERAL ("new ArrayBuffer(64)");
jerry_value_t arraybuffer = jerry_eval (source, sizeof (source) - 1, JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
TEST_ASSERT (!jerry_value_is_exception (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (!jerry_arraybuffer_has_buffer (arraybuffer));
@@ -482,13 +468,13 @@ main (void)
}
else
{
uint8_t *buffer_p = jerry_get_arraybuffer_pointer (arraybuffer);
uint8_t *buffer_p = jerry_arraybuffer_data (arraybuffer);
TEST_ASSERT (buffer_p != NULL);
}
TEST_ASSERT (jerry_arraybuffer_has_buffer (arraybuffer));
jerry_release_value (arraybuffer);
jerry_value_free (arraybuffer);
}
jerry_cleanup ();
tests/unit-core/test-backtrace.c
+99 -99
View File
@@ -29,10 +29,10 @@ backtrace_handler (const jerry_call_info_t *call_info_p, /**< call information *
if (args_count >= 1 && jerry_value_is_number (args_p[0]))
{
max_depth = (uint32_t) jerry_get_number_value (args_p[0]);
max_depth = (uint32_t) jerry_value_as_number (args_p[0]);
}
return jerry_get_backtrace (max_depth);
return jerry_backtrace (max_depth);
} /* backtrace_handler */
static void
@@ -44,9 +44,9 @@ compare_string (jerry_value_t left_value, /* string value */
TEST_ASSERT (length <= sizeof (buffer));
TEST_ASSERT (jerry_value_is_string (left_value));
TEST_ASSERT (jerry_get_string_size (left_value) == length);
TEST_ASSERT (jerry_string_size (left_value, JERRY_ENCODING_CESU8) == length);
TEST_ASSERT (jerry_string_to_char_buffer (left_value, buffer, sizeof (buffer)) == length);
TEST_ASSERT (jerry_string_to_buffer (left_value, JERRY_ENCODING_CESU8, buffer, sizeof (buffer)) == length);
TEST_ASSERT (memcmp (buffer, right_p, length) == 0);
} /* compare_string */
@@ -54,27 +54,27 @@ static const jerry_value_t *handler_args_p;
static int frame_index;
static bool
backtrace_callback (jerry_backtrace_frame_t *frame_p, /* frame information */
backtrace_callback (jerry_frame_t *frame_p, /* frame information */
void *user_p) /* user data */
{
TEST_ASSERT ((void *) handler_args_p == user_p);
TEST_ASSERT (jerry_backtrace_get_frame_type (frame_p) == JERRY_BACKTRACE_FRAME_JS);
TEST_ASSERT (jerry_frame_type (frame_p) == JERRY_BACKTRACE_FRAME_JS);
const jerry_backtrace_location_t *location_p = jerry_backtrace_get_location (frame_p);
const jerry_value_t *function_p = jerry_backtrace_get_function (frame_p);
const jerry_value_t *this_p = jerry_backtrace_get_this (frame_p);
const jerry_frame_location_t *location_p = jerry_frame_location (frame_p);
const jerry_value_t *function_p = jerry_frame_callee (frame_p);
const jerry_value_t *this_p = jerry_frame_this (frame_p);
TEST_ASSERT (location_p != NULL);
TEST_ASSERT (function_p != NULL);
TEST_ASSERT (this_p != NULL);
compare_string (location_p->resource_name, "capture_test.js");
compare_string (location_p->source_name, "capture_test.js");
++frame_index;
if (frame_index == 1)
{
TEST_ASSERT (!jerry_backtrace_is_strict (frame_p));
TEST_ASSERT (!jerry_frame_is_strict (frame_p));
TEST_ASSERT (location_p->line == 2);
TEST_ASSERT (location_p->column == 3);
TEST_ASSERT (handler_args_p[0] == *function_p);
@@ -84,7 +84,7 @@ backtrace_callback (jerry_backtrace_frame_t *frame_p, /* frame information */
if (frame_index == 2)
{
TEST_ASSERT (jerry_backtrace_is_strict (frame_p));
TEST_ASSERT (jerry_frame_is_strict (frame_p));
TEST_ASSERT (location_p->line == 7);
TEST_ASSERT (location_p->column == 6);
TEST_ASSERT (handler_args_p[2] == *function_p);
@@ -92,39 +92,39 @@ backtrace_callback (jerry_backtrace_frame_t *frame_p, /* frame information */
return true;
}
jerry_value_t global = jerry_get_global_object ();
jerry_value_t global = jerry_current_realm ();
TEST_ASSERT (frame_index == 3);
TEST_ASSERT (!jerry_backtrace_is_strict (frame_p));
TEST_ASSERT (!jerry_frame_is_strict (frame_p));
TEST_ASSERT (location_p->line == 11);
TEST_ASSERT (location_p->column == 3);
TEST_ASSERT (handler_args_p[3] == *function_p);
TEST_ASSERT (global == *this_p);
jerry_release_value (global);
jerry_value_free (global);
return false;
} /* backtrace_callback */
static bool
async_backtrace_callback (jerry_backtrace_frame_t *frame_p, /* frame information */
async_backtrace_callback (jerry_frame_t *frame_p, /* frame information */
void *user_p) /* user data */
{
TEST_ASSERT ((void *) handler_args_p == user_p);
TEST_ASSERT (jerry_backtrace_get_frame_type (frame_p) == JERRY_BACKTRACE_FRAME_JS);
TEST_ASSERT (jerry_frame_type (frame_p) == JERRY_BACKTRACE_FRAME_JS);
const jerry_backtrace_location_t *location_p = jerry_backtrace_get_location (frame_p);
const jerry_value_t *function_p = jerry_backtrace_get_function (frame_p);
const jerry_frame_location_t *location_p = jerry_frame_location (frame_p);
const jerry_value_t *function_p = jerry_frame_callee (frame_p);
TEST_ASSERT (location_p != NULL);
TEST_ASSERT (function_p != NULL);
compare_string (location_p->resource_name, "async_capture_test.js");
compare_string (location_p->source_name, "async_capture_test.js");
++frame_index;
if (frame_index == 1)
{
TEST_ASSERT (jerry_backtrace_is_strict (frame_p));
TEST_ASSERT (jerry_frame_is_strict (frame_p));
TEST_ASSERT (location_p->line == 3);
TEST_ASSERT (location_p->column == 3);
TEST_ASSERT (handler_args_p[0] == *function_p);
@@ -132,7 +132,7 @@ async_backtrace_callback (jerry_backtrace_frame_t *frame_p, /* frame information
}
TEST_ASSERT (frame_index == 2);
TEST_ASSERT (!jerry_backtrace_is_strict (frame_p));
TEST_ASSERT (!jerry_frame_is_strict (frame_p));
TEST_ASSERT (location_p->line == 8);
TEST_ASSERT (location_p->column == 3);
TEST_ASSERT (handler_args_p[1] == *function_p);
@@ -140,32 +140,32 @@ async_backtrace_callback (jerry_backtrace_frame_t *frame_p, /* frame information
} /* async_backtrace_callback */
static bool
class_backtrace_callback (jerry_backtrace_frame_t *frame_p, /* frame information */
class_backtrace_callback (jerry_frame_t *frame_p, /* frame information */
void *user_p) /* user data */
{
TEST_ASSERT ((void *) handler_args_p == user_p);
TEST_ASSERT (jerry_backtrace_get_frame_type (frame_p) == JERRY_BACKTRACE_FRAME_JS);
TEST_ASSERT (jerry_frame_type (frame_p) == JERRY_BACKTRACE_FRAME_JS);
const jerry_backtrace_location_t *location_p = jerry_backtrace_get_location (frame_p);
const jerry_value_t *function_p = jerry_backtrace_get_function (frame_p);
const jerry_frame_location_t *location_p = jerry_frame_location (frame_p);
const jerry_value_t *function_p = jerry_frame_callee (frame_p);
TEST_ASSERT (location_p != NULL);
TEST_ASSERT (function_p != NULL);
compare_string (location_p->resource_name, "class_capture_test.js");
compare_string (location_p->source_name, "class_capture_test.js");
++frame_index;
if (frame_index == 1)
{
TEST_ASSERT (jerry_backtrace_is_strict (frame_p));
TEST_ASSERT (jerry_frame_is_strict (frame_p));
TEST_ASSERT (location_p->line == 3);
TEST_ASSERT (location_p->column == 14);
return false;
}
TEST_ASSERT (frame_index == 2);
TEST_ASSERT (jerry_backtrace_is_strict (frame_p));
TEST_ASSERT (jerry_frame_is_strict (frame_p));
TEST_ASSERT (location_p->line == 2);
TEST_ASSERT (location_p->column == 7);
return false;
@@ -181,7 +181,7 @@ capture_handler (const jerry_call_info_t *call_info_p, /**< call information */
TEST_ASSERT (args_count == 0 || args_count == 2 || args_count == 4);
TEST_ASSERT (args_count == 0 || frame_index == 0);
jerry_backtrace_callback_t callback = backtrace_callback;
jerry_backtrace_cb_t callback = backtrace_callback;
if (args_count == 0)
{
@@ -197,22 +197,22 @@ capture_handler (const jerry_call_info_t *call_info_p, /**< call information */
TEST_ASSERT (args_count == 0 || frame_index == (args_count == 4 ? 3 : 2));
return jerry_create_undefined ();
return jerry_undefined ();
} /* capture_handler */
static bool
global_backtrace_callback (jerry_backtrace_frame_t *frame_p, /* frame information */
global_backtrace_callback (jerry_frame_t *frame_p, /* frame information */
void *user_p) /* user data */
{
TEST_ASSERT (user_p != NULL && frame_index == 0);
frame_index++;
const jerry_value_t *function_p = jerry_backtrace_get_function (frame_p);
const jerry_value_t *function_p = jerry_frame_callee (frame_p);
jerry_value_t *result_p = ((jerry_value_t *) user_p);
TEST_ASSERT (function_p != NULL);
jerry_release_value (*result_p);
*result_p = jerry_acquire_value (*function_p);
jerry_value_free (*result_p);
*result_p = jerry_value_copy (*function_p);
return true;
} /* global_backtrace_callback */
@@ -225,7 +225,7 @@ global_capture_handler (const jerry_call_info_t *call_info_p, /**< call informat
JERRY_UNUSED (args_p);
JERRY_UNUSED (args_count);
jerry_value_t result = jerry_create_undefined ();
jerry_value_t result = jerry_undefined ();
jerry_backtrace_capture (global_backtrace_callback, &result);
TEST_ASSERT (jerry_value_is_object (result));
@@ -236,34 +236,34 @@ static void
register_callback (jerry_external_handler_t handler_p, /**< callback function */
char *name_p) /**< name of the function */
{
jerry_value_t global = jerry_get_global_object ();
jerry_value_t global = jerry_current_realm ();
jerry_value_t func = jerry_create_external_function (handler_p);
jerry_value_t name = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t result = jerry_set_property (global, name, func);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_value_t func = jerry_function_external (handler_p);
jerry_value_t name = jerry_string_sz (name_p);
jerry_value_t result = jerry_object_set (global, name, func);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_release_value (result);
jerry_release_value (name);
jerry_release_value (func);
jerry_value_free (result);
jerry_value_free (name);
jerry_value_free (func);
jerry_release_value (global);
jerry_value_free (global);
} /* register_callback */
static jerry_value_t
run (const char *resource_name_p, /**< resource name */
run (const char *source_name_p, /**< resource name */
const char *source_p) /**< source code */
{
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name = jerry_create_string ((const jerry_char_t *) resource_name_p);
parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string_sz (source_name_p);
jerry_value_t code = jerry_parse ((const jerry_char_t *) source_p, strlen (source_p), &parse_options);
jerry_release_value (parse_options.resource_name);
TEST_ASSERT (!jerry_value_is_error (code));
jerry_value_free (parse_options.source_name);
TEST_ASSERT (!jerry_value_is_exception (code));
jerry_value_t result = jerry_run (code);
jerry_release_value (code);
jerry_value_free (code);
return result;
} /* run */
@@ -279,16 +279,16 @@ compare (jerry_value_t array, /**< array */
TEST_ASSERT (len < sizeof (buf));
jerry_value_t value = jerry_get_property_by_index (array, index);
jerry_value_t value = jerry_object_get_index (array, index);
TEST_ASSERT (!jerry_value_is_error (value) && jerry_value_is_string (value));
TEST_ASSERT (!jerry_value_is_exception (value) && jerry_value_is_string (value));
TEST_ASSERT (jerry_get_string_size (value) == len);
TEST_ASSERT (jerry_string_size (value, JERRY_ENCODING_CESU8) == len);
jerry_size_t str_len = jerry_string_to_char_buffer (value, buf, (jerry_size_t) len);
jerry_size_t str_len = jerry_string_to_buffer (value, JERRY_ENCODING_CESU8, buf, (jerry_size_t) len);
TEST_ASSERT (str_len == len);
jerry_release_value (value);
jerry_value_free (value);
TEST_ASSERT (memcmp (buf, str, len) == 0);
} /* compare */
@@ -317,16 +317,16 @@ test_get_backtrace_api_call (void)
jerry_value_t backtrace = run ("something.js", source_p);
TEST_ASSERT (!jerry_value_is_error (backtrace) && jerry_value_is_array (backtrace));
TEST_ASSERT (!jerry_value_is_exception (backtrace) && jerry_value_is_array (backtrace));
TEST_ASSERT (jerry_get_array_length (backtrace) == 4);
TEST_ASSERT (jerry_array_length (backtrace) == 4);
compare (backtrace, 0, "something.js:2:3");
compare (backtrace, 1, "something.js:6:3");
compare (backtrace, 2, "something.js:10:3");
compare (backtrace, 3, "something.js:13:1");
jerry_release_value (backtrace);
jerry_value_free (backtrace);
/* Depth set to 2 this time. */
@@ -346,14 +346,14 @@ test_get_backtrace_api_call (void)
backtrace = run ("something_else.js", source_p);
TEST_ASSERT (!jerry_value_is_error (backtrace) && jerry_value_is_array (backtrace));
TEST_ASSERT (!jerry_value_is_exception (backtrace) && jerry_value_is_array (backtrace));
TEST_ASSERT (jerry_get_array_length (backtrace) == 2);
TEST_ASSERT (jerry_array_length (backtrace) == 2);
compare (backtrace, 0, "something_else.js:2:6");
compare (backtrace, 1, "something_else.js:6:3");
jerry_release_value (backtrace);
jerry_value_free (backtrace);
/* Test frame capturing. */
@@ -376,7 +376,7 @@ test_get_backtrace_api_call (void)
jerry_value_t result = run ("capture_test.js", source_p);
TEST_ASSERT (jerry_value_is_undefined (result));
jerry_release_value (result);
jerry_value_free (result);
TEST_ASSERT (frame_index == 3);
@@ -384,9 +384,9 @@ test_get_backtrace_api_call (void)
source_p = "async function f() {}";
result = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), JERRY_PARSE_NO_OPTS);
if (!jerry_value_is_error (result))
if (!jerry_value_is_exception (result))
{
jerry_release_value (result);
jerry_value_free (result);
frame_index = 0;
source_p = ("function f() {\n"
@@ -404,29 +404,29 @@ test_get_backtrace_api_call (void)
result = run ("async_capture_test.js", source_p);
TEST_ASSERT (jerry_value_is_promise (result));
jerry_release_value (result);
jerry_value_free (result);
TEST_ASSERT (frame_index == 0);
result = jerry_run_all_enqueued_jobs ();
TEST_ASSERT (!jerry_value_is_error (result));
result = jerry_run_jobs ();
TEST_ASSERT (!jerry_value_is_exception (result));
TEST_ASSERT (frame_index == 2);
}
else
{
TEST_ASSERT (jerry_get_error_type (result) == JERRY_ERROR_SYNTAX);
TEST_ASSERT (jerry_error_type (result) == JERRY_ERROR_SYNTAX);
}
jerry_release_value (result);
jerry_value_free (result);
/* Test class initializer frame capturing. */
source_p = "class C {}";
result = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), JERRY_PARSE_NO_OPTS);
if (!jerry_value_is_error (result))
if (!jerry_value_is_exception (result))
{
jerry_release_value (result);
jerry_value_free (result);
frame_index = 0;
source_p = ("class C {\n"
@@ -437,15 +437,15 @@ test_get_backtrace_api_call (void)
result = run ("class_capture_test.js", source_p);
TEST_ASSERT (!jerry_value_is_error (result));
TEST_ASSERT (!jerry_value_is_exception (result));
TEST_ASSERT (frame_index == 2);
}
else
{
TEST_ASSERT (jerry_get_error_type (result) == JERRY_ERROR_SYNTAX);
TEST_ASSERT (jerry_error_type (result) == JERRY_ERROR_SYNTAX);
}
jerry_release_value (result);
jerry_value_free (result);
register_callback (global_capture_handler, "global_capture");
@@ -454,16 +454,16 @@ test_get_backtrace_api_call (void)
source_p = "global_capture()";
jerry_value_t code = jerry_parse ((const jerry_char_t *) source_p, strlen (source_p), NULL);
TEST_ASSERT (!jerry_value_is_error (code));
TEST_ASSERT (!jerry_value_is_exception (code));
result = jerry_run (code);
jerry_value_t compare_value = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, result, code);
jerry_value_t compare_value = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, result, code);
TEST_ASSERT (jerry_value_is_true (compare_value));
jerry_release_value (compare_value);
jerry_release_value (result);
jerry_release_value (code);
jerry_value_free (compare_value);
jerry_value_free (result);
jerry_value_free (code);
jerry_cleanup ();
} /* test_get_backtrace_api_call */
@@ -485,27 +485,27 @@ test_exception_backtrace (void)
jerry_value_t error = run ("bad.js", source);
TEST_ASSERT (jerry_value_is_error (error));
TEST_ASSERT (jerry_value_is_exception (error));
error = jerry_get_value_from_error (error, true);
error = jerry_exception_value (error, true);
TEST_ASSERT (jerry_value_is_object (error));
jerry_value_t name = jerry_create_string ((const jerry_char_t *) "stack");
jerry_value_t backtrace = jerry_get_property (error, name);
jerry_value_t name = jerry_string_sz ("stack");
jerry_value_t backtrace = jerry_object_get (error, name);
jerry_release_value (name);
jerry_release_value (error);
jerry_value_free (name);
jerry_value_free (error);
TEST_ASSERT (!jerry_value_is_error (backtrace) && jerry_value_is_array (backtrace));
TEST_ASSERT (!jerry_value_is_exception (backtrace) && jerry_value_is_array (backtrace));
TEST_ASSERT (jerry_get_array_length (backtrace) == 3);
TEST_ASSERT (jerry_array_length (backtrace) == 3);
compare (backtrace, 0, "bad.js:2:3");
compare (backtrace, 1, "bad.js:6:3");
compare (backtrace, 2, "bad.js:9:1");
jerry_release_value (backtrace);
jerry_value_free (backtrace);
jerry_cleanup ();
} /* test_exception_backtrace */
@@ -531,25 +531,25 @@ test_large_line_count (void)
jerry_value_t error = run ("bad.js", source);
TEST_ASSERT (jerry_value_is_error (error));
TEST_ASSERT (jerry_value_is_exception (error));
error = jerry_get_value_from_error (error, true);
error = jerry_exception_value (error, true);
TEST_ASSERT (jerry_value_is_object (error));
jerry_value_t name = jerry_create_string ((const jerry_char_t *) "stack");
jerry_value_t backtrace = jerry_get_property (error, name);
jerry_value_t name = jerry_string_sz ("stack");
jerry_value_t backtrace = jerry_object_get (error, name);
jerry_release_value (name);
jerry_release_value (error);
jerry_value_free (name);
jerry_value_free (error);
TEST_ASSERT (!jerry_value_is_error (backtrace) && jerry_value_is_array (backtrace));
TEST_ASSERT (!jerry_value_is_exception (backtrace) && jerry_value_is_array (backtrace));
TEST_ASSERT (jerry_get_array_length (backtrace) == 1);
TEST_ASSERT (jerry_array_length (backtrace) == 1);
compare (backtrace, 0, "bad.js:385:1");
jerry_release_value (backtrace);
jerry_value_free (backtrace);
jerry_cleanup ();
} /* test_large_line_count */
@@ -559,7 +559,7 @@ main (void)
{
TEST_INIT ();
TEST_ASSERT (jerry_is_feature_enabled (JERRY_FEATURE_LINE_INFO));
TEST_ASSERT (jerry_feature_enabled (JERRY_FEATURE_LINE_INFO));
test_get_backtrace_api_call ();
test_exception_backtrace ();
tests/unit-core/test-bigint.c
+30 -30
View File
@@ -20,7 +20,7 @@
int
main (void)
{
if (!jerry_is_feature_enabled (JERRY_FEATURE_BIGINT))
if (!jerry_feature_enabled (JERRY_FEATURE_BIGINT))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Bigint support is disabled!\n");
return 0;
@@ -28,34 +28,34 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t string = jerry_create_string ((const jerry_char_t *) "0xfffffff1fffffff2fffffff3");
TEST_ASSERT (!jerry_value_is_error (string));
jerry_value_t string = jerry_string_sz ("0xfffffff1fffffff2fffffff3");
TEST_ASSERT (!jerry_value_is_exception (string));
jerry_value_t bigint = jerry_value_to_bigint (string);
jerry_release_value (string);
jerry_value_free (string);
TEST_ASSERT (!jerry_value_is_error (bigint));
TEST_ASSERT (!jerry_value_is_exception (bigint));
TEST_ASSERT (jerry_value_is_bigint (bigint));
string = jerry_value_to_string (bigint);
TEST_ASSERT (!jerry_value_is_error (string));
TEST_ASSERT (!jerry_value_is_exception (string));
static jerry_char_t str_buffer[64];
const char *expected_string_p = "79228162256009920505775652851";
jerry_size_t size = jerry_string_to_char_buffer (string, str_buffer, sizeof (str_buffer));
jerry_size_t size = jerry_string_to_buffer (string, JERRY_ENCODING_CESU8, str_buffer, sizeof (str_buffer));
TEST_ASSERT (size == strlen (expected_string_p));
TEST_ASSERT (memcmp (str_buffer, expected_string_p, size) == 0);
jerry_release_value (string);
jerry_value_free (string);
TEST_ASSERT (jerry_get_bigint_size_in_digits (bigint) == 2);
TEST_ASSERT (jerry_bigint_digit_count (bigint) == 2);
uint64_t digits_buffer[4];
bool sign;
memset (digits_buffer, 0xff, sizeof (digits_buffer));
sign = true;
jerry_get_bigint_digits (bigint, digits_buffer, 0, &sign);
jerry_bigint_to_digits (bigint, digits_buffer, 0, &sign);
TEST_ASSERT (sign == false);
TEST_ASSERT (digits_buffer[0] == ~((uint64_t) 0));
TEST_ASSERT (digits_buffer[1] == ~((uint64_t) 0));
@@ -64,7 +64,7 @@ main (void)
memset (digits_buffer, 0xff, sizeof (digits_buffer));
sign = true;
jerry_get_bigint_digits (bigint, digits_buffer, 1, &sign);
jerry_bigint_to_digits (bigint, digits_buffer, 1, &sign);
TEST_ASSERT (sign == false);
TEST_ASSERT (digits_buffer[0] == 0xfffffff2fffffff3ull);
TEST_ASSERT (digits_buffer[1] == ~((uint64_t) 0));
@@ -73,7 +73,7 @@ main (void)
memset (digits_buffer, 0xff, sizeof (digits_buffer));
sign = true;
jerry_get_bigint_digits (bigint, digits_buffer, 2, &sign);
jerry_bigint_to_digits (bigint, digits_buffer, 2, &sign);
TEST_ASSERT (sign == false);
TEST_ASSERT (digits_buffer[0] == 0xfffffff2fffffff3ull);
TEST_ASSERT (digits_buffer[1] == 0xfffffff1ull);
@@ -82,7 +82,7 @@ main (void)
memset (digits_buffer, 0xff, sizeof (digits_buffer));
sign = true;
jerry_get_bigint_digits (bigint, digits_buffer, 3, &sign);
jerry_bigint_to_digits (bigint, digits_buffer, 3, &sign);
TEST_ASSERT (sign == false);
TEST_ASSERT (digits_buffer[0] == 0xfffffff2fffffff3ull);
TEST_ASSERT (digits_buffer[1] == 0xfffffff1ull);
@@ -90,44 +90,44 @@ main (void)
TEST_ASSERT (digits_buffer[3] == ~((uint64_t) 0));
memset (digits_buffer, 0xff, sizeof (digits_buffer));
jerry_get_bigint_digits (bigint, digits_buffer, 4, NULL);
jerry_bigint_to_digits (bigint, digits_buffer, 4, NULL);
TEST_ASSERT (digits_buffer[0] == 0xfffffff2fffffff3ull);
TEST_ASSERT (digits_buffer[1] == 0xfffffff1ull);
TEST_ASSERT (digits_buffer[2] == 0);
TEST_ASSERT (digits_buffer[3] == 0);
jerry_release_value (bigint);
jerry_value_free (bigint);
digits_buffer[0] = 0;
digits_buffer[1] = 0;
digits_buffer[2] = 0;
/* Sign of zero value is always positive, even if we set negative. */
bigint = jerry_create_bigint (digits_buffer, 3, true);
bigint = jerry_bigint (digits_buffer, 3, true);
TEST_ASSERT (jerry_value_is_bigint (bigint));
TEST_ASSERT (jerry_get_bigint_size_in_digits (bigint) == 0);
TEST_ASSERT (jerry_bigint_digit_count (bigint) == 0);
memset (digits_buffer, 0xff, sizeof (digits_buffer));
sign = true;
jerry_get_bigint_digits (bigint, digits_buffer, 2, &sign);
jerry_bigint_to_digits (bigint, digits_buffer, 2, &sign);
TEST_ASSERT (sign == false);
TEST_ASSERT (digits_buffer[0] == 0);
TEST_ASSERT (digits_buffer[1] == 0);
TEST_ASSERT (digits_buffer[2] == ~((uint64_t) 0));
TEST_ASSERT (digits_buffer[3] == ~((uint64_t) 0));
jerry_release_value (bigint);
jerry_value_free (bigint);
digits_buffer[0] = 1;
digits_buffer[1] = 0;
digits_buffer[2] = 0;
digits_buffer[3] = 0;
bigint = jerry_create_bigint (digits_buffer, 4, true);
bigint = jerry_bigint (digits_buffer, 4, true);
TEST_ASSERT (jerry_value_is_bigint (bigint));
TEST_ASSERT (jerry_get_bigint_size_in_digits (bigint) == 1);
TEST_ASSERT (jerry_bigint_digit_count (bigint) == 1);
memset (digits_buffer, 0xff, sizeof (digits_buffer));
sign = false;
jerry_get_bigint_digits (bigint, digits_buffer, 1, &sign);
jerry_bigint_to_digits (bigint, digits_buffer, 1, &sign);
TEST_ASSERT (sign == true);
TEST_ASSERT (digits_buffer[0] == 1);
TEST_ASSERT (digits_buffer[1] == ~((uint64_t) 0));
@@ -136,26 +136,26 @@ main (void)
memset (digits_buffer, 0xff, sizeof (digits_buffer));
sign = false;
jerry_get_bigint_digits (bigint, digits_buffer, 2, &sign);
jerry_bigint_to_digits (bigint, digits_buffer, 2, &sign);
TEST_ASSERT (sign == true);
TEST_ASSERT (digits_buffer[0] == 1);
TEST_ASSERT (digits_buffer[1] == 0);
TEST_ASSERT (digits_buffer[2] == ~((uint64_t) 0));
TEST_ASSERT (digits_buffer[3] == ~((uint64_t) 0));
jerry_release_value (bigint);
jerry_value_free (bigint);
digits_buffer[0] = 0;
digits_buffer[1] = 1;
digits_buffer[2] = 0;
digits_buffer[3] = 0;
bigint = jerry_create_bigint (digits_buffer, 4, true);
bigint = jerry_bigint (digits_buffer, 4, true);
TEST_ASSERT (jerry_value_is_bigint (bigint));
TEST_ASSERT (jerry_get_bigint_size_in_digits (bigint) == 2);
TEST_ASSERT (jerry_bigint_digit_count (bigint) == 2);
memset (digits_buffer, 0xff, sizeof (digits_buffer));
sign = false;
jerry_get_bigint_digits (bigint, digits_buffer, 1, &sign);
jerry_bigint_to_digits (bigint, digits_buffer, 1, &sign);
TEST_ASSERT (sign == true);
TEST_ASSERT (digits_buffer[0] == 0);
TEST_ASSERT (digits_buffer[1] == ~((uint64_t) 0));
@@ -164,7 +164,7 @@ main (void)
memset (digits_buffer, 0xff, sizeof (digits_buffer));
sign = false;
jerry_get_bigint_digits (bigint, digits_buffer, 2, &sign);
jerry_bigint_to_digits (bigint, digits_buffer, 2, &sign);
TEST_ASSERT (sign == true);
TEST_ASSERT (digits_buffer[0] == 0);
TEST_ASSERT (digits_buffer[1] == 1);
@@ -173,14 +173,14 @@ main (void)
memset (digits_buffer, 0xff, sizeof (digits_buffer));
sign = false;
jerry_get_bigint_digits (bigint, digits_buffer, 3, &sign);
jerry_bigint_to_digits (bigint, digits_buffer, 3, &sign);
TEST_ASSERT (sign == true);
TEST_ASSERT (digits_buffer[0] == 0);
TEST_ASSERT (digits_buffer[1] == 1);
TEST_ASSERT (digits_buffer[2] == 0);
TEST_ASSERT (digits_buffer[3] == ~((uint64_t) 0));
jerry_release_value (bigint);
jerry_value_free (bigint);
jerry_cleanup ();
return 0;
tests/unit-core/test-container-operation.c
+97 -97
View File
@@ -22,8 +22,8 @@ main (void)
{
jerry_init (JERRY_INIT_EMPTY);
if (!jerry_is_feature_enabled (JERRY_FEATURE_MAP) || !jerry_is_feature_enabled (JERRY_FEATURE_SET)
|| !jerry_is_feature_enabled (JERRY_FEATURE_WEAKMAP) || !jerry_is_feature_enabled (JERRY_FEATURE_WEAKSET))
if (!jerry_feature_enabled (JERRY_FEATURE_MAP) || !jerry_feature_enabled (JERRY_FEATURE_SET)
|| !jerry_feature_enabled (JERRY_FEATURE_WEAKMAP) || !jerry_feature_enabled (JERRY_FEATURE_WEAKSET))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Containers are disabled!\n");
jerry_cleanup ();
@@ -31,151 +31,151 @@ main (void)
}
// Map container tests
jerry_value_t map = jerry_create_container (JERRY_CONTAINER_TYPE_MAP, NULL, 0);
TEST_ASSERT (jerry_get_container_type (map) == JERRY_CONTAINER_TYPE_MAP);
jerry_value_t map = jerry_container (JERRY_CONTAINER_TYPE_MAP, NULL, 0);
TEST_ASSERT (jerry_container_type (map) == JERRY_CONTAINER_TYPE_MAP);
jerry_value_t key_str = jerry_create_string ((jerry_char_t *) "number");
jerry_value_t number = jerry_create_number (10);
jerry_value_t key_str = jerry_string_sz ("number");
jerry_value_t number = jerry_number (10);
jerry_value_t args[2] = { key_str, number };
jerry_value_t result = jerry_container_operation (JERRY_CONTAINER_OP_SET, map, args, 2);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
jerry_value_t result = jerry_container_op (JERRY_CONTAINER_OP_SET, map, args, 2);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_GET, map, &key_str, 1);
TEST_ASSERT (jerry_get_number_value (result) == 10);
jerry_release_value (result);
result = jerry_container_op (JERRY_CONTAINER_OP_GET, map, &key_str, 1);
TEST_ASSERT (jerry_value_as_number (result) == 10);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_HAS, map, &key_str, 1);
result = jerry_container_op (JERRY_CONTAINER_OP_HAS, map, &key_str, 1);
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_SIZE, map, NULL, 0);
TEST_ASSERT (jerry_get_number_value (result) == 1);
jerry_release_value (result);
result = jerry_container_op (JERRY_CONTAINER_OP_SIZE, map, NULL, 0);
TEST_ASSERT (jerry_value_as_number (result) == 1);
jerry_value_free (result);
key_str = jerry_create_string ((jerry_char_t *) "number2");
number = jerry_create_number (11);
key_str = jerry_string_sz ("number2");
number = jerry_number (11);
jerry_value_t args2[2] = { key_str, number };
result = jerry_container_operation (JERRY_CONTAINER_OP_SET, map, args2, 2);
jerry_release_value (result);
result = jerry_container_op (JERRY_CONTAINER_OP_SET, map, args2, 2);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_SIZE, map, NULL, 0);
TEST_ASSERT (jerry_get_number_value (result) == 2);
jerry_release_value (result);
result = jerry_container_op (JERRY_CONTAINER_OP_SIZE, map, NULL, 0);
TEST_ASSERT (jerry_value_as_number (result) == 2);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_DELETE, map, &key_str, 1);
result = jerry_container_op (JERRY_CONTAINER_OP_DELETE, map, &key_str, 1);
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_SIZE, map, NULL, 0);
TEST_ASSERT (jerry_get_number_value (result) == 1);
jerry_release_value (result);
result = jerry_container_op (JERRY_CONTAINER_OP_SIZE, map, NULL, 0);
TEST_ASSERT (jerry_value_as_number (result) == 1);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_CLEAR, map, NULL, 0);
result = jerry_container_op (JERRY_CONTAINER_OP_CLEAR, map, NULL, 0);
TEST_ASSERT (jerry_value_is_undefined (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_SIZE, map, NULL, 0);
TEST_ASSERT (jerry_get_number_value (result) == 0);
jerry_release_value (result);
result = jerry_container_op (JERRY_CONTAINER_OP_SIZE, map, NULL, 0);
TEST_ASSERT (jerry_value_as_number (result) == 0);
jerry_value_free (result);
// Set container tests
number = jerry_create_number (10);
jerry_value_t set = jerry_create_container (JERRY_CONTAINER_TYPE_SET, NULL, 0);
TEST_ASSERT (jerry_get_container_type (set) == JERRY_CONTAINER_TYPE_SET);
result = jerry_container_operation (JERRY_CONTAINER_OP_ADD, set, &number, 1);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
number = jerry_number (10);
jerry_value_t set = jerry_container (JERRY_CONTAINER_TYPE_SET, NULL, 0);
TEST_ASSERT (jerry_container_type (set) == JERRY_CONTAINER_TYPE_SET);
result = jerry_container_op (JERRY_CONTAINER_OP_ADD, set, &number, 1);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_HAS, set, &number, 1);
result = jerry_container_op (JERRY_CONTAINER_OP_HAS, set, &number, 1);
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_SIZE, set, NULL, 0);
TEST_ASSERT (jerry_get_number_value (result) == 1);
jerry_release_value (result);
result = jerry_container_op (JERRY_CONTAINER_OP_SIZE, set, NULL, 0);
TEST_ASSERT (jerry_value_as_number (result) == 1);
jerry_value_free (result);
number = jerry_create_number (11);
result = jerry_container_operation (JERRY_CONTAINER_OP_ADD, set, &number, 1);
jerry_release_value (result);
number = jerry_number (11);
result = jerry_container_op (JERRY_CONTAINER_OP_ADD, set, &number, 1);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_SIZE, set, NULL, 0);
TEST_ASSERT (jerry_get_number_value (result) == 2);
jerry_release_value (result);
result = jerry_container_op (JERRY_CONTAINER_OP_SIZE, set, NULL, 0);
TEST_ASSERT (jerry_value_as_number (result) == 2);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_DELETE, set, &number, 1);
result = jerry_container_op (JERRY_CONTAINER_OP_DELETE, set, &number, 1);
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_SIZE, set, NULL, 0);
TEST_ASSERT (jerry_get_number_value (result) == 1);
jerry_release_value (result);
result = jerry_container_op (JERRY_CONTAINER_OP_SIZE, set, NULL, 0);
TEST_ASSERT (jerry_value_as_number (result) == 1);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_CLEAR, set, NULL, 0);
result = jerry_container_op (JERRY_CONTAINER_OP_CLEAR, set, NULL, 0);
TEST_ASSERT (jerry_value_is_undefined (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_SIZE, set, NULL, 0);
TEST_ASSERT (jerry_get_number_value (result) == 0);
jerry_release_value (result);
jerry_release_value (set);
result = jerry_container_op (JERRY_CONTAINER_OP_SIZE, set, NULL, 0);
TEST_ASSERT (jerry_value_as_number (result) == 0);
jerry_value_free (result);
jerry_value_free (set);
// WeakMap contanier tests
number = jerry_create_number (10);
jerry_value_t weak_map = jerry_create_container (JERRY_CONTAINER_TYPE_WEAKMAP, NULL, 0);
TEST_ASSERT (jerry_get_container_type (weak_map) == JERRY_CONTAINER_TYPE_WEAKMAP);
number = jerry_number (10);
jerry_value_t weak_map = jerry_container (JERRY_CONTAINER_TYPE_WEAKMAP, NULL, 0);
TEST_ASSERT (jerry_container_type (weak_map) == JERRY_CONTAINER_TYPE_WEAKMAP);
jerry_value_t obj = jerry_create_object ();
number = jerry_create_number (10);
jerry_value_t obj = jerry_object ();
number = jerry_number (10);
jerry_value_t args4[2] = { obj, number };
result = jerry_container_operation (JERRY_CONTAINER_OP_SET, weak_map, args4, 2);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
result = jerry_container_op (JERRY_CONTAINER_OP_SET, weak_map, args4, 2);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_HAS, weak_map, &obj, 1);
result = jerry_container_op (JERRY_CONTAINER_OP_HAS, weak_map, &obj, 1);
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_DELETE, weak_map, &obj, 1);
result = jerry_container_op (JERRY_CONTAINER_OP_DELETE, weak_map, &obj, 1);
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_release_value (weak_map);
jerry_value_free (result);
jerry_value_free (weak_map);
// WeakSet contanier tests,
jerry_value_t weak_set = jerry_create_container (JERRY_CONTAINER_TYPE_WEAKSET, NULL, 0);
TEST_ASSERT (jerry_get_container_type (weak_set) == JERRY_CONTAINER_TYPE_WEAKSET);
jerry_value_t weak_set = jerry_container (JERRY_CONTAINER_TYPE_WEAKSET, NULL, 0);
TEST_ASSERT (jerry_container_type (weak_set) == JERRY_CONTAINER_TYPE_WEAKSET);
result = jerry_container_operation (JERRY_CONTAINER_OP_ADD, weak_set, &obj, 1);
jerry_release_value (result);
result = jerry_container_op (JERRY_CONTAINER_OP_ADD, weak_set, &obj, 1);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_HAS, weak_set, &obj, 1);
result = jerry_container_op (JERRY_CONTAINER_OP_HAS, weak_set, &obj, 1);
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_container_operation (JERRY_CONTAINER_OP_DELETE, weak_set, &obj, 1);
result = jerry_container_op (JERRY_CONTAINER_OP_DELETE, weak_set, &obj, 1);
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_release_value (weak_set);
jerry_value_free (result);
jerry_value_free (weak_set);
// container is not a object
jerry_value_t empty_val = jerry_create_undefined ();
result = jerry_container_operation (JERRY_CONTAINER_OP_SET, empty_val, args, 2);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
jerry_value_t empty_val = jerry_undefined ();
result = jerry_container_op (JERRY_CONTAINER_OP_SET, empty_val, args, 2);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
// arguments is a error
const char *const error_message_p = "Random error.";
jerry_value_t error_val = jerry_create_error (JERRY_ERROR_RANGE, (const jerry_char_t *) error_message_p);
jerry_value_t error_val = jerry_throw_sz (JERRY_ERROR_RANGE, error_message_p);
jerry_value_t args3[2] = { error_val, error_val };
result = jerry_container_operation (JERRY_CONTAINER_OP_SET, map, args3, 2);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
jerry_release_value (error_val);
jerry_release_value (map);
result = jerry_container_op (JERRY_CONTAINER_OP_SET, map, args3, 2);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
jerry_value_free (error_val);
jerry_value_free (map);
jerry_release_value (key_str);
jerry_release_value (number);
jerry_release_value (obj);
jerry_value_free (key_str);
jerry_value_free (number);
jerry_value_free (obj);
jerry_cleanup ();
return 0;
tests/unit-core/test-container.c
+55 -55
View File
@@ -43,11 +43,11 @@ create_array_from_container_handler (const jerry_call_info_t *call_info_p,
if (args_count < 2)
{
return jerry_create_undefined ();
return jerry_undefined ();
}
bool is_key_value_pairs = false;
jerry_value_t result = jerry_get_array_from_container (args_p[0], &is_key_value_pairs);
jerry_value_t result = jerry_container_to_array (args_p[0], &is_key_value_pairs);
TEST_ASSERT (is_key_value_pairs == jerry_value_is_true (args_p[1]));
return result;
@@ -58,15 +58,15 @@ run_eval (const char *source_p)
{
jerry_value_t result = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), 0);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
} /* run_eval */
static void
run_eval_error (const char *source_p)
{
jerry_value_t result = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), 0);
jerry_release_value (result);
jerry_value_free (result);
} /* run_eval_error */
int
@@ -74,8 +74,8 @@ main (void)
{
jerry_init (JERRY_INIT_EMPTY);
if (!jerry_is_feature_enabled (JERRY_FEATURE_MAP) || !jerry_is_feature_enabled (JERRY_FEATURE_SET)
|| !jerry_is_feature_enabled (JERRY_FEATURE_WEAKMAP) || !jerry_is_feature_enabled (JERRY_FEATURE_WEAKSET))
if (!jerry_feature_enabled (JERRY_FEATURE_MAP) || !jerry_feature_enabled (JERRY_FEATURE_SET)
|| !jerry_feature_enabled (JERRY_FEATURE_WEAKMAP) || !jerry_feature_enabled (JERRY_FEATURE_WEAKSET))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Containers are disabled!\n");
jerry_cleanup ();
@@ -83,63 +83,63 @@ main (void)
}
jerry_value_t instance_check;
jerry_value_t global = jerry_get_global_object ();
jerry_value_t map_str = jerry_create_string ((jerry_char_t *) "Map");
jerry_value_t set_str = jerry_create_string ((jerry_char_t *) "Set");
jerry_value_t weakmap_str = jerry_create_string ((jerry_char_t *) "WeakMap");
jerry_value_t weakset_str = jerry_create_string ((jerry_char_t *) "WeakSet");
jerry_value_t global_map = jerry_get_property (global, map_str);
jerry_value_t global_set = jerry_get_property (global, set_str);
jerry_value_t global_weakmap = jerry_get_property (global, weakmap_str);
jerry_value_t global_weakset = jerry_get_property (global, weakset_str);
jerry_value_t global = jerry_current_realm ();
jerry_value_t map_str = jerry_string_sz ("Map");
jerry_value_t set_str = jerry_string_sz ("Set");
jerry_value_t weakmap_str = jerry_string_sz ("WeakMap");
jerry_value_t weakset_str = jerry_string_sz ("WeakSet");
jerry_value_t global_map = jerry_object_get (global, map_str);
jerry_value_t global_set = jerry_object_get (global, set_str);
jerry_value_t global_weakmap = jerry_object_get (global, weakmap_str);
jerry_value_t global_weakset = jerry_object_get (global, weakset_str);
jerry_value_t function = jerry_create_external_function (create_array_from_container_handler);
jerry_value_t name = jerry_create_string ((const jerry_char_t *) "create_array_from_container");
jerry_value_t res = jerry_set_property (global, name, function);
TEST_ASSERT (!jerry_value_is_error (res));
jerry_value_t function = jerry_function_external (create_array_from_container_handler);
jerry_value_t name = jerry_string_sz ("create_array_from_container");
jerry_value_t res = jerry_object_set (global, name, function);
TEST_ASSERT (!jerry_value_is_exception (res));
jerry_release_value (res);
jerry_release_value (name);
jerry_release_value (function);
jerry_value_free (res);
jerry_value_free (name);
jerry_value_free (function);
jerry_release_value (global);
jerry_value_free (global);
jerry_release_value (map_str);
jerry_release_value (set_str);
jerry_release_value (weakmap_str);
jerry_release_value (weakset_str);
jerry_value_free (map_str);
jerry_value_free (set_str);
jerry_value_free (weakmap_str);
jerry_value_free (weakset_str);
jerry_value_t empty_map = jerry_create_container (JERRY_CONTAINER_TYPE_MAP, NULL, 0);
TEST_ASSERT (jerry_get_container_type (empty_map) == JERRY_CONTAINER_TYPE_MAP);
instance_check = jerry_binary_operation (JERRY_BIN_OP_INSTANCEOF, empty_map, global_map);
jerry_value_t empty_map = jerry_container (JERRY_CONTAINER_TYPE_MAP, NULL, 0);
TEST_ASSERT (jerry_container_type (empty_map) == JERRY_CONTAINER_TYPE_MAP);
instance_check = jerry_binary_op (JERRY_BIN_OP_INSTANCEOF, empty_map, global_map);
TEST_ASSERT (jerry_value_is_true (instance_check));
jerry_release_value (instance_check);
jerry_release_value (global_map);
jerry_release_value (empty_map);
jerry_value_free (instance_check);
jerry_value_free (global_map);
jerry_value_free (empty_map);
jerry_value_t empty_set = jerry_create_container (JERRY_CONTAINER_TYPE_SET, NULL, 0);
TEST_ASSERT (jerry_get_container_type (empty_set) == JERRY_CONTAINER_TYPE_SET);
instance_check = jerry_binary_operation (JERRY_BIN_OP_INSTANCEOF, empty_set, global_set);
jerry_value_t empty_set = jerry_container (JERRY_CONTAINER_TYPE_SET, NULL, 0);
TEST_ASSERT (jerry_container_type (empty_set) == JERRY_CONTAINER_TYPE_SET);
instance_check = jerry_binary_op (JERRY_BIN_OP_INSTANCEOF, empty_set, global_set);
TEST_ASSERT (jerry_value_is_true (instance_check));
jerry_release_value (instance_check);
jerry_release_value (global_set);
jerry_release_value (empty_set);
jerry_value_free (instance_check);
jerry_value_free (global_set);
jerry_value_free (empty_set);
jerry_value_t empty_weakmap = jerry_create_container (JERRY_CONTAINER_TYPE_WEAKMAP, NULL, 0);
TEST_ASSERT (jerry_get_container_type (empty_weakmap) == JERRY_CONTAINER_TYPE_WEAKMAP);
instance_check = jerry_binary_operation (JERRY_BIN_OP_INSTANCEOF, empty_weakmap, global_weakmap);
jerry_value_t empty_weakmap = jerry_container (JERRY_CONTAINER_TYPE_WEAKMAP, NULL, 0);
TEST_ASSERT (jerry_container_type (empty_weakmap) == JERRY_CONTAINER_TYPE_WEAKMAP);
instance_check = jerry_binary_op (JERRY_BIN_OP_INSTANCEOF, empty_weakmap, global_weakmap);
TEST_ASSERT (jerry_value_is_true (instance_check));
jerry_release_value (instance_check);
jerry_release_value (global_weakmap);
jerry_release_value (empty_weakmap);
jerry_value_free (instance_check);
jerry_value_free (global_weakmap);
jerry_value_free (empty_weakmap);
jerry_value_t empty_weakset = jerry_create_container (JERRY_CONTAINER_TYPE_WEAKSET, NULL, 0);
TEST_ASSERT (jerry_get_container_type (empty_weakset) == JERRY_CONTAINER_TYPE_WEAKSET);
instance_check = jerry_binary_operation (JERRY_BIN_OP_INSTANCEOF, empty_weakset, global_weakset);
jerry_value_t empty_weakset = jerry_container (JERRY_CONTAINER_TYPE_WEAKSET, NULL, 0);
TEST_ASSERT (jerry_container_type (empty_weakset) == JERRY_CONTAINER_TYPE_WEAKSET);
instance_check = jerry_binary_op (JERRY_BIN_OP_INSTANCEOF, empty_weakset, global_weakset);
TEST_ASSERT (jerry_value_is_true (instance_check));
jerry_release_value (instance_check);
jerry_release_value (global_weakset);
jerry_release_value (empty_weakset);
jerry_value_free (instance_check);
jerry_value_free (global_weakset);
jerry_value_free (empty_weakset);
const jerry_char_t source[] = TEST_STRING_LITERAL ("(function () {\n"
" var o1 = {}\n"
@@ -153,11 +153,11 @@ main (void)
jerry_value_t result = jerry_eval (source, sizeof (source) - 1, JERRY_PARSE_NO_OPTS);
TEST_ASSERT (jerry_value_is_object (result));
jerry_set_object_native_pointer (result, (void *) &global_counter, &native_info);
jerry_release_value (result);
jerry_object_set_native_ptr (result, &native_info, (void *) &global_counter);
jerry_value_free (result);
global_counter = 0;
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (global_counter == 1);
run_eval ("function assert(v) {\n"
tests/unit-core/test-context-data.c
+4 -4
View File
@@ -135,10 +135,10 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
TEST_ASSERT (!strcmp (*((const char **) jerry_get_context_data (&manager1)), "item1"));
TEST_ASSERT (!strcmp (*((const char **) jerry_get_context_data (&manager2)), "item2"));
TEST_ASSERT (jerry_get_context_data (&manager3) == NULL);
TEST_ASSERT (jerry_get_context_data (&manager4) == NULL);
TEST_ASSERT (!strcmp (*((const char **) jerry_context_data (&manager1)), "item1"));
TEST_ASSERT (!strcmp (*((const char **) jerry_context_data (&manager2)), "item2"));
TEST_ASSERT (jerry_context_data (&manager3) == NULL);
TEST_ASSERT (jerry_context_data (&manager4) == NULL);
TEST_ASSERT (test_context_data1_new_called);
TEST_ASSERT (test_context_data2_new_called);
tests/unit-core/test-dataview.c
+38 -38
View File
@@ -22,82 +22,82 @@
int
main (void)
{
if (!jerry_is_feature_enabled (JERRY_FEATURE_DATAVIEW))
if (!jerry_feature_enabled (JERRY_FEATURE_DATAVIEW))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "DataView support is disabled!\n");
return 0;
}
/* DataView builtin requires the TypedArray builtin */
TEST_ASSERT (jerry_is_feature_enabled (JERRY_FEATURE_TYPEDARRAY));
TEST_ASSERT (jerry_feature_enabled (JERRY_FEATURE_TYPEDARRAY));
jerry_init (JERRY_INIT_EMPTY);
/* Test accessors */
jerry_value_t arraybuffer = jerry_create_arraybuffer (16);
jerry_value_t view1 = jerry_create_dataview (arraybuffer, 0, 16);
TEST_ASSERT (!jerry_value_is_error (view1));
jerry_value_t arraybuffer = jerry_arraybuffer (16);
jerry_value_t view1 = jerry_dataview (arraybuffer, 0, 16);
TEST_ASSERT (!jerry_value_is_exception (view1));
TEST_ASSERT (jerry_value_is_dataview (view1));
jerry_length_t byteOffset = 0;
jerry_length_t byteLength = 0;
;
jerry_value_t internal_buffer = jerry_get_dataview_buffer (view1, &byteOffset, &byteLength);
TEST_ASSERT (jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, internal_buffer, arraybuffer));
jerry_value_t internal_buffer = jerry_dataview_buffer (view1, &byteOffset, &byteLength);
TEST_ASSERT (jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, internal_buffer, arraybuffer));
TEST_ASSERT (byteOffset == 0);
TEST_ASSERT (byteLength == 16);
jerry_release_value (internal_buffer);
jerry_value_free (internal_buffer);
jerry_value_t view2 = jerry_create_dataview (arraybuffer, 12, 4);
TEST_ASSERT (!jerry_value_is_error (view1));
jerry_value_t view2 = jerry_dataview (arraybuffer, 12, 4);
TEST_ASSERT (!jerry_value_is_exception (view1));
TEST_ASSERT (jerry_value_is_dataview (view2));
internal_buffer = jerry_get_dataview_buffer (view2, &byteOffset, &byteLength);
TEST_ASSERT (jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, internal_buffer, arraybuffer));
internal_buffer = jerry_dataview_buffer (view2, &byteOffset, &byteLength);
TEST_ASSERT (jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, internal_buffer, arraybuffer));
TEST_ASSERT (byteOffset == 12);
TEST_ASSERT (byteLength == 4);
jerry_release_value (internal_buffer);
jerry_value_free (internal_buffer);
/* Test invalid construction */
jerry_value_t empty_object = jerry_create_object ();
jerry_value_t view3 = jerry_create_dataview (empty_object, 20, 10);
TEST_ASSERT (jerry_value_is_error (view3));
jerry_value_t error_obj = jerry_get_value_from_error (view3, true);
TEST_ASSERT (jerry_get_error_type (error_obj) == JERRY_ERROR_TYPE);
jerry_release_value (error_obj);
jerry_release_value (empty_object);
jerry_value_t empty_object = jerry_object ();
jerry_value_t view3 = jerry_dataview (empty_object, 20, 10);
TEST_ASSERT (jerry_value_is_exception (view3));
jerry_value_t error_obj = jerry_exception_value (view3, true);
TEST_ASSERT (jerry_error_type (error_obj) == JERRY_ERROR_TYPE);
jerry_value_free (error_obj);
jerry_value_free (empty_object);
jerry_value_t view4 = jerry_create_dataview (arraybuffer, 20, 10);
TEST_ASSERT (jerry_value_is_error (view3));
error_obj = jerry_get_value_from_error (view4, true);
TEST_ASSERT (jerry_get_error_type (error_obj) == JERRY_ERROR_RANGE);
jerry_release_value (error_obj);
jerry_value_t view4 = jerry_dataview (arraybuffer, 20, 10);
TEST_ASSERT (jerry_value_is_exception (view3));
error_obj = jerry_exception_value (view4, true);
TEST_ASSERT (jerry_error_type (error_obj) == JERRY_ERROR_RANGE);
jerry_value_free (error_obj);
/* Test getting/setting values */
jerry_value_t global_obj = jerry_get_global_object ();
jerry_value_t view1_str = jerry_create_string ((const jerry_char_t *) "view1");
jerry_value_t view2_str = jerry_create_string ((const jerry_char_t *) "view2");
TEST_ASSERT (jerry_set_property (global_obj, view1_str, view1));
TEST_ASSERT (jerry_set_property (global_obj, view2_str, view2));
jerry_value_t global_obj = jerry_current_realm ();
jerry_value_t view1_str = jerry_string_sz ("view1");
jerry_value_t view2_str = jerry_string_sz ("view2");
TEST_ASSERT (jerry_object_set (global_obj, view1_str, view1));
TEST_ASSERT (jerry_object_set (global_obj, view2_str, view2));
jerry_release_value (view1_str);
jerry_release_value (view2_str);
jerry_release_value (global_obj);
jerry_value_free (view1_str);
jerry_value_free (view2_str);
jerry_value_free (global_obj);
const jerry_char_t set_src[] = "view1.setInt16 (12, 255)";
TEST_ASSERT (jerry_value_is_undefined (jerry_eval (set_src, sizeof (set_src) - 1, JERRY_PARSE_NO_OPTS)));
const jerry_char_t get_src[] = "view2.getInt16 (0)";
TEST_ASSERT (jerry_get_number_value (jerry_eval (get_src, sizeof (get_src) - 1, JERRY_PARSE_NO_OPTS)) == 255);
TEST_ASSERT (jerry_value_as_number (jerry_eval (get_src, sizeof (get_src) - 1, JERRY_PARSE_NO_OPTS)) == 255);
const jerry_char_t get_src_little_endian[] = "view2.getInt16 (0, true)";
TEST_ASSERT (
jerry_get_number_value (jerry_eval (get_src_little_endian, sizeof (get_src_little_endian) - 1, JERRY_PARSE_NO_OPTS))
jerry_value_as_number (jerry_eval (get_src_little_endian, sizeof (get_src_little_endian) - 1, JERRY_PARSE_NO_OPTS))
== -256);
/* Cleanup */
jerry_release_value (view2);
jerry_release_value (view1);
jerry_release_value (arraybuffer);
jerry_value_free (view2);
jerry_value_free (view1);
jerry_value_free (arraybuffer);
jerry_cleanup ();
tests/unit-core/test-error-callback.c
+11 -12
View File
@@ -30,21 +30,21 @@ error_object_created_callback (const jerry_value_t error_object_t, /**< new erro
error_object_created_callback_is_running = true;
error_object_created_callback_count++;
jerry_value_t name = jerry_create_string ((const jerry_char_t *) "message");
jerry_value_t message = jerry_create_string ((const jerry_char_t *) "Replaced message!");
jerry_value_t name = jerry_string_sz ("message");
jerry_value_t message = jerry_string_sz ("Replaced message!");
jerry_value_t result = jerry_set_property (error_object_t, name, message);
jerry_value_t result = jerry_object_set (error_object_t, name, message);
TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
/* This SyntaxError must not trigger a recusrsive call of the this callback. */
const char *source_p = "Syntax Error in JS!";
result = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), 0);
TEST_ASSERT (jerry_value_is_error (result));
TEST_ASSERT (jerry_value_is_exception (result));
jerry_release_value (result);
jerry_release_value (message);
jerry_release_value (name);
jerry_value_free (result);
jerry_value_free (message);
jerry_value_free (name);
error_object_created_callback_is_running = false;
} /* error_object_created_callback */
@@ -57,7 +57,7 @@ run_test (const char *source_p)
{
jerry_value_t result = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), 0);
TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
}
} /* run_test */
@@ -71,8 +71,7 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_set_error_object_created_callback (error_object_created_callback,
(void *) &error_object_created_callback_count);
jerry_error_on_created (error_object_created_callback, (void *) &error_object_created_callback_count);
run_test ("var result = false\n"
"try {\n"
@@ -85,7 +84,7 @@ main (void)
run_test ("var error = new Error()\n"
"error.message === 'Replaced message!'\n");
jerry_release_value (jerry_create_error (JERRY_ERROR_COMMON, (const jerry_char_t *) "Message"));
jerry_value_free (jerry_error_sz (JERRY_ERROR_COMMON, "Message"));
TEST_ASSERT (error_object_created_callback_count == 11);
tests/unit-core/test-external-string.c
+66 -66
View File
@@ -67,140 +67,140 @@ main (void)
bool is_external;
/* Test external callback calls. */
jerry_string_set_external_free_callback (external_string_free_callback_1);
jerry_value_t external_string = jerry_create_external_string ((jerry_char_t *) external_1, NULL);
jerry_string_external_on_free (external_string_free_callback_1);
jerry_value_t external_string = jerry_string_external_sz (external_1, NULL);
TEST_ASSERT (free_count == 0);
TEST_ASSERT (jerry_string_get_external_user_pointer (external_string, &is_external) == NULL);
TEST_ASSERT (jerry_string_user_ptr (external_string, &is_external) == NULL);
TEST_ASSERT (is_external);
TEST_ASSERT (jerry_string_get_external_user_pointer (external_string, NULL) == NULL);
jerry_release_value (external_string);
TEST_ASSERT (jerry_string_user_ptr (external_string, NULL) == NULL);
jerry_value_free (external_string);
TEST_ASSERT (free_count == 1);
jerry_string_set_external_free_callback (NULL);
external_string = jerry_create_external_string ((jerry_char_t *) external_1, (void *) &free_count);
jerry_string_external_on_free (NULL);
external_string = jerry_string_external_sz (external_1, (void *) &free_count);
TEST_ASSERT (free_count == 1);
TEST_ASSERT (jerry_string_get_external_user_pointer (external_string, &is_external) == (void *) &free_count);
TEST_ASSERT (jerry_string_user_ptr (external_string, &is_external) == (void *) &free_count);
TEST_ASSERT (is_external);
TEST_ASSERT (jerry_string_get_external_user_pointer (external_string, NULL) == (void *) &free_count);
jerry_release_value (external_string);
TEST_ASSERT (jerry_string_user_ptr (external_string, NULL) == (void *) &free_count);
jerry_value_free (external_string);
TEST_ASSERT (free_count == 1);
jerry_string_set_external_free_callback (external_string_free_callback_2);
external_string = jerry_create_external_string ((jerry_char_t *) external_2, (void *) &free_count);
jerry_string_external_on_free (external_string_free_callback_2);
external_string = jerry_string_external_sz (external_2, (void *) &free_count);
TEST_ASSERT (free_count == 2);
TEST_ASSERT (jerry_string_get_external_user_pointer (external_string, &is_external) == NULL);
TEST_ASSERT (jerry_string_user_ptr (external_string, &is_external) == NULL);
TEST_ASSERT (!is_external);
jerry_release_value (external_string);
jerry_value_free (external_string);
TEST_ASSERT (free_count == 2);
jerry_string_set_external_free_callback (NULL);
external_string = jerry_create_external_string ((jerry_char_t *) external_2, (void *) &free_count);
jerry_string_external_on_free (NULL);
external_string = jerry_string_external_sz (external_2, (void *) &free_count);
TEST_ASSERT (free_count == 2);
TEST_ASSERT (jerry_string_get_external_user_pointer (external_string, &is_external) == NULL);
TEST_ASSERT (jerry_string_user_ptr (external_string, &is_external) == NULL);
TEST_ASSERT (!is_external);
jerry_release_value (external_string);
jerry_value_free (external_string);
TEST_ASSERT (free_count == 2);
jerry_string_set_external_free_callback (external_string_free_callback_3);
external_string = jerry_create_external_string ((jerry_char_t *) external_3, (void *) external_3);
jerry_string_external_on_free (external_string_free_callback_3);
external_string = jerry_string_external_sz (external_3, (void *) external_3);
TEST_ASSERT (free_count == 3);
TEST_ASSERT (jerry_string_get_external_user_pointer (external_string, &is_external) == NULL);
TEST_ASSERT (jerry_string_user_ptr (external_string, &is_external) == NULL);
TEST_ASSERT (!is_external);
jerry_release_value (external_string);
jerry_value_free (external_string);
TEST_ASSERT (free_count == 3);
jerry_string_set_external_free_callback (NULL);
external_string = jerry_create_external_string ((jerry_char_t *) external_3, (void *) external_3);
jerry_string_external_on_free (NULL);
external_string = jerry_string_external_sz (external_3, (void *) external_3);
TEST_ASSERT (free_count == 3);
TEST_ASSERT (jerry_string_get_external_user_pointer (external_string, &is_external) == NULL);
TEST_ASSERT (jerry_string_user_ptr (external_string, &is_external) == NULL);
TEST_ASSERT (!is_external);
jerry_release_value (external_string);
jerry_value_free (external_string);
TEST_ASSERT (free_count == 3);
/* Test string comparison. */
jerry_string_set_external_free_callback (external_string_free_callback_1);
external_string = jerry_create_external_string ((jerry_char_t *) external_1, NULL);
jerry_value_t other_string = jerry_create_string ((jerry_char_t *) external_1);
jerry_string_external_on_free (external_string_free_callback_1);
external_string = jerry_string_external_sz (external_1, NULL);
jerry_value_t other_string = jerry_string_sz (external_1);
jerry_value_t result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, external_string, other_string);
jerry_value_t result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, external_string, other_string);
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, external_string, external_string);
result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, external_string, external_string);
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
TEST_ASSERT (free_count == 3);
jerry_release_value (external_string);
jerry_value_free (external_string);
TEST_ASSERT (free_count == 4);
jerry_release_value (other_string);
jerry_value_free (other_string);
/* Test getting string. */
jerry_string_set_external_free_callback (external_string_free_callback_1);
external_string = jerry_create_external_string ((jerry_char_t *) external_1, NULL);
jerry_string_external_on_free (external_string_free_callback_1);
external_string = jerry_string_external_sz (external_1, NULL);
size_t length = strlen (external_1);
TEST_ASSERT (jerry_value_is_string (external_string));
TEST_ASSERT (jerry_get_string_size (external_string) == length);
TEST_ASSERT (jerry_get_string_length (external_string) == length);
TEST_ASSERT (jerry_string_size (external_string, JERRY_ENCODING_CESU8) == length);
TEST_ASSERT (jerry_string_length (external_string) == length);
jerry_char_t buf[128];
jerry_string_to_char_buffer (external_string, buf, sizeof (buf));
jerry_string_to_buffer (external_string, JERRY_ENCODING_CESU8, buf, sizeof (buf));
TEST_ASSERT (memcmp (buf, external_1, length) == 0);
TEST_ASSERT (free_count == 4);
jerry_release_value (external_string);
jerry_value_free (external_string);
TEST_ASSERT (free_count == 5);
/* Test property access. */
jerry_string_set_external_free_callback (NULL);
external_string = jerry_create_external_string ((jerry_char_t *) external_4, NULL);
other_string = jerry_create_string ((jerry_char_t *) external_4);
jerry_string_external_on_free (NULL);
external_string = jerry_string_external_sz (external_4, NULL);
other_string = jerry_string_sz (external_4);
jerry_value_t obj = jerry_create_object ();
result = jerry_set_property (obj, external_string, other_string);
jerry_value_t obj = jerry_object ();
result = jerry_object_set (obj, external_string, other_string);
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
jerry_value_t get_result = jerry_get_property (obj, other_string);
jerry_value_t get_result = jerry_object_get (obj, other_string);
TEST_ASSERT (jerry_value_is_string (get_result));
result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, get_result, external_string);
jerry_release_value (get_result);
result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, get_result, external_string);
jerry_value_free (get_result);
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_set_property (obj, other_string, external_string);
result = jerry_object_set (obj, other_string, external_string);
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
get_result = jerry_get_property (obj, external_string);
get_result = jerry_object_get (obj, external_string);
TEST_ASSERT (jerry_value_is_string (get_result));
result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, get_result, other_string);
jerry_release_value (get_result);
result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, get_result, other_string);
jerry_value_free (get_result);
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
jerry_release_value (obj);
jerry_release_value (external_string);
jerry_release_value (other_string);
jerry_value_free (obj);
jerry_value_free (external_string);
jerry_value_free (other_string);
external_string = jerry_create_boolean (true);
TEST_ASSERT (jerry_string_get_external_user_pointer (external_string, &is_external) == NULL);
external_string = jerry_boolean (true);
TEST_ASSERT (jerry_string_user_ptr (external_string, &is_external) == NULL);
TEST_ASSERT (!is_external);
jerry_release_value (external_string);
jerry_value_free (external_string);
external_string = jerry_create_object ();
TEST_ASSERT (jerry_string_get_external_user_pointer (external_string, &is_external) == NULL);
external_string = jerry_object ();
TEST_ASSERT (jerry_string_user_ptr (external_string, &is_external) == NULL);
TEST_ASSERT (!is_external);
jerry_release_value (external_string);
jerry_value_free (external_string);
jerry_cleanup ();
return 0;
tests/unit-core/test-from-property-descriptor.c
+29 -29
View File
@@ -25,55 +25,55 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t object = jerry_create_object ();
jerry_value_t prop_name = jerry_create_string_from_utf8 ((jerry_char_t *) "length");
jerry_value_t value = jerry_create_boolean (true);
jerry_value_t object = jerry_object ();
jerry_value_t prop_name = jerry_string_sz ("length");
jerry_value_t value = jerry_boolean (true);
TEST_ASSERT (jerry_set_property (object, prop_name, prop_name));
TEST_ASSERT (jerry_has_property (object, prop_name));
TEST_ASSERT (jerry_has_own_property (object, prop_name));
TEST_ASSERT (jerry_object_set (object, prop_name, prop_name));
TEST_ASSERT (jerry_object_has (object, prop_name));
TEST_ASSERT (jerry_object_has_own (object, prop_name));
jerry_property_descriptor_t prop_desc;
TEST_ASSERT (jerry_get_own_property_descriptor (object, prop_name, &prop_desc));
TEST_ASSERT (jerry_object_get_own_prop (object, prop_name, &prop_desc));
jerry_value_t from_object = jerry_from_property_descriptor (&prop_desc);
jerry_value_t from_object = jerry_property_descriptor_to_object (&prop_desc);
prop_name = jerry_create_string_from_utf8 ((jerry_char_t *) "value");
value = jerry_get_property (from_object, prop_name);
prop_name = jerry_string_sz ("value");
value = jerry_object_get (from_object, prop_name);
TEST_ASSERT (value == prop_desc.value);
prop_name = jerry_create_string_from_utf8 ((jerry_char_t *) "writable");
value = jerry_get_property (from_object, prop_name);
prop_name = jerry_string_sz ("writable");
value = jerry_object_get (from_object, prop_name);
TEST_ASSERT (jerry_value_is_true (value) == ((prop_desc.flags & JERRY_PROP_IS_WRITABLE) != 0));
prop_name = jerry_create_string_from_utf8 ((jerry_char_t *) "enumerable");
value = jerry_get_property (from_object, prop_name);
prop_name = jerry_string_sz ("enumerable");
value = jerry_object_get (from_object, prop_name);
TEST_ASSERT (jerry_value_is_true (value) == ((prop_desc.flags & JERRY_PROP_IS_ENUMERABLE) != 0));
prop_name = jerry_create_string_from_utf8 ((jerry_char_t *) "configurable");
value = jerry_get_property (from_object, prop_name);
prop_name = jerry_string_sz ("configurable");
value = jerry_object_get (from_object, prop_name);
TEST_ASSERT (jerry_value_is_true (value) == ((prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE) != 0));
jerry_release_value (object);
jerry_release_value (prop_name);
jerry_release_value (value);
jerry_release_value (from_object);
jerry_value_free (object);
jerry_value_free (prop_name);
jerry_value_free (value);
jerry_value_free (from_object);
jerry_property_descriptor_free (&prop_desc);
prop_desc.flags = JERRY_PROP_IS_CONFIGURABLE;
from_object = jerry_from_property_descriptor (&prop_desc);
TEST_ASSERT (jerry_value_is_error (from_object));
jerry_release_value (from_object);
from_object = jerry_property_descriptor_to_object (&prop_desc);
TEST_ASSERT (jerry_value_is_exception (from_object));
jerry_value_free (from_object);
prop_desc.flags = JERRY_PROP_IS_ENUMERABLE;
from_object = jerry_from_property_descriptor (&prop_desc);
TEST_ASSERT (jerry_value_is_error (from_object));
jerry_release_value (from_object);
from_object = jerry_property_descriptor_to_object (&prop_desc);
TEST_ASSERT (jerry_value_is_exception (from_object));
jerry_value_free (from_object);
prop_desc.flags = JERRY_PROP_IS_WRITABLE;
from_object = jerry_from_property_descriptor (&prop_desc);
TEST_ASSERT (jerry_value_is_error (from_object));
jerry_release_value (from_object);
from_object = jerry_property_descriptor_to_object (&prop_desc);
TEST_ASSERT (jerry_value_is_exception (from_object));
jerry_value_free (from_object);
jerry_cleanup ();
return 0;
tests/unit-core/test-get-own-property.c
+60 -60
View File
@@ -35,9 +35,9 @@ compare_string (jerry_value_t value, /**< value to compare */
size_t size = strlen (string_p);
TEST_ASSERT (size <= sizeof (string_buffer));
TEST_ASSERT (size == jerry_get_string_size (value));
TEST_ASSERT (size == jerry_string_size (value, JERRY_ENCODING_CESU8));
jerry_string_to_char_buffer (value, string_buffer, (jerry_size_t) size);
jerry_string_to_buffer (value, JERRY_ENCODING_CESU8, string_buffer, (jerry_size_t) size);
TEST_ASSERT (memcmp (string_p, string_buffer, size) == 0);
} /* compare_string */
@@ -47,97 +47,97 @@ main (void)
TEST_INIT ();
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t pp_string = jerry_create_string ((const jerry_char_t *) "pp");
jerry_value_t qq_string = jerry_create_string ((const jerry_char_t *) "qq");
jerry_value_t rr_string = jerry_create_string ((const jerry_char_t *) "rr");
jerry_value_t pp_string = jerry_string_sz ("pp");
jerry_value_t qq_string = jerry_string_sz ("qq");
jerry_value_t rr_string = jerry_string_sz ("rr");
jerry_value_t object = create_object ("'use strict';\n"
"({ pp:'A', get qq() { return 'B' } })");
jerry_value_t result = jerry_get_own_property (object, pp_string, object, NULL);
jerry_value_t result = jerry_object_find_own (object, pp_string, object, NULL);
compare_string (result, "A");
jerry_release_value (result);
jerry_value_free (result);
bool found = false;
result = jerry_get_own_property (object, pp_string, object, &found);
result = jerry_object_find_own (object, pp_string, object, &found);
compare_string (result, "A");
TEST_ASSERT (found);
jerry_release_value (result);
jerry_value_free (result);
result = jerry_get_own_property (object, qq_string, object, NULL);
result = jerry_object_find_own (object, qq_string, object, NULL);
compare_string (result, "B");
jerry_release_value (result);
jerry_value_free (result);
found = false;
result = jerry_get_own_property (object, qq_string, object, &found);
result = jerry_object_find_own (object, qq_string, object, &found);
compare_string (result, "B");
TEST_ASSERT (found);
jerry_release_value (result);
jerry_value_free (result);
result = jerry_get_own_property (object, rr_string, object, NULL);
result = jerry_object_find_own (object, rr_string, object, NULL);
TEST_ASSERT (jerry_value_is_undefined (result));
jerry_release_value (result);
jerry_value_free (result);
found = true;
result = jerry_get_own_property (object, rr_string, object, &found);
result = jerry_object_find_own (object, rr_string, object, &found);
TEST_ASSERT (jerry_value_is_undefined (result));
TEST_ASSERT (!found);
jerry_release_value (result);
jerry_value_free (result);
jerry_release_value (object);
jerry_value_free (object);
object = create_object ("'use strict';\n"
"Object.create({ pp:'Found!' })\n");
found = true;
/* Does not check prototype. */
result = jerry_get_own_property (object, pp_string, object, &found);
result = jerry_object_find_own (object, pp_string, object, &found);
TEST_ASSERT (jerry_value_is_undefined (result));
TEST_ASSERT (!found);
jerry_release_value (result);
jerry_value_free (result);
jerry_release_value (object);
jerry_value_free (object);
object = create_object ("'use strict';\n"
"var obj = Object.create({ get pp() { return this.qq } })\n"
"Object.defineProperty(obj, 'qq', { value: 'Prop' })\n"
"obj");
jerry_value_t prototype = jerry_get_prototype (object);
jerry_value_t prototype = jerry_object_proto (object);
TEST_ASSERT (jerry_value_is_object (prototype));
found = false;
result = jerry_get_own_property (prototype, pp_string, object, &found);
result = jerry_object_find_own (prototype, pp_string, object, &found);
compare_string (result, "Prop");
TEST_ASSERT (found);
jerry_release_value (result);
jerry_value_free (result);
jerry_release_value (prototype);
jerry_release_value (object);
jerry_value_free (prototype);
jerry_value_free (object);
/* Error cases. */
jerry_value_t invalid_arg = jerry_create_null ();
object = jerry_create_object ();
jerry_value_t invalid_arg = jerry_null ();
object = jerry_object ();
found = true;
result = jerry_get_own_property (invalid_arg, pp_string, object, &found);
TEST_ASSERT (jerry_value_is_error (result));
result = jerry_object_find_own (invalid_arg, pp_string, object, &found);
TEST_ASSERT (jerry_value_is_exception (result));
TEST_ASSERT (!found);
jerry_release_value (result);
jerry_value_free (result);
result = jerry_get_own_property (object, pp_string, invalid_arg, NULL);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
result = jerry_object_find_own (object, pp_string, invalid_arg, NULL);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
found = true;
result = jerry_get_own_property (object, invalid_arg, object, &found);
TEST_ASSERT (jerry_value_is_error (result));
result = jerry_object_find_own (object, invalid_arg, object, &found);
TEST_ASSERT (jerry_value_is_exception (result));
TEST_ASSERT (!found);
jerry_release_value (result);
jerry_value_free (result);
jerry_release_value (object);
jerry_release_value (invalid_arg);
jerry_value_free (object);
jerry_value_free (invalid_arg);
if (jerry_is_feature_enabled (JERRY_FEATURE_PROXY))
if (jerry_feature_enabled (JERRY_FEATURE_PROXY))
{
object = create_object ("'use strict';\n"
"var proxy = new Proxy({}, {\n"
@@ -150,21 +150,21 @@ main (void)
"Object.defineProperty(obj, 'pp', { value: 'Prop' })\n"
"obj");
prototype = jerry_get_prototype (object);
prototype = jerry_object_proto (object);
found = false;
result = jerry_get_own_property (prototype, pp_string, object, &found);
result = jerry_object_find_own (prototype, pp_string, object, &found);
compare_string (result, "Prop");
TEST_ASSERT (found);
jerry_release_value (result);
jerry_value_free (result);
found = false;
result = jerry_get_own_property (prototype, qq_string, object, &found);
result = jerry_object_find_own (prototype, qq_string, object, &found);
TEST_ASSERT (jerry_value_is_undefined (result));
TEST_ASSERT (found);
jerry_release_value (result);
jerry_value_free (result);
jerry_release_value (prototype);
jerry_release_value (object);
jerry_value_free (prototype);
jerry_value_free (object);
object = create_object ("'use strict';\n"
"(new Proxy({}, {\n"
@@ -174,38 +174,38 @@ main (void)
"}))\n");
found = false;
result = jerry_get_own_property (object, qq_string, object, &found);
TEST_ASSERT (jerry_value_is_error (result));
result = jerry_object_find_own (object, qq_string, object, &found);
TEST_ASSERT (jerry_value_is_exception (result));
TEST_ASSERT (found);
jerry_release_value (result);
jerry_value_free (result);
jerry_release_value (object);
jerry_value_free (object);
}
if (jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
if (jerry_feature_enabled (JERRY_FEATURE_SYMBOL))
{
object = create_object ("'use strict'\n"
"var sym = Symbol();\n"
"({ pp:sym, [sym]:'Prop' })");
found = false;
jerry_value_t symbol = jerry_get_own_property (object, pp_string, object, &found);
jerry_value_t symbol = jerry_object_find_own (object, pp_string, object, &found);
TEST_ASSERT (jerry_value_is_symbol (symbol));
TEST_ASSERT (found);
found = false;
result = jerry_get_own_property (object, symbol, object, &found);
result = jerry_object_find_own (object, symbol, object, &found);
compare_string (result, "Prop");
TEST_ASSERT (found);
jerry_release_value (result);
jerry_value_free (result);
jerry_release_value (symbol);
jerry_release_value (object);
jerry_value_free (symbol);
jerry_value_free (object);
}
jerry_release_value (pp_string);
jerry_release_value (qq_string);
jerry_release_value (rr_string);
jerry_value_free (pp_string);
jerry_value_free (qq_string);
jerry_value_free (rr_string);
jerry_cleanup ();
return 0;
tests/unit-core/test-has-property.c
+21 -21
View File
@@ -23,7 +23,7 @@ assert_boolean_and_release (jerry_value_t result, bool expected)
{
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result) == expected);
jerry_release_value (result);
jerry_value_free (result);
} /* assert_boolean_and_release */
int
@@ -33,38 +33,38 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t object = jerry_create_object ();
jerry_value_t prop_name = jerry_create_string_from_utf8 ((jerry_char_t *) "something");
jerry_value_t prop_value = jerry_create_boolean (true);
jerry_value_t proto_object = jerry_create_object ();
jerry_value_t object = jerry_object ();
jerry_value_t prop_name = jerry_string_sz ("something");
jerry_value_t prop_value = jerry_boolean (true);
jerry_value_t proto_object = jerry_object ();
/* Assert that an empty object does not have the property in question */
assert_boolean_and_release (jerry_has_property (object, prop_name), false);
assert_boolean_and_release (jerry_has_own_property (object, prop_name), false);
assert_boolean_and_release (jerry_object_has (object, prop_name), false);
assert_boolean_and_release (jerry_object_has_own (object, prop_name), false);
assert_boolean_and_release (jerry_set_prototype (object, proto_object), true);
assert_boolean_and_release (jerry_object_set_proto (object, proto_object), true);
/* If the object has a prototype, that still means it doesn't have the property */
assert_boolean_and_release (jerry_has_property (object, prop_name), false);
assert_boolean_and_release (jerry_has_own_property (object, prop_name), false);
assert_boolean_and_release (jerry_object_has (object, prop_name), false);
assert_boolean_and_release (jerry_object_has_own (object, prop_name), false);
assert_boolean_and_release (jerry_set_property (proto_object, prop_name, prop_value), true);
assert_boolean_and_release (jerry_object_set (proto_object, prop_name, prop_value), true);
/* After setting the property on the prototype, it must be there, but not on the object */
assert_boolean_and_release (jerry_has_property (object, prop_name), true);
assert_boolean_and_release (jerry_has_own_property (object, prop_name), false);
assert_boolean_and_release (jerry_object_has (object, prop_name), true);
assert_boolean_and_release (jerry_object_has_own (object, prop_name), false);
TEST_ASSERT (jerry_delete_property (proto_object, prop_name));
assert_boolean_and_release (jerry_set_property (object, prop_name, prop_value), true);
TEST_ASSERT (jerry_value_is_true (jerry_object_delete (proto_object, prop_name)));
assert_boolean_and_release (jerry_object_set (object, prop_name, prop_value), true);
/* After relocating the property onto the object, it must be there */
assert_boolean_and_release (jerry_has_property (object, prop_name), true);
assert_boolean_and_release (jerry_has_own_property (object, prop_name), true);
assert_boolean_and_release (jerry_object_has (object, prop_name), true);
assert_boolean_and_release (jerry_object_has_own (object, prop_name), true);
jerry_release_value (object);
jerry_release_value (prop_name);
jerry_release_value (prop_value);
jerry_release_value (proto_object);
jerry_value_free (object);
jerry_value_free (prop_name);
jerry_value_free (prop_value);
jerry_value_free (proto_object);
jerry_cleanup ();
tests/unit-core/test-internal-properties.c
+115 -115
View File
@@ -24,71 +24,71 @@ main (void)
{
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t object = jerry_create_object ();
jerry_value_t object = jerry_object ();
jerry_value_t prop_name_1 = jerry_create_string ((const jerry_char_t *) "foo");
jerry_value_t prop_name_2 = jerry_create_string ((const jerry_char_t *) "non_hidden_prop");
jerry_value_t prop_name_1 = jerry_string_sz ("foo");
jerry_value_t prop_name_2 = jerry_string_sz ("non_hidden_prop");
jerry_value_t prop_name_3;
if (jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
if (jerry_feature_enabled (JERRY_FEATURE_SYMBOL))
{
jerry_value_t prop_name_3_desc = jerry_create_string ((const jerry_char_t *) "bar");
prop_name_3 = jerry_create_symbol (prop_name_3_desc);
jerry_release_value (prop_name_3_desc);
jerry_value_t prop_name_3_desc = jerry_string_sz ("bar");
prop_name_3 = jerry_symbol_with_description (prop_name_3_desc);
jerry_value_free (prop_name_3_desc);
}
else
{
prop_name_3 = jerry_create_string ((const jerry_char_t *) "non_hidden_string_prop");
prop_name_3 = jerry_string_sz ("non_hidden_string_prop");
}
jerry_value_t internal_prop_name_1 = jerry_create_string ((const jerry_char_t *) "hidden_foo");
jerry_value_t internal_prop_name_2 = jerry_create_string ((const jerry_char_t *) "hidden_prop");
jerry_value_t internal_prop_name_1 = jerry_string_sz ("hidden_foo");
jerry_value_t internal_prop_name_2 = jerry_string_sz ("hidden_prop");
jerry_value_t internal_prop_name_3;
if (jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
if (jerry_feature_enabled (JERRY_FEATURE_SYMBOL))
{
jerry_value_t internal_prop_name_3_desc = jerry_create_string ((const jerry_char_t *) "bar");
internal_prop_name_3 = jerry_create_symbol (internal_prop_name_3_desc);
jerry_release_value (internal_prop_name_3_desc);
jerry_value_t internal_prop_name_3_desc = jerry_string_sz ("bar");
internal_prop_name_3 = jerry_symbol_with_description (internal_prop_name_3_desc);
jerry_value_free (internal_prop_name_3_desc);
}
else
{
internal_prop_name_3 = jerry_create_string ((const jerry_char_t *) "hidden_string_prop");
internal_prop_name_3 = jerry_string_sz ("hidden_string_prop");
}
jerry_value_t prop_value_1 = jerry_create_number (5.5);
jerry_value_t prop_value_2 = jerry_create_number (6.5);
jerry_value_t prop_value_3 = jerry_create_number (7.5);
jerry_value_t prop_value_1 = jerry_number (5.5);
jerry_value_t prop_value_2 = jerry_number (6.5);
jerry_value_t prop_value_3 = jerry_number (7.5);
jerry_value_t internal_prop_value_1 = jerry_create_number (8.5);
jerry_value_t internal_prop_value_2 = jerry_create_number (9.5);
jerry_value_t internal_prop_value_3 = jerry_create_number (10.5);
jerry_value_t internal_prop_value_1 = jerry_number (8.5);
jerry_value_t internal_prop_value_2 = jerry_number (9.5);
jerry_value_t internal_prop_value_3 = jerry_number (10.5);
/* Test the normal [[Set]] method */
bool set_result_1 = jerry_set_property (object, prop_name_1, prop_value_1);
bool set_result_2 = jerry_set_property (object, prop_name_2, prop_value_2);
bool set_result_3 = jerry_set_property (object, prop_name_3, prop_value_3);
bool set_result_1 = jerry_object_set (object, prop_name_1, prop_value_1);
bool set_result_2 = jerry_object_set (object, prop_name_2, prop_value_2);
bool set_result_3 = jerry_object_set (object, prop_name_3, prop_value_3);
TEST_ASSERT (set_result_1);
TEST_ASSERT (set_result_2);
TEST_ASSERT (set_result_3);
/* Test the internal [[Set]] method */
bool set_internal_result_1 = jerry_set_internal_property (object, internal_prop_name_1, internal_prop_value_1);
bool set_internal_result_2 = jerry_set_internal_property (object, internal_prop_name_2, internal_prop_value_2);
bool set_internal_result_3 = jerry_set_internal_property (object, internal_prop_name_3, internal_prop_value_3);
bool set_internal_result_1 = jerry_object_set_internal (object, internal_prop_name_1, internal_prop_value_1);
bool set_internal_result_2 = jerry_object_set_internal (object, internal_prop_name_2, internal_prop_value_2);
bool set_internal_result_3 = jerry_object_set_internal (object, internal_prop_name_3, internal_prop_value_3);
TEST_ASSERT (set_internal_result_1);
TEST_ASSERT (set_internal_result_2);
TEST_ASSERT (set_internal_result_3);
/* Test the normal [[Has]] method. */
jerry_value_t has_result_1 = jerry_has_property (object, prop_name_1);
jerry_value_t has_result_2 = jerry_has_property (object, prop_name_2);
jerry_value_t has_result_3 = jerry_has_property (object, prop_name_3);
jerry_value_t has_result_4 = jerry_has_property (object, internal_prop_name_1);
jerry_value_t has_result_5 = jerry_has_property (object, internal_prop_name_2);
jerry_value_t has_result_6 = jerry_has_property (object, internal_prop_name_3);
jerry_value_t has_result_1 = jerry_object_has (object, prop_name_1);
jerry_value_t has_result_2 = jerry_object_has (object, prop_name_2);
jerry_value_t has_result_3 = jerry_object_has (object, prop_name_3);
jerry_value_t has_result_4 = jerry_object_has (object, internal_prop_name_1);
jerry_value_t has_result_5 = jerry_object_has (object, internal_prop_name_2);
jerry_value_t has_result_6 = jerry_object_has (object, internal_prop_name_3);
TEST_ASSERT (jerry_value_is_boolean (has_result_1) && jerry_value_is_true (has_result_1));
TEST_ASSERT (jerry_value_is_boolean (has_result_2) && jerry_value_is_true (has_result_2));
@@ -97,20 +97,20 @@ main (void)
TEST_ASSERT (jerry_value_is_boolean (has_result_5) && !jerry_value_is_true (has_result_5));
TEST_ASSERT (jerry_value_is_boolean (has_result_6) && !jerry_value_is_true (has_result_6));
jerry_release_value (has_result_1);
jerry_release_value (has_result_2);
jerry_release_value (has_result_3);
jerry_release_value (has_result_4);
jerry_release_value (has_result_5);
jerry_release_value (has_result_6);
jerry_value_free (has_result_1);
jerry_value_free (has_result_2);
jerry_value_free (has_result_3);
jerry_value_free (has_result_4);
jerry_value_free (has_result_5);
jerry_value_free (has_result_6);
/* Test the internal [[Has]] method. */
bool has_internal_result_1 = jerry_has_internal_property (object, prop_name_1);
bool has_internal_result_2 = jerry_has_internal_property (object, prop_name_2);
bool has_internal_result_3 = jerry_has_internal_property (object, prop_name_3);
bool has_internal_result_4 = jerry_has_internal_property (object, internal_prop_name_1);
bool has_internal_result_5 = jerry_has_internal_property (object, internal_prop_name_2);
bool has_internal_result_6 = jerry_has_internal_property (object, internal_prop_name_3);
bool has_internal_result_1 = jerry_object_has_internal (object, prop_name_1);
bool has_internal_result_2 = jerry_object_has_internal (object, prop_name_2);
bool has_internal_result_3 = jerry_object_has_internal (object, prop_name_3);
bool has_internal_result_4 = jerry_object_has_internal (object, internal_prop_name_1);
bool has_internal_result_5 = jerry_object_has_internal (object, internal_prop_name_2);
bool has_internal_result_6 = jerry_object_has_internal (object, internal_prop_name_3);
TEST_ASSERT (!has_internal_result_1);
TEST_ASSERT (!has_internal_result_2);
@@ -120,70 +120,70 @@ main (void)
TEST_ASSERT (has_internal_result_6);
/* Test the normal [[Get]] method. */
jerry_value_t get_result_1 = jerry_get_property (object, prop_name_1);
jerry_value_t get_result_2 = jerry_get_property (object, prop_name_2);
jerry_value_t get_result_3 = jerry_get_property (object, prop_name_3);
jerry_value_t get_result_4 = jerry_get_property (object, internal_prop_name_1);
jerry_value_t get_result_5 = jerry_get_property (object, internal_prop_name_2);
jerry_value_t get_result_6 = jerry_get_property (object, internal_prop_name_3);
jerry_value_t get_result_1 = jerry_object_get (object, prop_name_1);
jerry_value_t get_result_2 = jerry_object_get (object, prop_name_2);
jerry_value_t get_result_3 = jerry_object_get (object, prop_name_3);
jerry_value_t get_result_4 = jerry_object_get (object, internal_prop_name_1);
jerry_value_t get_result_5 = jerry_object_get (object, internal_prop_name_2);
jerry_value_t get_result_6 = jerry_object_get (object, internal_prop_name_3);
TEST_ASSERT (jerry_value_is_number (get_result_1) && jerry_get_number_value (get_result_1) == 5.5);
TEST_ASSERT (jerry_value_is_number (get_result_2) && jerry_get_number_value (get_result_2) == 6.5);
TEST_ASSERT (jerry_value_is_number (get_result_3) && jerry_get_number_value (get_result_3) == 7.5);
TEST_ASSERT (jerry_value_is_number (get_result_1) && jerry_value_as_number (get_result_1) == 5.5);
TEST_ASSERT (jerry_value_is_number (get_result_2) && jerry_value_as_number (get_result_2) == 6.5);
TEST_ASSERT (jerry_value_is_number (get_result_3) && jerry_value_as_number (get_result_3) == 7.5);
TEST_ASSERT (jerry_value_is_undefined (get_result_4));
TEST_ASSERT (jerry_value_is_undefined (get_result_5));
TEST_ASSERT (jerry_value_is_undefined (get_result_6));
jerry_release_value (get_result_1);
jerry_release_value (get_result_2);
jerry_release_value (get_result_3);
jerry_release_value (get_result_4);
jerry_release_value (get_result_5);
jerry_release_value (get_result_6);
jerry_value_free (get_result_1);
jerry_value_free (get_result_2);
jerry_value_free (get_result_3);
jerry_value_free (get_result_4);
jerry_value_free (get_result_5);
jerry_value_free (get_result_6);
/* Test the internal [[Get]] method. */
jerry_value_t get_internal_result_1 = jerry_get_internal_property (object, prop_name_1);
jerry_value_t get_internal_result_2 = jerry_get_internal_property (object, prop_name_2);
jerry_value_t get_internal_result_3 = jerry_get_internal_property (object, prop_name_3);
jerry_value_t get_internal_result_4 = jerry_get_internal_property (object, internal_prop_name_1);
jerry_value_t get_internal_result_5 = jerry_get_internal_property (object, internal_prop_name_2);
jerry_value_t get_internal_result_6 = jerry_get_internal_property (object, internal_prop_name_3);
jerry_value_t get_internal_result_1 = jerry_object_get_internal (object, prop_name_1);
jerry_value_t get_internal_result_2 = jerry_object_get_internal (object, prop_name_2);
jerry_value_t get_internal_result_3 = jerry_object_get_internal (object, prop_name_3);
jerry_value_t get_internal_result_4 = jerry_object_get_internal (object, internal_prop_name_1);
jerry_value_t get_internal_result_5 = jerry_object_get_internal (object, internal_prop_name_2);
jerry_value_t get_internal_result_6 = jerry_object_get_internal (object, internal_prop_name_3);
TEST_ASSERT (jerry_value_is_undefined (get_internal_result_1));
TEST_ASSERT (jerry_value_is_undefined (get_internal_result_2));
TEST_ASSERT (jerry_value_is_undefined (get_internal_result_3));
TEST_ASSERT (jerry_value_is_number (get_internal_result_4) && jerry_get_number_value (get_internal_result_4) == 8.5);
TEST_ASSERT (jerry_value_is_number (get_internal_result_5) && jerry_get_number_value (get_internal_result_5) == 9.5);
TEST_ASSERT (jerry_value_is_number (get_internal_result_6) && jerry_get_number_value (get_internal_result_6) == 10.5);
TEST_ASSERT (jerry_value_is_number (get_internal_result_4) && jerry_value_as_number (get_internal_result_4) == 8.5);
TEST_ASSERT (jerry_value_is_number (get_internal_result_5) && jerry_value_as_number (get_internal_result_5) == 9.5);
TEST_ASSERT (jerry_value_is_number (get_internal_result_6) && jerry_value_as_number (get_internal_result_6) == 10.5);
jerry_release_value (get_internal_result_1);
jerry_release_value (get_internal_result_2);
jerry_release_value (get_internal_result_3);
jerry_release_value (get_internal_result_4);
jerry_release_value (get_internal_result_5);
jerry_release_value (get_internal_result_6);
jerry_value_free (get_internal_result_1);
jerry_value_free (get_internal_result_2);
jerry_value_free (get_internal_result_3);
jerry_value_free (get_internal_result_4);
jerry_value_free (get_internal_result_5);
jerry_value_free (get_internal_result_6);
/* Test the normal [[Delete]] method. */
bool delete_result_1 = jerry_delete_property (object, prop_name_1);
bool delete_result_2 = jerry_delete_property (object, prop_name_2);
bool delete_result_3 = jerry_delete_property (object, prop_name_3);
bool delete_result_4 = jerry_delete_property (object, internal_prop_name_1);
bool delete_result_5 = jerry_delete_property (object, internal_prop_name_2);
bool delete_result_6 = jerry_delete_property (object, internal_prop_name_3);
jerry_value_t delete_result_1 = jerry_object_delete (object, prop_name_1);
jerry_value_t delete_result_2 = jerry_object_delete (object, prop_name_2);
jerry_value_t delete_result_3 = jerry_object_delete (object, prop_name_3);
jerry_value_t delete_result_4 = jerry_object_delete (object, internal_prop_name_1);
jerry_value_t delete_result_5 = jerry_object_delete (object, internal_prop_name_2);
jerry_value_t delete_result_6 = jerry_object_delete (object, internal_prop_name_3);
TEST_ASSERT (delete_result_1);
TEST_ASSERT (delete_result_2);
TEST_ASSERT (delete_result_3);
TEST_ASSERT (delete_result_4);
TEST_ASSERT (delete_result_5);
TEST_ASSERT (delete_result_6);
TEST_ASSERT (jerry_value_is_true (delete_result_1));
TEST_ASSERT (jerry_value_is_true (delete_result_2));
TEST_ASSERT (jerry_value_is_true (delete_result_3));
TEST_ASSERT (jerry_value_is_true (delete_result_4));
TEST_ASSERT (jerry_value_is_true (delete_result_5));
TEST_ASSERT (jerry_value_is_true (delete_result_6));
jerry_value_t has_after_delete_result_1 = jerry_has_property (object, prop_name_1);
jerry_value_t has_after_delete_result_2 = jerry_has_property (object, prop_name_2);
jerry_value_t has_after_delete_result_3 = jerry_has_property (object, prop_name_3);
bool has_after_delete_result_4 = jerry_has_internal_property (object, internal_prop_name_1);
bool has_after_delete_result_5 = jerry_has_internal_property (object, internal_prop_name_2);
bool has_after_delete_result_6 = jerry_has_internal_property (object, internal_prop_name_3);
jerry_value_t has_after_delete_result_1 = jerry_object_has (object, prop_name_1);
jerry_value_t has_after_delete_result_2 = jerry_object_has (object, prop_name_2);
jerry_value_t has_after_delete_result_3 = jerry_object_has (object, prop_name_3);
bool has_after_delete_result_4 = jerry_object_has_internal (object, internal_prop_name_1);
bool has_after_delete_result_5 = jerry_object_has_internal (object, internal_prop_name_2);
bool has_after_delete_result_6 = jerry_object_has_internal (object, internal_prop_name_3);
TEST_ASSERT (jerry_value_is_boolean (has_after_delete_result_1) && !jerry_value_is_true (has_after_delete_result_1));
TEST_ASSERT (jerry_value_is_boolean (has_after_delete_result_2) && !jerry_value_is_true (has_after_delete_result_2));
@@ -192,45 +192,45 @@ main (void)
TEST_ASSERT (has_after_delete_result_5);
TEST_ASSERT (has_after_delete_result_6);
jerry_release_value (has_after_delete_result_1);
jerry_release_value (has_after_delete_result_2);
jerry_release_value (has_after_delete_result_3);
jerry_value_free (has_after_delete_result_1);
jerry_value_free (has_after_delete_result_2);
jerry_value_free (has_after_delete_result_3);
/* Test the internal [[Delete]] method. */
bool delete_internal_result_4 = jerry_delete_internal_property (object, internal_prop_name_1);
bool delete_internal_result_5 = jerry_delete_internal_property (object, internal_prop_name_2);
bool delete_internal_result_6 = jerry_delete_internal_property (object, internal_prop_name_3);
bool delete_internal_result_4 = jerry_object_delete_internal (object, internal_prop_name_1);
bool delete_internal_result_5 = jerry_object_delete_internal (object, internal_prop_name_2);
bool delete_internal_result_6 = jerry_object_delete_internal (object, internal_prop_name_3);
TEST_ASSERT (delete_internal_result_4);
TEST_ASSERT (delete_internal_result_5);
TEST_ASSERT (delete_internal_result_6);
bool has_after_internal_delete_result_1 = jerry_has_internal_property (object, internal_prop_name_1);
bool has_after_internal_delete_result_2 = jerry_has_internal_property (object, internal_prop_name_2);
bool has_after_internal_delete_result_3 = jerry_has_internal_property (object, internal_prop_name_3);
bool has_after_internal_delete_result_1 = jerry_object_has_internal (object, internal_prop_name_1);
bool has_after_internal_delete_result_2 = jerry_object_has_internal (object, internal_prop_name_2);
bool has_after_internal_delete_result_3 = jerry_object_has_internal (object, internal_prop_name_3);
TEST_ASSERT (!has_after_internal_delete_result_1);
TEST_ASSERT (!has_after_internal_delete_result_2);
TEST_ASSERT (!has_after_internal_delete_result_3);
/* Cleanup */
jerry_release_value (prop_value_3);
jerry_release_value (prop_value_2);
jerry_release_value (prop_value_1);
jerry_value_free (prop_value_3);
jerry_value_free (prop_value_2);
jerry_value_free (prop_value_1);
jerry_release_value (prop_name_3);
jerry_release_value (prop_name_2);
jerry_release_value (prop_name_1);
jerry_value_free (prop_name_3);
jerry_value_free (prop_name_2);
jerry_value_free (prop_name_1);
jerry_release_value (internal_prop_value_3);
jerry_release_value (internal_prop_value_2);
jerry_release_value (internal_prop_value_1);
jerry_value_free (internal_prop_value_3);
jerry_value_free (internal_prop_value_2);
jerry_value_free (internal_prop_value_1);
jerry_release_value (internal_prop_name_3);
jerry_release_value (internal_prop_name_2);
jerry_release_value (internal_prop_name_1);
jerry_value_free (internal_prop_name_3);
jerry_value_free (internal_prop_name_2);
jerry_value_free (internal_prop_name_1);
jerry_release_value (object);
jerry_value_free (object);
jerry_cleanup ();
tests/unit-core/test-is-eval-code.c
+23 -23
View File
@@ -25,8 +25,8 @@ check_eval (const jerry_call_info_t *call_info_p, /**< call information */
{
JERRY_UNUSED (call_info_p);
TEST_ASSERT (args_cnt == 2 && jerry_is_eval_code (args_p[0]) == jerry_value_is_true (args_p[1]));
return jerry_create_boolean (true);
TEST_ASSERT (args_cnt == 2 && jerry_function_is_dynamic (args_p[0]) == jerry_value_is_true (args_p[1]));
return jerry_boolean (true);
} /* check_eval */
static void
@@ -34,22 +34,22 @@ test_parse (const char *source_p, /**< source code */
jerry_parse_options_t *options_p) /**< options passed to jerry_parse */
{
jerry_value_t parse_result = jerry_parse ((const jerry_char_t *) source_p, strlen (source_p), options_p);
TEST_ASSERT (!jerry_value_is_error (parse_result));
TEST_ASSERT (!jerry_is_eval_code (parse_result));
TEST_ASSERT (!jerry_value_is_exception (parse_result));
TEST_ASSERT (!jerry_function_is_dynamic (parse_result));
jerry_value_t result;
if (options_p->options & JERRY_PARSE_HAS_ARGUMENT_LIST)
{
jerry_value_t this_value = jerry_create_undefined ();
result = jerry_call_function (parse_result, this_value, NULL, 0);
jerry_release_value (this_value);
jerry_value_t this_value = jerry_undefined ();
result = jerry_call (parse_result, this_value, NULL, 0);
jerry_value_free (this_value);
}
else if (options_p->options & JERRY_PARSE_MODULE)
{
result = jerry_module_link (parse_result, NULL, NULL);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
result = jerry_module_evaluate (parse_result);
}
else
@@ -57,10 +57,10 @@ test_parse (const char *source_p, /**< source code */
result = jerry_run (parse_result);
}
TEST_ASSERT (!jerry_value_is_error (result));
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_release_value (parse_result);
jerry_release_value (result);
jerry_value_free (parse_result);
jerry_value_free (result);
} /* test_parse */
int
@@ -70,15 +70,15 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t global_object_value = jerry_get_global_object ();
jerry_value_t global_object_value = jerry_current_realm ();
jerry_value_t function_value = jerry_create_external_function (check_eval);
jerry_value_t function_name_value = jerry_create_string ((const jerry_char_t *) "check_eval");
jerry_release_value (jerry_set_property (global_object_value, function_name_value, function_value));
jerry_value_t function_value = jerry_function_external (check_eval);
jerry_value_t function_name_value = jerry_string_sz ("check_eval");
jerry_value_free (jerry_object_set (global_object_value, function_name_value, function_value));
jerry_release_value (function_name_value);
jerry_release_value (function_value);
jerry_release_value (global_object_value);
jerry_value_free (function_name_value);
jerry_value_free (function_value);
jerry_value_free (global_object_value);
jerry_parse_options_t parse_options;
const char *source_p = TEST_STRING_LITERAL ("eval('check_eval(function() {}, true)')\n"
@@ -87,23 +87,23 @@ main (void)
parse_options.options = JERRY_PARSE_NO_OPTS;
test_parse (source_p, &parse_options);
if (jerry_is_feature_enabled (JERRY_FEATURE_MODULE))
if (jerry_feature_enabled (JERRY_FEATURE_MODULE))
{
parse_options.options = JERRY_PARSE_MODULE;
test_parse (source_p, &parse_options);
}
parse_options.options = JERRY_PARSE_HAS_ARGUMENT_LIST;
parse_options.argument_list = jerry_create_string ((const jerry_char_t *) "");
parse_options.argument_list = jerry_string_sz ("");
test_parse (source_p, &parse_options);
jerry_release_value (parse_options.argument_list);
jerry_value_free (parse_options.argument_list);
parse_options.options = JERRY_PARSE_NO_OPTS;
source_p = TEST_STRING_LITERAL ("check_eval(new Function('a', 'return a'), true)");
test_parse (source_p, &parse_options);
source_p = TEST_STRING_LITERAL ("check_eval(function() {}, true)");
jerry_release_value (jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), JERRY_PARSE_NO_OPTS));
jerry_value_free (jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), JERRY_PARSE_NO_OPTS));
jerry_cleanup ();
return 0;
tests/unit-core/test-json.c
+74 -54
View File
@@ -27,7 +27,7 @@ custom_to_json (const jerry_call_info_t *call_info_p, /**< call information */
JERRY_UNUSED (args_p);
JERRY_UNUSED (args_cnt);
return jerry_create_error (JERRY_ERROR_URI, (const jerry_char_t *) "Error");
return jerry_throw_sz (JERRY_ERROR_URI, "Error");
} /* custom_to_json */
int
@@ -43,125 +43,145 @@ main (void)
jerry_value_t parsed_json = jerry_json_parse (data, sizeof (data) - 1);
/* Check "name" property values */
jerry_value_t name_key = jerry_create_string ((const jerry_char_t *) "name");
jerry_value_t name_key = jerry_string_sz ("name");
jerry_value_t has_name = jerry_has_property (parsed_json, name_key);
jerry_value_t has_name = jerry_object_has (parsed_json, name_key);
TEST_ASSERT (jerry_value_is_true (has_name));
jerry_release_value (has_name);
jerry_value_free (has_name);
jerry_value_t name_value = jerry_get_property (parsed_json, name_key);
jerry_value_t name_value = jerry_object_get (parsed_json, name_key);
TEST_ASSERT (jerry_value_is_string (name_value) == true);
jerry_size_t name_size = jerry_get_string_size (name_value);
jerry_size_t name_size = jerry_string_size (name_value, JERRY_ENCODING_CESU8);
TEST_ASSERT (name_size == 4);
JERRY_VLA (jerry_char_t, name_data, name_size + 1);
jerry_size_t copied = jerry_string_to_char_buffer (name_value, name_data, name_size);
jerry_size_t copied = jerry_string_to_buffer (name_value, JERRY_ENCODING_CESU8, name_data, name_size);
name_data[name_size] = '\0';
jerry_release_value (name_value);
jerry_value_free (name_value);
TEST_ASSERT (copied == name_size);
TEST_ASSERT_STR ("John", name_data);
jerry_release_value (name_key);
jerry_value_free (name_key);
/* Check "age" property values */
jerry_value_t age_key = jerry_create_string ((const jerry_char_t *) "age");
jerry_value_t age_key = jerry_string_sz ("age");
jerry_value_t has_age = jerry_has_property (parsed_json, age_key);
jerry_value_t has_age = jerry_object_has (parsed_json, age_key);
TEST_ASSERT (jerry_value_is_true (has_age));
jerry_release_value (has_age);
jerry_value_free (has_age);
jerry_value_t age_value = jerry_get_property (parsed_json, age_key);
jerry_value_t age_value = jerry_object_get (parsed_json, age_key);
TEST_ASSERT (jerry_value_is_number (age_value) == true);
TEST_ASSERT (jerry_get_number_value (age_value) == 5.0);
TEST_ASSERT (jerry_value_as_number (age_value) == 5.0);
jerry_release_value (age_value);
jerry_release_value (age_key);
jerry_value_free (age_value);
jerry_value_free (age_key);
jerry_release_value (parsed_json);
jerry_value_free (parsed_json);
}
/* JSON.parse cesu-8 / utf-8 encoded string */
{
jerry_char_t cesu8[] = "{\"ch\": \"\xED\xA0\x83\xED\xB2\x9F\"}";
jerry_char_t utf8[] = "{\"ch\": \"\xF0\x90\xB2\x9F\"}";
jerry_value_t parsed_cesu8 = jerry_json_parse (cesu8, sizeof (cesu8) - 1);
jerry_value_t parsed_utf8 = jerry_json_parse (utf8, sizeof (utf8) - 1);
jerry_value_t key = jerry_string_sz ("ch");
jerry_value_t char_cesu8 = jerry_object_get (parsed_cesu8, key);
jerry_value_t char_utf8 = jerry_object_get (parsed_utf8, key);
jerry_value_free (key);
TEST_ASSERT (jerry_value_to_boolean (jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, char_cesu8, char_utf8)));
jerry_value_free (char_cesu8);
jerry_value_free (char_utf8);
jerry_value_free (parsed_cesu8);
jerry_value_free (parsed_utf8);
}
/* JSON.parse error checks */
{
jerry_value_t parsed_json = jerry_json_parse ((const jerry_char_t *) "", 0);
TEST_ASSERT (jerry_value_is_error (parsed_json));
TEST_ASSERT (jerry_get_error_type (parsed_json) == JERRY_ERROR_SYNTAX);
jerry_release_value (parsed_json);
TEST_ASSERT (jerry_value_is_exception (parsed_json));
TEST_ASSERT (jerry_error_type (parsed_json) == JERRY_ERROR_SYNTAX);
jerry_value_free (parsed_json);
}
{
jerry_value_t parsed_json = jerry_json_parse ((const jerry_char_t *) "-", 1);
TEST_ASSERT (jerry_value_is_error (parsed_json));
TEST_ASSERT (jerry_get_error_type (parsed_json) == JERRY_ERROR_SYNTAX);
jerry_release_value (parsed_json);
TEST_ASSERT (jerry_value_is_exception (parsed_json));
TEST_ASSERT (jerry_error_type (parsed_json) == JERRY_ERROR_SYNTAX);
jerry_value_free (parsed_json);
}
/* JSON.stringify check */
{
jerry_value_t obj = jerry_create_object ();
jerry_value_t obj = jerry_object ();
/* Fill "obj" with data */
{
jerry_value_t name_key = jerry_create_string ((const jerry_char_t *) "name");
jerry_value_t name_value = jerry_create_string ((const jerry_char_t *) "John");
jerry_value_t name_set = jerry_set_property (obj, name_key, name_value);
TEST_ASSERT (!jerry_value_is_error (name_set));
jerry_value_t name_key = jerry_string_sz ("name");
jerry_value_t name_value = jerry_string_sz ("John");
jerry_value_t name_set = jerry_object_set (obj, name_key, name_value);
TEST_ASSERT (!jerry_value_is_exception (name_set));
TEST_ASSERT (jerry_value_is_boolean (name_set));
TEST_ASSERT (jerry_value_is_true (name_set));
jerry_release_value (name_key);
jerry_release_value (name_value);
jerry_release_value (name_set);
jerry_value_free (name_key);
jerry_value_free (name_value);
jerry_value_free (name_set);
}
{
jerry_value_t age_key = jerry_create_string ((const jerry_char_t *) "age");
jerry_value_t age_value = jerry_create_number (32);
jerry_value_t age_set = jerry_set_property (obj, age_key, age_value);
TEST_ASSERT (!jerry_value_is_error (age_set));
jerry_value_t age_key = jerry_string_sz ("age");
jerry_value_t age_value = jerry_number (32);
jerry_value_t age_set = jerry_object_set (obj, age_key, age_value);
TEST_ASSERT (!jerry_value_is_exception (age_set));
TEST_ASSERT (jerry_value_is_boolean (age_set));
TEST_ASSERT (jerry_value_is_true (age_set));
jerry_release_value (age_key);
jerry_release_value (age_value);
jerry_release_value (age_set);
jerry_value_free (age_key);
jerry_value_free (age_value);
jerry_value_free (age_set);
}
jerry_value_t json_string = jerry_json_stringify (obj);
TEST_ASSERT (jerry_value_is_string (json_string));
jerry_release_value (obj);
jerry_value_free (obj);
const char check_value[] = "{\"name\":\"John\",\"age\":32}";
jerry_size_t json_size = jerry_get_string_size (json_string);
jerry_size_t json_size = jerry_string_size (json_string, JERRY_ENCODING_CESU8);
TEST_ASSERT (json_size == strlen (check_value));
JERRY_VLA (jerry_char_t, json_data, json_size + 1);
jerry_string_to_char_buffer (json_string, json_data, json_size);
jerry_string_to_buffer (json_string, JERRY_ENCODING_CESU8, json_data, json_size);
json_data[json_size] = '\0';
TEST_ASSERT_STR (check_value, json_data);
jerry_release_value (json_string);
jerry_value_free (json_string);
}
/* Custom "toJSON" invocation test */
{
jerry_value_t obj = jerry_create_object ();
jerry_value_t obj = jerry_object ();
/* Fill "obj" with data */
{
jerry_value_t name_key = jerry_create_string ((const jerry_char_t *) "toJSON");
jerry_value_t name_value = jerry_create_external_function (custom_to_json);
jerry_value_t name_set = jerry_set_property (obj, name_key, name_value);
TEST_ASSERT (!jerry_value_is_error (name_set));
jerry_value_t name_key = jerry_string_sz ("toJSON");
jerry_value_t name_value = jerry_function_external (custom_to_json);
jerry_value_t name_set = jerry_object_set (obj, name_key, name_value);
TEST_ASSERT (!jerry_value_is_exception (name_set));
TEST_ASSERT (jerry_value_is_boolean (name_set));
TEST_ASSERT (jerry_value_is_true (name_set));
jerry_release_value (name_key);
jerry_release_value (name_value);
jerry_release_value (name_set);
jerry_value_free (name_key);
jerry_value_free (name_value);
jerry_value_free (name_set);
}
jerry_value_t json_string = jerry_json_stringify (obj);
TEST_ASSERT (jerry_value_is_error (json_string));
TEST_ASSERT (jerry_get_error_type (json_string) == JERRY_ERROR_URI);
TEST_ASSERT (jerry_value_is_exception (json_string));
TEST_ASSERT (jerry_error_type (json_string) == JERRY_ERROR_URI);
jerry_release_value (json_string);
jerry_release_value (obj);
jerry_value_free (json_string);
jerry_value_free (obj);
}
jerry_cleanup ();
tests/unit-core/test-mem-stats.c
+7 -7
View File
@@ -20,7 +20,7 @@
int
main (void)
{
if (!jerry_is_feature_enabled (JERRY_FEATURE_MEM_STATS))
if (!jerry_feature_enabled (JERRY_FEATURE_HEAP_STATS))
{
return 0;
}
@@ -30,22 +30,22 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t parsed_code_val = jerry_parse (test_source, sizeof (test_source) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (!jerry_value_is_exception (res));
jerry_heap_stats_t stats;
memset (&stats, 0, sizeof (stats));
bool get_stats_ret = jerry_get_memory_stats (&stats);
bool get_stats_ret = jerry_heap_stats (&stats);
TEST_ASSERT (get_stats_ret);
TEST_ASSERT (stats.version == 1);
TEST_ASSERT (stats.size == 524280);
TEST_ASSERT (!jerry_get_memory_stats (NULL));
TEST_ASSERT (!jerry_heap_stats (NULL));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_value_free (res);
jerry_value_free (parsed_code_val);
jerry_cleanup ();
tests/unit-core/test-module-dynamic.c
+61 -61
View File
@@ -30,24 +30,24 @@ global_assert (const jerry_call_info_t *call_info_p, /**< call information */
JERRY_UNUSED (call_info_p);
TEST_ASSERT (args_cnt == 1 && jerry_value_is_true (args_p[0]));
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* global_assert */
static void
register_assert (void)
{
jerry_value_t global_object_value = jerry_get_global_object ();
jerry_value_t global_object_value = jerry_current_realm ();
jerry_value_t function_value = jerry_create_external_function (global_assert);
jerry_value_t function_name_value = jerry_create_string ((const jerry_char_t *) "assert");
jerry_value_t result_value = jerry_set_property (global_object_value, function_name_value, function_value);
jerry_value_t function_value = jerry_function_external (global_assert);
jerry_value_t function_name_value = jerry_string_sz ("assert");
jerry_value_t result_value = jerry_object_set (global_object_value, function_name_value, function_value);
jerry_release_value (function_name_value);
jerry_release_value (function_value);
jerry_release_value (global_object_value);
jerry_value_free (function_name_value);
jerry_value_free (function_value);
jerry_value_free (global_object_value);
TEST_ASSERT (jerry_value_is_true (result_value));
jerry_release_value (result_value);
jerry_value_free (result_value);
} /* register_assert */
static void
@@ -65,9 +65,9 @@ compare_specifier (jerry_value_t specifier, /* string value */
jerry_char_t buffer[sizeof (string) - 1];
TEST_ASSERT (jerry_value_is_string (specifier));
TEST_ASSERT (jerry_get_string_size (specifier) == length);
TEST_ASSERT (jerry_string_size (specifier, JERRY_ENCODING_CESU8) == length);
TEST_ASSERT (jerry_string_to_char_buffer (specifier, buffer, length) == length);
TEST_ASSERT (jerry_string_to_buffer (specifier, JERRY_ENCODING_CESU8, buffer, length) == length);
TEST_ASSERT (memcmp (buffer, string, length) == 0);
} /* compare_specifier */
@@ -80,10 +80,10 @@ module_import_callback (const jerry_value_t specifier, /* string value */
if (mode != 3)
{
jerry_value_t compare_value = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, user_value, global_user_value);
jerry_value_t compare_value = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, user_value, global_user_value);
TEST_ASSERT (jerry_value_is_true (compare_value));
jerry_release_value (compare_value);
jerry_value_free (compare_value);
}
switch (mode)
@@ -91,22 +91,22 @@ module_import_callback (const jerry_value_t specifier, /* string value */
case 0:
{
compare_specifier (specifier, 1);
return jerry_create_error (JERRY_ERROR_RANGE, (const jerry_char_t *) "Err01");
return jerry_throw_sz (JERRY_ERROR_RANGE, "Err01");
}
case 1:
{
compare_specifier (specifier, 2);
return jerry_create_null ();
return jerry_null ();
}
case 2:
{
compare_specifier (specifier, 3);
jerry_value_t promise_value = jerry_create_promise ();
jerry_value_t promise_value = jerry_promise ();
/* Normally this should be a namespace object. */
jerry_value_t object_value = jerry_create_object ();
jerry_resolve_or_reject_promise (promise_value, object_value, true);
jerry_release_value (object_value);
jerry_value_t object_value = jerry_object ();
jerry_promise_resolve (promise_value, object_value);
jerry_value_free (object_value);
return promise_value;
}
case 3:
@@ -114,12 +114,12 @@ module_import_callback (const jerry_value_t specifier, /* string value */
compare_specifier (specifier, 28);
TEST_ASSERT (jerry_value_is_object (user_value));
jerry_value_t property_name = jerry_create_string ((const jerry_char_t *) "MyProp1");
jerry_value_t result = jerry_get_property (user_value, property_name);
TEST_ASSERT (jerry_value_is_number (result) && jerry_get_number_value (result) == 3.5);
jerry_release_value (result);
jerry_release_value (property_name);
return jerry_create_undefined ();
jerry_value_t property_name = jerry_string_sz ("MyProp1");
jerry_value_t result = jerry_object_get (user_value, property_name);
TEST_ASSERT (jerry_value_is_number (result) && jerry_value_as_number (result) == 3.5);
jerry_value_free (result);
jerry_value_free (property_name);
return jerry_undefined ();
}
}
@@ -129,17 +129,17 @@ module_import_callback (const jerry_value_t specifier, /* string value */
parse_options.options = JERRY_PARSE_MODULE;
jerry_value_t parse_result_value = jerry_parse ((const jerry_char_t *) "", 0, &parse_options);
TEST_ASSERT (!jerry_value_is_error (parse_result_value));
TEST_ASSERT (!jerry_value_is_exception (parse_result_value));
jerry_value_t result_value = jerry_module_link (parse_result_value, NULL, NULL);
TEST_ASSERT (!jerry_value_is_error (result_value));
jerry_release_value (result_value);
TEST_ASSERT (!jerry_value_is_exception (result_value));
jerry_value_free (result_value);
if (mode == 4)
{
result_value = jerry_module_evaluate (parse_result_value);
TEST_ASSERT (!jerry_value_is_error (result_value));
jerry_release_value (result_value);
TEST_ASSERT (!jerry_value_is_exception (result_value));
jerry_value_free (result_value);
}
return parse_result_value;
@@ -153,20 +153,20 @@ run_script (const char *source_p, /* source code */
jerry_value_t parse_result_value;
parse_result_value = jerry_parse ((const jerry_char_t *) source_p, strlen (source_p), parse_options_p);
TEST_ASSERT (!jerry_value_is_error (parse_result_value));
TEST_ASSERT (!jerry_value_is_exception (parse_result_value));
if (release_user_value)
{
jerry_release_value (parse_options_p->user_value);
jerry_gc (JERRY_GC_PRESSURE_HIGH);
jerry_value_free (parse_options_p->user_value);
jerry_heap_gc (JERRY_GC_PRESSURE_HIGH);
}
jerry_value_t result_value;
if (parse_options_p->options & JERRY_PARSE_MODULE)
{
result_value = jerry_module_link (parse_result_value, NULL, NULL);
TEST_ASSERT (!jerry_value_is_error (result_value));
jerry_release_value (result_value);
TEST_ASSERT (!jerry_value_is_exception (result_value));
jerry_value_free (result_value);
result_value = jerry_module_evaluate (parse_result_value);
}
@@ -175,14 +175,14 @@ run_script (const char *source_p, /* source code */
result_value = jerry_run (parse_result_value);
}
jerry_release_value (parse_result_value);
jerry_value_free (parse_result_value);
TEST_ASSERT (!jerry_value_is_error (result_value));
jerry_release_value (result_value);
TEST_ASSERT (!jerry_value_is_exception (result_value));
jerry_value_free (result_value);
result_value = jerry_run_all_enqueued_jobs ();
TEST_ASSERT (!jerry_value_is_error (result_value));
jerry_release_value (result_value);
result_value = jerry_run_jobs ();
TEST_ASSERT (!jerry_value_is_exception (result_value));
jerry_value_free (result_value);
} /* run_script */
int
@@ -190,7 +190,7 @@ main (void)
{
jerry_init (JERRY_INIT_EMPTY);
if (!jerry_is_feature_enabled (JERRY_FEATURE_MODULE))
if (!jerry_feature_enabled (JERRY_FEATURE_MODULE))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Module is disabled!\n");
jerry_cleanup ();
@@ -198,12 +198,12 @@ main (void)
}
register_assert ();
jerry_module_set_import_callback (module_import_callback, (void *) &mode);
jerry_module_on_import (module_import_callback, (void *) &mode);
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_NO_OPTS;
if (jerry_is_feature_enabled (JERRY_FEATURE_ERROR_MESSAGES))
if (jerry_feature_enabled (JERRY_FEATURE_ERROR_MESSAGES))
{
run_script ("var expected_message = 'Module cannot be instantiated'", &parse_options, false);
}
@@ -212,7 +212,7 @@ main (void)
run_script ("var expected_message = ''", &parse_options, false);
}
global_user_value = jerry_create_object ();
global_user_value = jerry_object ();
const char *source_p = TEST_STRING_LITERAL ("import('01_module.mjs').then(\n"
" function(resolve) { assert(false) },\n"
" function(reject) {\n"
@@ -225,9 +225,9 @@ main (void)
parse_options.options = JERRY_PARSE_HAS_USER_VALUE;
parse_options.user_value = global_user_value;
run_script (source_p, &parse_options, false);
jerry_release_value (global_user_value);
jerry_value_free (global_user_value);
global_user_value = jerry_create_null ();
global_user_value = jerry_null ();
source_p = TEST_STRING_LITERAL ("var src = \"import('02_module.mjs').then(\\\n"
" function(resolve) { assert(false) },\\\n"
" function(reject) {\\\n"
@@ -241,9 +241,9 @@ main (void)
parse_options.options = JERRY_PARSE_HAS_USER_VALUE;
parse_options.user_value = global_user_value;
run_script (source_p, &parse_options, false);
jerry_release_value (global_user_value);
jerry_value_free (global_user_value);
global_user_value = jerry_create_number (5.6);
global_user_value = jerry_number (5.6);
source_p = TEST_STRING_LITERAL ("function f() {\n"
" return function () {\n"
" return import('03_module.mjs')\n"
@@ -258,9 +258,9 @@ main (void)
parse_options.options = JERRY_PARSE_HAS_USER_VALUE | JERRY_PARSE_MODULE;
parse_options.user_value = global_user_value;
run_script (source_p, &parse_options, false);
jerry_release_value (global_user_value);
jerry_value_free (global_user_value);
global_user_value = jerry_create_string ((const jerry_char_t *) "Any string...");
global_user_value = jerry_string_sz ("Any string...");
source_p = TEST_STRING_LITERAL ("var src = \"import('02_module.mjs').then(\\\n"
" function(resolve) { assert(typeof resolve == 'object') },\\\n"
" function(reject) { assert(false) }\\\n"
@@ -274,14 +274,14 @@ main (void)
{
mode = 3;
parse_options.options = JERRY_PARSE_HAS_USER_VALUE | (i == 1 ? JERRY_PARSE_MODULE : 0);
parse_options.user_value = jerry_create_object ();
jerry_value_t property_name = jerry_create_string ((const jerry_char_t *) "MyProp1");
jerry_value_t property_value = jerry_create_number (3.5);
jerry_value_t result = jerry_set_property (parse_options.user_value, property_name, property_value);
parse_options.user_value = jerry_object ();
jerry_value_t property_name = jerry_string_sz ("MyProp1");
jerry_value_t property_value = jerry_number (3.5);
jerry_value_t result = jerry_object_set (parse_options.user_value, property_name, property_value);
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_release_value (property_value);
jerry_release_value (property_name);
jerry_value_free (result);
jerry_value_free (property_value);
jerry_value_free (property_name);
source_p = TEST_STRING_LITERAL ("import('28_module.mjs')");
run_script (source_p, &parse_options, true);
@@ -291,9 +291,9 @@ main (void)
parse_options.options = JERRY_PARSE_HAS_USER_VALUE;
parse_options.user_value = global_user_value;
run_script (source_p, &parse_options, false);
jerry_release_value (global_user_value);
jerry_value_free (global_user_value);
global_user_value = jerry_create_external_function (global_assert);
global_user_value = jerry_function_external (global_assert);
source_p = TEST_STRING_LITERAL ("var src = \"import('02_module.mjs').then(\\\n"
" function(resolve) { assert(false) },\\\n"
" function(reject) {\\\n"
@@ -310,7 +310,7 @@ main (void)
parse_options.options = JERRY_PARSE_HAS_USER_VALUE | JERRY_PARSE_MODULE;
parse_options.user_value = global_user_value;
run_script (source_p, &parse_options, false);
jerry_release_value (global_user_value);
jerry_value_free (global_user_value);
jerry_cleanup ();
return 0;
tests/unit-core/test-module-import-meta.c
+23 -23
View File
@@ -29,24 +29,24 @@ global_assert (const jerry_call_info_t *call_info_p, /**< call information */
JERRY_UNUSED (call_info_p);
TEST_ASSERT (args_cnt == 1 && jerry_value_is_true (args_p[0]));
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* global_assert */
static void
register_assert (void)
{
jerry_value_t global_object_value = jerry_get_global_object ();
jerry_value_t global_object_value = jerry_current_realm ();
jerry_value_t function_value = jerry_create_external_function (global_assert);
jerry_value_t function_name_value = jerry_create_string ((const jerry_char_t *) "assert");
jerry_value_t result_value = jerry_set_property (global_object_value, function_name_value, function_value);
jerry_value_t function_value = jerry_function_external (global_assert);
jerry_value_t function_name_value = jerry_string_sz ("assert");
jerry_value_t result_value = jerry_object_set (global_object_value, function_name_value, function_value);
jerry_release_value (function_name_value);
jerry_release_value (function_value);
jerry_release_value (global_object_value);
jerry_value_free (function_name_value);
jerry_value_free (function_value);
jerry_value_free (global_object_value);
TEST_ASSERT (jerry_value_is_true (result_value));
jerry_release_value (result_value);
jerry_value_free (result_value);
} /* register_assert */
static void
@@ -57,10 +57,10 @@ module_import_meta_callback (const jerry_value_t module, /**< module */
TEST_ASSERT (user_p == (void *) &counter);
TEST_ASSERT (module == global_module_value);
jerry_value_t property_name_value = jerry_create_string ((const jerry_char_t *) "prop");
jerry_value_t result_value = jerry_set_property (meta_object, property_name_value, property_name_value);
jerry_release_value (result_value);
jerry_release_value (property_name_value);
jerry_value_t property_name_value = jerry_string_sz ("prop");
jerry_value_t result_value = jerry_object_set (meta_object, property_name_value, property_name_value);
jerry_value_free (result_value);
jerry_value_free (property_name_value);
counter++;
} /* module_import_meta_callback */
@@ -70,8 +70,8 @@ test_syntax_error (const char *source_p, /**< source code */
const jerry_parse_options_t *options_p) /**< parse options */
{
jerry_value_t result_value = jerry_parse ((const jerry_char_t *) source_p, strlen (source_p), options_p);
TEST_ASSERT (jerry_value_is_error (result_value) && jerry_get_error_type (result_value) == JERRY_ERROR_SYNTAX);
jerry_release_value (result_value);
TEST_ASSERT (jerry_value_is_exception (result_value) && jerry_error_type (result_value) == JERRY_ERROR_SYNTAX);
jerry_value_free (result_value);
} /* test_syntax_error */
static void
@@ -79,18 +79,18 @@ run_module (const char *source_p, /* source code */
jerry_parse_options_t *parse_options_p) /* parse options */
{
global_module_value = jerry_parse ((const jerry_char_t *) source_p, strlen (source_p), parse_options_p);
TEST_ASSERT (!jerry_value_is_error (global_module_value));
TEST_ASSERT (!jerry_value_is_exception (global_module_value));
jerry_value_t result_value = jerry_module_link (global_module_value, NULL, NULL);
TEST_ASSERT (!jerry_value_is_error (result_value));
jerry_release_value (result_value);
TEST_ASSERT (!jerry_value_is_exception (result_value));
jerry_value_free (result_value);
result_value = jerry_module_evaluate (global_module_value);
jerry_release_value (global_module_value);
jerry_value_free (global_module_value);
TEST_ASSERT (!jerry_value_is_error (result_value));
jerry_release_value (result_value);
TEST_ASSERT (!jerry_value_is_exception (result_value));
jerry_value_free (result_value);
} /* run_module */
int
@@ -98,7 +98,7 @@ main (void)
{
jerry_init (JERRY_INIT_EMPTY);
if (!jerry_is_feature_enabled (JERRY_FEATURE_MODULE))
if (!jerry_feature_enabled (JERRY_FEATURE_MODULE))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Module is disabled!\n");
jerry_cleanup ();
@@ -106,7 +106,7 @@ main (void)
}
register_assert ();
jerry_module_set_import_meta_callback (module_import_meta_callback, (void *) &counter);
jerry_module_on_import_meta (module_import_meta_callback, (void *) &counter);
/* Syntax errors. */
test_syntax_error ("import.meta", NULL);
tests/unit-core/test-module.c
+172 -173
View File
@@ -34,9 +34,9 @@ compare_specifier (jerry_value_t specifier, /* string value */
jerry_char_t buffer[sizeof (string) - 1];
TEST_ASSERT (jerry_value_is_string (specifier));
TEST_ASSERT (jerry_get_string_size (specifier) == length);
TEST_ASSERT (jerry_string_size (specifier, JERRY_ENCODING_CESU8) == length);
TEST_ASSERT (jerry_string_to_char_buffer (specifier, buffer, length) == length);
TEST_ASSERT (jerry_string_to_buffer (specifier, JERRY_ENCODING_CESU8, buffer, length) == length);
TEST_ASSERT (memcmp (buffer, string, length) == 0);
} /* compare_specifier */
@@ -45,14 +45,14 @@ compare_property (jerry_value_t namespace_object, /**< namespace object */
const char *name_p, /**< property name */
double expected_value) /**< property value (number for simplicity) */
{
jerry_value_t name = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t result = jerry_get_property (namespace_object, name);
jerry_value_t name = jerry_string_sz (name_p);
jerry_value_t result = jerry_object_get (namespace_object, name);
TEST_ASSERT (jerry_value_is_number (result));
TEST_ASSERT (jerry_get_number_value (result) == expected_value);
TEST_ASSERT (jerry_value_as_number (result) == expected_value);
jerry_release_value (result);
jerry_release_value (name);
jerry_value_free (result);
jerry_value_free (name);
} /* compare_property */
static jerry_value_t
@@ -81,7 +81,7 @@ create_module (int id) /**< module id */
result = jerry_parse (source, sizeof (source) - 1, &module_parse_options);
}
TEST_ASSERT (!jerry_value_is_error (result));
TEST_ASSERT (!jerry_value_is_exception (result));
return result;
} /* create_module */
@@ -98,7 +98,7 @@ resolve_callback1 (const jerry_value_t specifier, /**< module specifier */
compare_specifier (specifier, 1);
counter++;
return counter == 1 ? jerry_create_number (7) : jerry_create_object ();
return counter == 1 ? jerry_number (7) : jerry_object ();
} /* resolve_callback1 */
static jerry_value_t prev_module;
@@ -118,7 +118,7 @@ resolve_callback2 (const jerry_value_t specifier, /**< module specifier */
{
if (terminate_with_error)
{
return jerry_create_error (JERRY_ERROR_RANGE, (const jerry_char_t *) "Module not found");
return jerry_throw_sz (JERRY_ERROR_RANGE, "Module not found");
}
return create_module (0);
@@ -145,62 +145,62 @@ native_module_evaluate (const jerry_value_t native_module) /**< native module */
{
++counter;
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_EVALUATING);
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_EVALUATING);
jerry_value_t exp_val = jerry_create_string ((const jerry_char_t *) "exp");
jerry_value_t other_exp_val = jerry_create_string ((const jerry_char_t *) "other_exp");
jerry_value_t exp_val = jerry_string_sz ("exp");
jerry_value_t other_exp_val = jerry_string_sz ("other_exp");
/* The native module has no such export. */
jerry_value_t no_exp_val = jerry_create_string ((const jerry_char_t *) "no_exp");
jerry_value_t no_exp_val = jerry_string_sz ("no_exp");
jerry_value_t result = jerry_native_module_get_export (native_module, exp_val);
jerry_value_t result = jerry_native_module_get (native_module, exp_val);
TEST_ASSERT (jerry_value_is_undefined (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_native_module_get_export (native_module, other_exp_val);
result = jerry_native_module_get (native_module, other_exp_val);
TEST_ASSERT (jerry_value_is_undefined (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_native_module_get_export (native_module, no_exp_val);
TEST_ASSERT (jerry_value_is_error (result));
TEST_ASSERT (jerry_get_error_type (result) == JERRY_ERROR_REFERENCE);
jerry_release_value (result);
result = jerry_native_module_get (native_module, no_exp_val);
TEST_ASSERT (jerry_value_is_exception (result));
TEST_ASSERT (jerry_error_type (result) == JERRY_ERROR_REFERENCE);
jerry_value_free (result);
jerry_value_t export = jerry_create_number (3.5);
result = jerry_native_module_set_export (native_module, exp_val, export);
jerry_value_t export = jerry_number (3.5);
result = jerry_native_module_set (native_module, exp_val, export);
TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
jerry_release_value (result);
jerry_release_value (export);
jerry_value_free (result);
jerry_value_free (export);
export = jerry_create_string ((const jerry_char_t *) "str");
result = jerry_native_module_set_export (native_module, other_exp_val, export);
export = jerry_string_sz ("str");
result = jerry_native_module_set (native_module, other_exp_val, export);
TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
jerry_release_value (result);
jerry_release_value (export);
jerry_value_free (result);
jerry_value_free (export);
result = jerry_native_module_set_export (native_module, no_exp_val, no_exp_val);
TEST_ASSERT (jerry_value_is_error (result));
TEST_ASSERT (jerry_get_error_type (result) == JERRY_ERROR_REFERENCE);
jerry_release_value (result);
result = jerry_native_module_set (native_module, no_exp_val, no_exp_val);
TEST_ASSERT (jerry_value_is_exception (result));
TEST_ASSERT (jerry_error_type (result) == JERRY_ERROR_REFERENCE);
jerry_value_free (result);
result = jerry_native_module_get_export (native_module, exp_val);
TEST_ASSERT (jerry_value_is_number (result) && jerry_get_number_value (result) == 3.5);
jerry_release_value (result);
result = jerry_native_module_get (native_module, exp_val);
TEST_ASSERT (jerry_value_is_number (result) && jerry_value_as_number (result) == 3.5);
jerry_value_free (result);
result = jerry_native_module_get_export (native_module, other_exp_val);
result = jerry_native_module_get (native_module, other_exp_val);
TEST_ASSERT (jerry_value_is_string (result));
jerry_release_value (result);
jerry_value_free (result);
jerry_release_value (exp_val);
jerry_release_value (other_exp_val);
jerry_release_value (no_exp_val);
jerry_value_free (exp_val);
jerry_value_free (other_exp_val);
jerry_value_free (no_exp_val);
if (counter == 4)
{
++counter;
return jerry_create_error (JERRY_ERROR_COMMON, (const jerry_char_t *) "Ooops!");
return jerry_throw_sz (JERRY_ERROR_COMMON, "Ooops!");
}
return jerry_create_undefined ();
return jerry_undefined ();
} /* native_module_evaluate */
static jerry_value_t
@@ -213,16 +213,15 @@ resolve_callback4 (const jerry_value_t specifier, /**< module specifier */
++counter;
jerry_value_t exports[2] = { jerry_create_string ((const jerry_char_t *) "exp"),
jerry_create_string ((const jerry_char_t *) "other_exp") };
jerry_value_t exports[2] = { jerry_string_sz ("exp"), jerry_string_sz ("other_exp") };
jerry_value_t native_module = jerry_native_module_create (native_module_evaluate, exports, 2);
TEST_ASSERT (!jerry_value_is_error (native_module));
jerry_value_t native_module = jerry_native_module (native_module_evaluate, exports, 2);
TEST_ASSERT (!jerry_value_is_exception (native_module));
jerry_release_value (exports[0]);
jerry_release_value (exports[1]);
jerry_value_free (exports[0]);
jerry_value_free (exports[1]);
*((jerry_value_t *) user_p) = jerry_acquire_value (native_module);
*((jerry_value_t *) user_p) = jerry_value_copy (native_module);
return native_module;
} /* resolve_callback4 */
@@ -232,7 +231,7 @@ module_state_changed (jerry_module_state_t new_state, /**< new state of the modu
const jerry_value_t value, /**< value argument */
void *user_p) /**< user pointer */
{
TEST_ASSERT (jerry_module_get_state (module_val) == new_state);
TEST_ASSERT (jerry_module_state (module_val) == new_state);
TEST_ASSERT (module_val == module);
TEST_ASSERT (user_p == (void *) &counter);
@@ -250,14 +249,14 @@ module_state_changed (jerry_module_state_t new_state, /**< new state of the modu
case 2:
{
TEST_ASSERT (new_state == JERRY_MODULE_STATE_EVALUATED);
TEST_ASSERT (jerry_value_is_number (value) && jerry_get_number_value (value) == 33.5);
TEST_ASSERT (jerry_value_is_number (value) && jerry_value_as_number (value) == 33.5);
break;
}
default:
{
TEST_ASSERT (counter == 4);
TEST_ASSERT (new_state == JERRY_MODULE_STATE_ERROR);
TEST_ASSERT (jerry_value_is_number (value) && jerry_get_number_value (value) == -5.5);
TEST_ASSERT (jerry_value_is_number (value) && jerry_value_as_number (value) == -5.5);
break;
}
}
@@ -281,62 +280,62 @@ main (void)
{
jerry_init (JERRY_INIT_EMPTY);
if (!jerry_is_feature_enabled (JERRY_FEATURE_MODULE))
if (!jerry_feature_enabled (JERRY_FEATURE_MODULE))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Module is disabled!\n");
jerry_cleanup ();
return 0;
}
jerry_value_t number = jerry_create_number (5);
jerry_value_t object = jerry_create_object ();
jerry_value_t number = jerry_number (5);
jerry_value_t object = jerry_object ();
jerry_value_t result = jerry_module_link (number, resolve_callback1, NULL);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
result = jerry_module_link (object, resolve_callback1, NULL);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
module = create_module (1);
/* After an error, module must remain in unlinked mode. */
result = jerry_module_link (module, resolve_callback1, (void *) &module);
TEST_ASSERT (jerry_value_is_error (result));
TEST_ASSERT (jerry_value_is_exception (result));
TEST_ASSERT (counter == 1);
jerry_release_value (result);
jerry_value_free (result);
result = jerry_module_link (module, resolve_callback1, (void *) &module);
TEST_ASSERT (jerry_value_is_error (result));
TEST_ASSERT (jerry_value_is_exception (result));
TEST_ASSERT (counter == 2);
jerry_release_value (result);
jerry_value_free (result);
prev_module = module;
counter = 0;
terminate_with_error = true;
result = jerry_module_link (module, resolve_callback2, NULL);
TEST_ASSERT (jerry_value_is_error (result));
TEST_ASSERT (jerry_value_is_exception (result));
TEST_ASSERT (counter == 32);
jerry_release_value (result);
jerry_value_free (result);
/* The successfully resolved modules is kept around in unlinked state. */
jerry_gc (JERRY_GC_PRESSURE_HIGH);
jerry_heap_gc (JERRY_GC_PRESSURE_HIGH);
counter = 31;
terminate_with_error = false;
result = jerry_module_link (module, resolve_callback2, NULL);
TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
TEST_ASSERT (counter == 32);
jerry_release_value (result);
jerry_value_free (result);
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_LINKED);
TEST_ASSERT (jerry_module_get_number_of_requests (module) == 1);
result = jerry_module_get_request (module, 0);
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_LINKED);
jerry_release_value (result);
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_LINKED);
TEST_ASSERT (jerry_module_request_count (module) == 1);
result = jerry_module_request (module, 0);
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_LINKED);
jerry_value_free (result);
jerry_release_value (module);
jerry_value_free (module);
module = create_module (1);
@@ -346,10 +345,10 @@ main (void)
result = jerry_module_link (module, resolve_callback2, NULL);
TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
TEST_ASSERT (counter == 32);
jerry_release_value (result);
jerry_release_value (module);
jerry_value_free (result);
jerry_value_free (module);
TEST_ASSERT (jerry_module_get_state (number) == JERRY_MODULE_STATE_INVALID);
TEST_ASSERT (jerry_module_state (number) == JERRY_MODULE_STATE_INVALID);
jerry_parse_options_t module_parse_options;
module_parse_options.options = JERRY_PARSE_MODULE;
@@ -359,116 +358,116 @@ main (void)
"export * from '44_module.mjs'\n"
"import * as b from '36_module.mjs'\n");
module = jerry_parse (source1, sizeof (source1) - 1, &module_parse_options);
TEST_ASSERT (!jerry_value_is_error (module));
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_UNLINKED);
TEST_ASSERT (!jerry_value_is_exception (module));
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_UNLINKED);
TEST_ASSERT (jerry_module_get_number_of_requests (number) == 0);
TEST_ASSERT (jerry_module_get_number_of_requests (module) == 4);
TEST_ASSERT (jerry_module_request_count (number) == 0);
TEST_ASSERT (jerry_module_request_count (module) == 4);
result = jerry_module_get_request (object, 0);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
result = jerry_module_request (object, 0);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
result = jerry_module_get_request (module, 0);
result = jerry_module_request (module, 0);
compare_specifier (result, 16);
jerry_release_value (result);
jerry_value_free (result);
result = jerry_module_get_request (module, 1);
result = jerry_module_request (module, 1);
compare_specifier (result, 7);
jerry_release_value (result);
jerry_value_free (result);
result = jerry_module_get_request (module, 2);
result = jerry_module_request (module, 2);
compare_specifier (result, 44);
jerry_release_value (result);
jerry_value_free (result);
result = jerry_module_get_request (module, 3);
result = jerry_module_request (module, 3);
compare_specifier (result, 36);
jerry_release_value (result);
jerry_value_free (result);
result = jerry_module_get_request (module, 4);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
result = jerry_module_request (module, 4);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
jerry_release_value (module);
jerry_value_free (module);
result = jerry_module_get_namespace (number);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
result = jerry_module_namespace (number);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
jerry_char_t source2[] = TEST_STRING_LITERAL ("export let a = 6\n"
"export let b = 8.5\n");
module = jerry_parse (source2, sizeof (source2) - 1, &module_parse_options);
TEST_ASSERT (!jerry_value_is_error (module));
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_UNLINKED);
TEST_ASSERT (!jerry_value_is_exception (module));
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_UNLINKED);
result = jerry_module_link (module, resolve_callback3, NULL);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_LINKED);
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_LINKED);
result = jerry_module_evaluate (module);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_EVALUATED);
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_EVALUATED);
result = jerry_module_get_namespace (module);
result = jerry_module_namespace (module);
TEST_ASSERT (jerry_value_is_object (result));
compare_property (result, "a", 6);
compare_property (result, "b", 8.5);
jerry_release_value (result);
jerry_value_free (result);
jerry_release_value (module);
jerry_value_free (module);
module = jerry_native_module_create (NULL, &object, 1);
TEST_ASSERT (jerry_value_is_error (module));
jerry_release_value (module);
module = jerry_native_module (NULL, &object, 1);
TEST_ASSERT (jerry_value_is_exception (module));
jerry_value_free (module);
module = jerry_native_module_create (NULL, NULL, 0);
TEST_ASSERT (!jerry_value_is_error (module));
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_UNLINKED);
module = jerry_native_module (NULL, NULL, 0);
TEST_ASSERT (!jerry_value_is_exception (module));
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_UNLINKED);
result = jerry_native_module_get_export (object, number);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
result = jerry_native_module_get (object, number);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
result = jerry_native_module_set_export (module, number, number);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
result = jerry_native_module_set (module, number, number);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
jerry_release_value (module);
jerry_value_free (module);
/* Valid identifier. */
jerry_value_t export = jerry_create_string ((const jerry_char_t *) "\xed\xa0\x83\xed\xb2\x80");
jerry_value_t export = jerry_string_sz ("\xed\xa0\x83\xed\xb2\x80");
module = jerry_native_module_create (NULL, &export, 1);
TEST_ASSERT (!jerry_value_is_error (module));
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_UNLINKED);
module = jerry_native_module (NULL, &export, 1);
TEST_ASSERT (!jerry_value_is_exception (module));
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_UNLINKED);
result = jerry_module_link (module, NULL, NULL);
TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
result = jerry_module_evaluate (module);
TEST_ASSERT (jerry_value_is_undefined (result));
jerry_release_value (result);
jerry_value_free (result);
jerry_release_value (module);
jerry_release_value (export);
jerry_value_free (module);
jerry_value_free (export);
/* Invalid identifiers. */
export = jerry_create_string ((const jerry_char_t *) "a+");
module = jerry_native_module_create (NULL, &export, 1);
TEST_ASSERT (jerry_value_is_error (module));
jerry_release_value (module);
jerry_release_value (export);
export = jerry_string_sz ("a+");
module = jerry_native_module (NULL, &export, 1);
TEST_ASSERT (jerry_value_is_exception (module));
jerry_value_free (module);
jerry_value_free (export);
export = jerry_create_string ((const jerry_char_t *) "\xed\xa0\x80");
module = jerry_native_module_create (NULL, &export, 1);
TEST_ASSERT (jerry_value_is_error (module));
jerry_release_value (module);
jerry_release_value (export);
export = jerry_string_sz ("\xed\xa0\x80");
module = jerry_native_module (NULL, &export, 1);
TEST_ASSERT (jerry_value_is_exception (module));
jerry_value_free (module);
jerry_value_free (export);
counter = 0;
@@ -480,74 +479,74 @@ main (void)
"if (exp !== 3.5 || other !== 'str') { throw 'Assertion failed!' }\n"
"if (namespace.exp !== 3.5 || namespace.other_exp !== 'str') { throw 'Assertion failed!' }\n");
module = jerry_parse (source3, sizeof (source3) - 1, &module_parse_options);
TEST_ASSERT (!jerry_value_is_error (module));
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_UNLINKED);
TEST_ASSERT (!jerry_value_is_exception (module));
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_UNLINKED);
jerry_value_t native_module;
result = jerry_module_link (module, resolve_callback4, (void *) &native_module);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
TEST_ASSERT (counter == i * 2 + 1);
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_LINKED);
TEST_ASSERT (jerry_module_get_state (native_module) == JERRY_MODULE_STATE_LINKED);
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_LINKED);
TEST_ASSERT (jerry_module_state (native_module) == JERRY_MODULE_STATE_LINKED);
result = jerry_module_evaluate (module);
if (i == 0)
{
TEST_ASSERT (!jerry_value_is_error (result));
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_EVALUATED);
TEST_ASSERT (jerry_module_get_state (native_module) == JERRY_MODULE_STATE_EVALUATED);
TEST_ASSERT (!jerry_value_is_exception (result));
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_EVALUATED);
TEST_ASSERT (jerry_module_state (native_module) == JERRY_MODULE_STATE_EVALUATED);
TEST_ASSERT (counter == 2);
}
else
{
TEST_ASSERT (jerry_value_is_error (result));
TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_ERROR);
TEST_ASSERT (jerry_module_get_state (native_module) == JERRY_MODULE_STATE_ERROR);
TEST_ASSERT (jerry_value_is_exception (result));
TEST_ASSERT (jerry_module_state (module) == JERRY_MODULE_STATE_ERROR);
TEST_ASSERT (jerry_module_state (native_module) == JERRY_MODULE_STATE_ERROR);
TEST_ASSERT (counter == 5);
}
jerry_release_value (result);
jerry_release_value (module);
jerry_release_value (native_module);
jerry_value_free (result);
jerry_value_free (module);
jerry_value_free (native_module);
}
jerry_release_value (object);
jerry_release_value (number);
jerry_value_free (object);
jerry_value_free (number);
counter = 0;
jerry_module_set_state_changed_callback (module_state_changed, (void *) &counter);
jerry_module_on_state_changed (module_state_changed, (void *) &counter);
jerry_char_t source4[] = TEST_STRING_LITERAL ("33.5\n");
module = jerry_parse (source4, sizeof (source4) - 1, &module_parse_options);
result = jerry_module_link (module, NULL, NULL);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
result = jerry_module_evaluate (module);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
jerry_release_value (module);
jerry_value_free (module);
jerry_char_t source5[] = TEST_STRING_LITERAL ("throw -5.5\n");
module = jerry_parse (source5, sizeof (source5) - 1, &module_parse_options);
result = jerry_module_link (module, NULL, NULL);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
result = jerry_module_evaluate (module);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
jerry_release_value (module);
jerry_value_free (module);
jerry_module_set_state_changed_callback (NULL, NULL);
jerry_module_on_state_changed (NULL, NULL);
TEST_ASSERT (counter == 4);
@@ -555,8 +554,8 @@ main (void)
module = jerry_parse (source6, sizeof (source6) - 1, &module_parse_options);
result = jerry_module_link (module, resolve_callback5, NULL);
TEST_ASSERT (jerry_value_is_error (result) && jerry_get_error_type (result) == JERRY_ERROR_SYNTAX);
jerry_release_value (result);
TEST_ASSERT (jerry_value_is_exception (result) && jerry_error_type (result) == JERRY_ERROR_SYNTAX);
jerry_value_free (result);
jerry_cleanup ();
tests/unit-core/test-native-callback-nested.c
+11 -11
View File
@@ -22,12 +22,12 @@
static void
native_cb2 (void)
{
jerry_value_t array = jerry_create_array (100);
jerry_release_value (array);
jerry_value_t array = jerry_array (100);
jerry_value_free (array);
} /* native_cb2 */
static const jerry_object_native_info_t native_info2 = {
.free_cb = (jerry_object_native_free_callback_t) native_cb2,
.free_cb = (jerry_object_native_free_cb_t) native_cb2,
.number_of_references = 0,
.offset_of_references = 0,
};
@@ -35,15 +35,15 @@ static const jerry_object_native_info_t native_info2 = {
static void
native_cb (void)
{
jerry_value_t array = jerry_create_array (100);
jerry_value_t array = jerry_array (100);
jerry_set_object_native_pointer (array, NULL, &native_info2);
jerry_object_set_native_ptr (array, &native_info2, NULL);
jerry_release_value (array);
jerry_value_free (array);
} /* native_cb */
static const jerry_object_native_info_t native_info = {
.free_cb = (jerry_object_native_free_callback_t) native_cb,
.free_cb = (jerry_object_native_free_cb_t) native_cb,
.number_of_references = 0,
.offset_of_references = 0,
};
@@ -58,14 +58,14 @@ context_alloc_fn (size_t size, void *cb_data)
int
main (void)
{
jerry_context_t *ctx_p = jerry_create_context (1024, context_alloc_fn, NULL);
jerry_context_t *ctx_p = jerry_context_alloc (1024, context_alloc_fn, NULL);
jerry_port_default_set_current_context (ctx_p);
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t obj = jerry_create_object ();
jerry_value_t obj = jerry_object ();
jerry_set_object_native_pointer (obj, NULL, &native_info);
jerry_release_value (obj);
jerry_object_set_native_ptr (obj, &native_info, NULL);
jerry_value_free (obj);
jerry_cleanup ();
free (ctx_p);
tests/unit-core/test-native-instanceof.c
+17 -17
View File
@@ -26,26 +26,26 @@ external_function (const jerry_call_info_t *call_info_p, const jerry_value_t arg
(void) args_p;
(void) args_count;
return jerry_create_undefined ();
return jerry_undefined ();
} /* external_function */
static void
test_instanceof (jerry_value_t instanceof, jerry_value_t constructor)
{
jerry_value_t instance = jerry_construct_object (constructor, NULL, 0);
jerry_value_t instance = jerry_construct (constructor, NULL, 0);
jerry_value_t args[2] = { instance, constructor };
jerry_value_t undefined = jerry_create_undefined ();
jerry_value_t result = jerry_call_function (instanceof, undefined, args, 2);
jerry_release_value (undefined);
jerry_value_t undefined = jerry_undefined ();
jerry_value_t result = jerry_call (instanceof, undefined, args, 2);
jerry_value_free (undefined);
TEST_ASSERT (!jerry_value_is_error (result));
TEST_ASSERT (!jerry_value_is_exception (result));
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (instance);
jerry_release_value (result);
jerry_value_free (instance);
jerry_value_free (result);
} /* test_instanceof */
int
@@ -56,22 +56,22 @@ main (void)
jerry_value_t instanceof = jerry_eval ((jerry_char_t *) instanceof_source, sizeof (instanceof_source) - 1, true);
/* Test for a native-backed function. */
jerry_value_t constructor = jerry_create_external_function (external_function);
jerry_value_t constructor = jerry_function_external (external_function);
test_instanceof (instanceof, constructor);
jerry_release_value (constructor);
jerry_value_free (constructor);
/* Test for a JS constructor. */
jerry_value_t global = jerry_get_global_object ();
jerry_value_t object_name = jerry_create_string ((jerry_char_t *) "Object");
constructor = jerry_get_property (global, object_name);
jerry_release_value (object_name);
jerry_release_value (global);
jerry_value_t global = jerry_current_realm ();
jerry_value_t object_name = jerry_string_sz ("Object");
constructor = jerry_object_get (global, object_name);
jerry_value_free (object_name);
jerry_value_free (global);
test_instanceof (instanceof, constructor);
jerry_release_value (constructor);
jerry_value_free (constructor);
jerry_release_value (instanceof);
jerry_value_free (instanceof);
jerry_cleanup ();
tests/unit-core/test-native-pointer.c
+85 -85
View File
@@ -76,7 +76,7 @@ native_references_free_callback (void *native_p, /**< native pointer */
uint32_t check = refs_p->check_before;
jerry_native_pointer_release_references (native_p, info_p);
jerry_native_ptr_free (native_p, info_p);
TEST_ASSERT (jerry_value_is_undefined (refs_p->a));
TEST_ASSERT (jerry_value_is_undefined (refs_p->b));
@@ -104,7 +104,7 @@ init_references (test_references_t *refs_p, /**< native pointer */
refs_p->c = 3;
refs_p->check_after = check;
jerry_native_pointer_init_references ((void *) refs_p, &native_info_4);
jerry_native_ptr_init ((void *) refs_p, &native_info_4);
TEST_ASSERT (jerry_value_is_undefined (refs_p->a));
TEST_ASSERT (jerry_value_is_undefined (refs_p->b));
@@ -119,9 +119,9 @@ set_references (test_references_t *refs_p, /**< native pointer */
jerry_value_t value2, /**< second value to be set */
jerry_value_t value3) /**< third value to be set */
{
jerry_native_pointer_set_reference (&refs_p->a, value1);
jerry_native_pointer_set_reference (&refs_p->b, value2);
jerry_native_pointer_set_reference (&refs_p->c, value3);
jerry_native_ptr_set (&refs_p->a, value1);
jerry_native_ptr_set (&refs_p->b, value2);
jerry_native_ptr_set (&refs_p->c, value3);
TEST_ASSERT (jerry_value_is_object (value1) ? jerry_value_is_object (refs_p->a) : jerry_value_is_string (refs_p->a));
TEST_ASSERT (jerry_value_is_object (value2) ? jerry_value_is_object (refs_p->b) : jerry_value_is_string (refs_p->b));
@@ -133,8 +133,8 @@ check_native_info (jerry_value_t object_value, /**< object value */
const jerry_object_native_info_t *native_info_p, /**< native info */
void *expected_pointer_p) /**< expected pointer */
{
void *native_pointer_p;
TEST_ASSERT (jerry_get_object_native_pointer (object_value, &native_pointer_p, native_info_p));
TEST_ASSERT (jerry_object_has_native_ptr (object_value, native_info_p));
void *native_pointer_p = jerry_object_get_native_ptr (object_value, native_info_p);
TEST_ASSERT (native_pointer_p == expected_pointer_p);
} /* check_native_info */
@@ -144,189 +144,189 @@ main (void)
TEST_INIT ();
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t object_value = jerry_create_object ();
jerry_value_t object_value = jerry_object ();
jerry_set_object_native_pointer (object_value, global_p, &native_info_1);
jerry_set_object_native_pointer (object_value, NULL, &native_info_2);
jerry_object_set_native_ptr (object_value, &native_info_1, global_p);
jerry_object_set_native_ptr (object_value, &native_info_2, NULL);
check_native_info (object_value, &native_info_1, global_p);
check_native_info (object_value, &native_info_2, NULL);
jerry_release_value (object_value);
jerry_value_free (object_value);
jerry_gc (JERRY_GC_PRESSURE_HIGH);
jerry_heap_gc (JERRY_GC_PRESSURE_HIGH);
TEST_ASSERT (global_counter == 1);
global_counter = 0;
object_value = jerry_create_object ();
object_value = jerry_object ();
jerry_set_object_native_pointer (object_value, global_p, &native_info_1);
jerry_set_object_native_pointer (object_value, NULL, &native_info_2);
jerry_object_set_native_ptr (object_value, &native_info_1, global_p);
jerry_object_set_native_ptr (object_value, &native_info_2, NULL);
TEST_ASSERT (jerry_delete_object_native_pointer (object_value, &native_info_1));
TEST_ASSERT (jerry_object_delete_native_ptr (object_value, &native_info_1));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_1));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_1));
check_native_info (object_value, &native_info_2, NULL);
TEST_ASSERT (!jerry_delete_object_native_pointer (object_value, &native_info_1));
TEST_ASSERT (!jerry_object_delete_native_ptr (object_value, &native_info_1));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_1));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_1));
check_native_info (object_value, &native_info_2, NULL);
TEST_ASSERT (jerry_delete_object_native_pointer (object_value, &native_info_2));
TEST_ASSERT (jerry_object_delete_native_ptr (object_value, &native_info_2));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_1));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_2));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_1));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_2));
jerry_set_object_native_pointer (object_value, NULL, &native_info_1);
jerry_object_set_native_ptr (object_value, &native_info_1, NULL);
check_native_info (object_value, &native_info_1, NULL);
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_2));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_2));
jerry_set_object_native_pointer (object_value, global_p, &native_info_2);
jerry_object_set_native_ptr (object_value, &native_info_2, global_p);
check_native_info (object_value, &native_info_1, NULL);
check_native_info (object_value, &native_info_2, global_p);
jerry_set_object_native_pointer (object_value, global_p, &native_info_1);
jerry_object_set_native_ptr (object_value, &native_info_1, global_p);
check_native_info (object_value, &native_info_1, global_p);
check_native_info (object_value, &native_info_2, global_p);
TEST_ASSERT (jerry_delete_object_native_pointer (object_value, &native_info_1));
TEST_ASSERT (jerry_delete_object_native_pointer (object_value, &native_info_2));
TEST_ASSERT (jerry_object_delete_native_ptr (object_value, &native_info_1));
TEST_ASSERT (jerry_object_delete_native_ptr (object_value, &native_info_2));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_1));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_2));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_1));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_2));
jerry_set_object_native_pointer (object_value, global_p, &native_info_1);
jerry_set_object_native_pointer (object_value, NULL, &native_info_2);
jerry_set_object_native_pointer (object_value, global_p, &native_info_3);
jerry_object_set_native_ptr (object_value, &native_info_1, global_p);
jerry_object_set_native_ptr (object_value, &native_info_2, NULL);
jerry_object_set_native_ptr (object_value, &native_info_3, global_p);
check_native_info (object_value, &native_info_1, global_p);
check_native_info (object_value, &native_info_2, NULL);
check_native_info (object_value, &native_info_3, global_p);
TEST_ASSERT (jerry_delete_object_native_pointer (object_value, &native_info_1));
TEST_ASSERT (jerry_delete_object_native_pointer (object_value, &native_info_2));
TEST_ASSERT (jerry_delete_object_native_pointer (object_value, &native_info_3));
TEST_ASSERT (jerry_object_delete_native_ptr (object_value, &native_info_1));
TEST_ASSERT (jerry_object_delete_native_ptr (object_value, &native_info_2));
TEST_ASSERT (jerry_object_delete_native_ptr (object_value, &native_info_3));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_1));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_2));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_3));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_1));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_2));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_3));
jerry_set_object_native_pointer (object_value, NULL, &native_info_1);
jerry_set_object_native_pointer (object_value, global_p, &native_info_2);
jerry_set_object_native_pointer (object_value, NULL, &native_info_3);
jerry_object_set_native_ptr (object_value, &native_info_1, NULL);
jerry_object_set_native_ptr (object_value, &native_info_2, global_p);
jerry_object_set_native_ptr (object_value, &native_info_3, NULL);
check_native_info (object_value, &native_info_1, NULL);
check_native_info (object_value, &native_info_2, global_p);
check_native_info (object_value, &native_info_3, NULL);
/* Reversed delete order. */
TEST_ASSERT (jerry_delete_object_native_pointer (object_value, &native_info_3));
TEST_ASSERT (jerry_delete_object_native_pointer (object_value, &native_info_2));
TEST_ASSERT (jerry_delete_object_native_pointer (object_value, &native_info_1));
TEST_ASSERT (jerry_object_delete_native_ptr (object_value, &native_info_3));
TEST_ASSERT (jerry_object_delete_native_ptr (object_value, &native_info_2));
TEST_ASSERT (jerry_object_delete_native_ptr (object_value, &native_info_1));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_1));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_2));
TEST_ASSERT (!jerry_get_object_native_pointer (object_value, NULL, &native_info_3));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_1));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_2));
TEST_ASSERT (!jerry_object_has_native_ptr (object_value, &native_info_3));
/* Test value references */
jerry_value_t string1_value = jerry_create_string ((const jerry_char_t *) "String1");
jerry_value_t string2_value = jerry_create_string ((const jerry_char_t *) "String2");
jerry_value_t string1_value = jerry_string_sz ("String1");
jerry_value_t string2_value = jerry_string_sz ("String2");
jerry_value_t object1_value = jerry_create_object ();
jerry_value_t object2_value = jerry_create_object ();
jerry_value_t object1_value = jerry_object ();
jerry_value_t object2_value = jerry_object ();
init_references (&test_references1, 0x12345678);
init_references (&test_references2, 0x87654321);
jerry_set_object_native_pointer (object1_value, (void *) &test_references1, &native_info_4);
jerry_set_object_native_pointer (object2_value, (void *) &test_references2, &native_info_4);
jerry_object_set_native_ptr (object1_value, &native_info_4, (void *) &test_references1);
jerry_object_set_native_ptr (object2_value, &native_info_4, (void *) &test_references2);
/* Assign values (cross reference between object1 and object2). */
set_references (&test_references1, string1_value, object2_value, string2_value);
set_references (&test_references2, string2_value, object1_value, string1_value);
jerry_gc (JERRY_GC_PRESSURE_HIGH);
jerry_heap_gc (JERRY_GC_PRESSURE_HIGH);
/* Reassign values. */
set_references (&test_references1, object2_value, string2_value, string1_value);
set_references (&test_references2, object1_value, string1_value, string2_value);
jerry_gc (JERRY_GC_PRESSURE_HIGH);
jerry_heap_gc (JERRY_GC_PRESSURE_HIGH);
jerry_release_value (object1_value);
jerry_release_value (object2_value);
jerry_value_free (object1_value);
jerry_value_free (object2_value);
object1_value = jerry_create_object ();
object2_value = jerry_create_object ();
object1_value = jerry_object ();
object2_value = jerry_object ();
init_references (&test_references3, 0x12344321);
/* Assign the same native pointer to multiple objects. */
jerry_set_object_native_pointer (object1_value, (void *) &test_references3, &native_info_4);
jerry_set_object_native_pointer (object2_value, (void *) &test_references3, &native_info_4);
jerry_object_set_native_ptr (object1_value, &native_info_4, (void *) &test_references3);
jerry_object_set_native_ptr (object2_value, &native_info_4, (void *) &test_references3);
set_references (&test_references3, object1_value, object2_value, string1_value);
jerry_gc (JERRY_GC_PRESSURE_HIGH);
jerry_heap_gc (JERRY_GC_PRESSURE_HIGH);
init_references (&test_references4, 0x87655678);
/* Re-assign reference */
jerry_set_object_native_pointer (object1_value, (void *) &test_references4, &native_info_4);
jerry_object_set_native_ptr (object1_value, &native_info_4, (void *) &test_references4);
set_references (&test_references4, string1_value, string2_value, string1_value);
jerry_set_object_native_pointer (object1_value, NULL, &native_info_4);
jerry_object_set_native_ptr (object1_value, &native_info_4, NULL);
jerry_native_pointer_release_references ((void *) &test_references4, &native_info_4);
jerry_native_ptr_free ((void *) &test_references4, &native_info_4);
/* Calling jerry_native_pointer_init_references with test_references4 is optional here. */
/* Calling jerry_native_ptr_init with test_references4 is optional here. */
jerry_set_object_native_pointer (object1_value, (void *) &test_references4, &native_info_4);
jerry_object_set_native_ptr (object1_value, &native_info_4, (void *) &test_references4);
set_references (&test_references4, string2_value, string1_value, string2_value);
TEST_ASSERT (jerry_delete_object_native_pointer (object1_value, &native_info_4));
TEST_ASSERT (jerry_object_delete_native_ptr (object1_value, &native_info_4));
jerry_native_pointer_release_references ((void *) &test_references4, &native_info_4);
jerry_native_ptr_free ((void *) &test_references4, &native_info_4);
jerry_release_value (object1_value);
jerry_release_value (object2_value);
jerry_value_free (object1_value);
jerry_value_free (object2_value);
/* Delete references */
for (int i = 0; i < 3; i++)
{
object1_value = jerry_create_object ();
object1_value = jerry_object ();
jerry_set_object_native_pointer (object1_value, global_p, NULL);
jerry_set_object_native_pointer (object1_value, (void *) &test_references4, &native_info_4);
jerry_set_object_native_pointer (object1_value, global_p, &native_info_2);
jerry_object_set_native_ptr (object1_value, NULL, global_p);
jerry_object_set_native_ptr (object1_value, &native_info_4, (void *) &test_references4);
jerry_object_set_native_ptr (object1_value, &native_info_2, global_p);
set_references (&test_references4, string1_value, string2_value, object1_value);
jerry_gc (JERRY_GC_PRESSURE_HIGH);
jerry_heap_gc (JERRY_GC_PRESSURE_HIGH);
if (i == 1)
{
TEST_ASSERT (jerry_delete_object_native_pointer (object1_value, NULL));
TEST_ASSERT (jerry_object_delete_native_ptr (object1_value, NULL));
}
else if (i == 2)
{
TEST_ASSERT (jerry_delete_object_native_pointer (object1_value, &native_info_2));
TEST_ASSERT (jerry_object_delete_native_ptr (object1_value, &native_info_2));
}
TEST_ASSERT (jerry_delete_object_native_pointer (object1_value, &native_info_4));
jerry_native_pointer_release_references ((void *) &test_references4, &native_info_4);
jerry_release_value (object1_value);
TEST_ASSERT (jerry_object_delete_native_ptr (object1_value, &native_info_4));
jerry_native_ptr_free ((void *) &test_references4, &native_info_4);
jerry_value_free (object1_value);
}
jerry_release_value (string1_value);
jerry_release_value (string2_value);
jerry_value_free (string1_value);
jerry_value_free (string2_value);
jerry_release_value (object_value);
jerry_value_free (object_value);
jerry_cleanup ();
tests/unit-core/test-newtarget.c
+42 -42
View File
@@ -26,16 +26,16 @@ static jerry_value_t
register_js_function (const char *name_p, /**< name of the function */
jerry_external_handler_t handler_p) /**< function callback */
{
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t function_val = jerry_create_external_function (handler_p);
jerry_value_t function_name_val = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t result_val = jerry_set_property (global_obj_val, function_name_val, function_val);
jerry_value_t function_val = jerry_function_external (handler_p);
jerry_value_t function_name_val = jerry_string_sz (name_p);
jerry_value_t result_val = jerry_object_set (global_obj_val, function_name_val, function_val);
jerry_release_value (function_name_val);
jerry_release_value (global_obj_val);
jerry_value_free (function_name_val);
jerry_value_free (global_obj_val);
jerry_release_value (result_val);
jerry_value_free (result_val);
return function_val;
} /* register_js_function */
@@ -59,7 +59,7 @@ construct_handler (const jerry_call_info_t *call_info_p, /**< call information *
TEST_ASSERT (0 && "Invalid arguments for demo method");
}
int test_id = (int) jerry_get_number_value (args_p[0]);
int test_id = (int) jerry_value_as_number (args_p[0]);
switch (test_id)
{
@@ -87,11 +87,11 @@ construct_handler (const jerry_call_info_t *call_info_p, /**< call information *
TEST_ASSERT (target == call_info_p->function);
/* Calling a function should hide the old "new.target". */
jerry_value_t sub_arg = jerry_create_number (TEST_ID_SIMPLE_CALL);
jerry_value_t sub_arg = jerry_number (TEST_ID_SIMPLE_CALL);
jerry_value_t func_call_result;
func_call_result = jerry_call_function (call_info_p->function, call_info_p->this_value, &sub_arg, 1);
TEST_ASSERT (!jerry_value_is_error (func_call_result));
func_call_result = jerry_call (call_info_p->function, call_info_p->this_value, &sub_arg, 1);
TEST_ASSERT (!jerry_value_is_exception (func_call_result));
TEST_ASSERT (jerry_value_is_undefined (func_call_result));
break;
}
@@ -103,14 +103,14 @@ construct_handler (const jerry_call_info_t *call_info_p, /**< call information *
}
}
return jerry_create_undefined ();
return jerry_undefined ();
} /* construct_handler */
int
main (void)
{
/* Test JERRY_FEATURE_SYMBOL feature as it is a must-have in ES.next */
if (!jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
if (!jerry_feature_enabled (JERRY_FEATURE_SYMBOL))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Skipping test, ES.next support is disabled.\n");
return 0;
@@ -121,57 +121,57 @@ main (void)
jerry_value_t demo_func = register_js_function ("Demo", construct_handler);
{
jerry_value_t test_arg = jerry_create_number (TEST_ID_SIMPLE_CONSTRUCT);
jerry_value_t constructed = jerry_construct_object (demo_func, &test_arg, 1);
TEST_ASSERT (!jerry_value_is_error (constructed));
jerry_value_t test_arg = jerry_number (TEST_ID_SIMPLE_CONSTRUCT);
jerry_value_t constructed = jerry_construct (demo_func, &test_arg, 1);
TEST_ASSERT (!jerry_value_is_exception (constructed));
TEST_ASSERT (jerry_value_is_object (constructed));
jerry_release_value (test_arg);
jerry_release_value (constructed);
jerry_value_free (test_arg);
jerry_value_free (constructed);
}
{
jerry_value_t test_arg = jerry_create_number (TEST_ID_SIMPLE_CALL);
jerry_value_t this_arg = jerry_create_undefined ();
jerry_value_t constructed = jerry_call_function (demo_func, this_arg, &test_arg, 1);
jerry_value_t test_arg = jerry_number (TEST_ID_SIMPLE_CALL);
jerry_value_t this_arg = jerry_undefined ();
jerry_value_t constructed = jerry_call (demo_func, this_arg, &test_arg, 1);
TEST_ASSERT (jerry_value_is_undefined (constructed));
jerry_release_value (constructed);
jerry_release_value (constructed);
jerry_release_value (test_arg);
jerry_value_free (constructed);
jerry_value_free (constructed);
jerry_value_free (test_arg);
}
{
jerry_value_t test_arg = jerry_create_number (TEST_ID_CONSTRUCT_AND_CALL_SUB);
jerry_value_t constructed = jerry_construct_object (demo_func, &test_arg, 1);
TEST_ASSERT (!jerry_value_is_error (constructed));
jerry_value_t test_arg = jerry_number (TEST_ID_CONSTRUCT_AND_CALL_SUB);
jerry_value_t constructed = jerry_construct (demo_func, &test_arg, 1);
TEST_ASSERT (!jerry_value_is_exception (constructed));
TEST_ASSERT (jerry_value_is_object (constructed));
jerry_release_value (test_arg);
jerry_release_value (constructed);
jerry_value_free (test_arg);
jerry_value_free (constructed);
}
{
static const jerry_char_t test_source[] = TEST_STRING_LITERAL ("new Demo (1)");
jerry_value_t parsed_code_val = jerry_parse (test_source, sizeof (test_source) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (!jerry_value_is_exception (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_value_free (res);
jerry_value_free (parsed_code_val);
}
{
static const jerry_char_t test_source[] = TEST_STRING_LITERAL ("Demo (2)");
jerry_value_t parsed_code_val = jerry_parse (test_source, sizeof (test_source) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (!jerry_value_is_exception (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_value_free (res);
jerry_value_free (parsed_code_val);
}
{
@@ -181,16 +181,16 @@ main (void)
"new base(3);");
jerry_value_t parsed_code_val = jerry_parse (test_source, sizeof (test_source) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (!jerry_value_is_exception (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_value_free (res);
jerry_value_free (parsed_code_val);
}
jerry_release_value (demo_func);
jerry_value_free (demo_func);
jerry_cleanup ();
return 0;
} /* main */
tests/unit-core/test-number-converter.c
+11 -11
View File
@@ -21,30 +21,30 @@
static void
test_to_uint32 (double input, uint32_t test_number)
{
jerry_value_t number_val = jerry_create_number (input);
jerry_value_t number_val = jerry_number (input);
uint32_t uint_number = jerry_value_as_uint32 (number_val);
TEST_ASSERT (uint_number == test_number);
jerry_release_value (number_val);
jerry_value_free (number_val);
} /* test_to_uint32 */
// basic toInt32 tester method
static void
test_to_int32 (double input, int32_t test_number)
{
jerry_value_t number_val = jerry_create_number (input);
jerry_value_t number_val = jerry_number (input);
int32_t int_number = jerry_value_as_int32 (number_val);
TEST_ASSERT (int_number == test_number);
jerry_release_value (number_val);
jerry_value_free (number_val);
} /* test_to_int32 */
// basic toInteger tester method
static void
test_to_interger (double input, double test_number)
{
jerry_value_t number_val = jerry_create_number (input);
jerry_value_t number_val = jerry_number (input);
double double_number = jerry_value_as_integer (number_val);
TEST_ASSERT (double_number == test_number);
jerry_release_value (number_val);
jerry_value_free (number_val);
} /* test_to_interger */
int
@@ -115,21 +115,21 @@ main (void)
test_to_interger (-4294967297, -4294967297);
// few test-cases which return with error
jerry_value_t error_val = jerry_create_error (JERRY_ERROR_TYPE, (const jerry_char_t *) "error");
jerry_value_t error_val = jerry_throw_sz (JERRY_ERROR_TYPE, "error");
double number = jerry_value_as_integer (error_val);
jerry_release_value (error_val);
jerry_value_free (error_val);
TEST_ASSERT (number == 0);
error_val = jerry_create_symbol (error_val);
error_val = jerry_symbol_with_description (error_val);
number = jerry_value_as_integer (error_val);
TEST_ASSERT (number == 0);
jerry_release_value (error_val);
jerry_value_free (error_val);
error_val =
jerry_eval ((const jerry_char_t *) "({ valueOf() { throw new TypeError('foo')}})", 44, JERRY_PARSE_NO_OPTS);
number = jerry_value_as_integer (error_val);
TEST_ASSERT (number == 0);
jerry_release_value (error_val);
jerry_value_free (error_val);
jerry_cleanup ();
return 0;
tests/unit-core/test-objects-foreach.c
+61 -61
View File
@@ -32,14 +32,14 @@ count_objects (jerry_value_t object, void *user_arg)
static void
test_container (void)
{
jerry_value_t global = jerry_get_global_object ();
jerry_value_t map_str = jerry_create_string ((const jerry_char_t *) "Map");
jerry_value_t map_result = jerry_get_property (global, map_str);
jerry_type_t type = jerry_value_get_type (map_result);
jerry_value_t global = jerry_current_realm ();
jerry_value_t map_str = jerry_string_sz ("Map");
jerry_value_t map_result = jerry_object_get (global, map_str);
jerry_type_t type = jerry_value_type (map_result);
jerry_release_value (map_result);
jerry_release_value (map_str);
jerry_release_value (global);
jerry_value_free (map_result);
jerry_value_free (map_str);
jerry_value_free (global);
/* If there is no Map function this is not an es.next profile build, skip this test case. */
if (type != JERRY_TYPE_FUNCTION)
@@ -53,8 +53,8 @@ test_container (void)
const char array_str[] = "var DEMO = [[1, 2], [3, 4]]; DEMO";
jerry_value_t array = jerry_eval ((const jerry_char_t *) array_str, sizeof (array_str) - 1, 0);
TEST_ASSERT (jerry_value_is_object (array));
TEST_ASSERT (!jerry_value_is_error (array));
jerry_release_value (array);
TEST_ASSERT (!jerry_value_is_exception (array));
jerry_value_free (array);
}
const char eval_str[] = "new Map (DEMO)";
@@ -62,73 +62,73 @@ test_container (void)
/* Make sure that the Map and it's prototype object/function is initialized. */
jerry_value_t result = jerry_eval ((const jerry_char_t *) eval_str, sizeof (eval_str) - 1, 0);
TEST_ASSERT (jerry_value_is_object (result));
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
}
/* Do a bit of cleaning to clear up old objects. */
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
/* Get the number of iterable objects. */
int start_count = 0;
jerry_objects_foreach (count_objects, &start_count);
jerry_foreach_live_object (count_objects, &start_count);
/* Create another map. */
jerry_value_t result = jerry_eval ((const jerry_char_t *) eval_str, sizeof (eval_str) - 1, 0);
/* Remove any old/unused objects. */
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
/* Get the current number of objects. */
int end_count = 0;
jerry_objects_foreach (count_objects, &end_count);
jerry_foreach_live_object (count_objects, &end_count);
/* As only one Map was created the number of available iterable objects should be incremented only by one. */
TEST_ASSERT (end_count > start_count);
TEST_ASSERT ((end_count - start_count) == 1);
jerry_release_value (result);
jerry_value_free (result);
} /* test_container */
static void
test_internal_prop (void)
{
/* Make sure that the object is initialized in the engine. */
jerry_value_t object_dummy = jerry_create_object ();
jerry_value_t object_dummy = jerry_object ();
/* Get the number of iterable objects. */
int before_object_count = 0;
jerry_objects_foreach (count_objects, &before_object_count);
jerry_foreach_live_object (count_objects, &before_object_count);
jerry_value_t object = jerry_create_object ();
jerry_value_t object = jerry_object ();
/* After creating the object, the number of objects is incremented by one. */
int after_object_count = 0;
{
jerry_objects_foreach (count_objects, &after_object_count);
jerry_foreach_live_object (count_objects, &after_object_count);
TEST_ASSERT (after_object_count > before_object_count);
TEST_ASSERT ((after_object_count - before_object_count) == 1);
}
jerry_value_t internal_prop_name = jerry_create_string ((const jerry_char_t *) "hidden_foo");
jerry_value_t internal_prop_object = jerry_create_object ();
bool internal_result = jerry_set_internal_property (object, internal_prop_name, internal_prop_object);
jerry_value_t internal_prop_name = jerry_string_sz ("hidden_foo");
jerry_value_t internal_prop_object = jerry_object ();
bool internal_result = jerry_object_set_internal (object, internal_prop_name, internal_prop_object);
TEST_ASSERT (internal_result == true);
jerry_release_value (internal_prop_name);
jerry_release_value (internal_prop_object);
jerry_value_free (internal_prop_name);
jerry_value_free (internal_prop_object);
/* After adding an internal property object, the number of object is incremented by one. */
{
int after_internal_count = 0;
jerry_objects_foreach (count_objects, &after_internal_count);
jerry_foreach_live_object (count_objects, &after_internal_count);
TEST_ASSERT (after_internal_count > after_object_count);
TEST_ASSERT ((after_internal_count - after_object_count) == 1);
}
jerry_release_value (object);
jerry_release_value (object_dummy);
jerry_value_free (object);
jerry_value_free (object_dummy);
} /* test_internal_prop */
static int test_data = 1;
@@ -154,7 +154,7 @@ find_test_object_by_data (const jerry_value_t candidate, void *object_data_p, vo
{
if (object_data_p == &test_data)
{
*((jerry_value_t *) context_p) = jerry_acquire_value (candidate);
*((jerry_value_t *) context_p) = jerry_value_copy (candidate);
return false;
}
return true;
@@ -164,17 +164,17 @@ static bool
find_test_object_by_property (const jerry_value_t candidate, void *context_p)
{
jerry_value_t *args_p = (jerry_value_t *) context_p;
jerry_value_t result = jerry_has_property (candidate, args_p[0]);
jerry_value_t result = jerry_object_has (candidate, args_p[0]);
bool has_property = (!jerry_value_is_error (result) && jerry_value_is_true (result));
bool has_property = (!jerry_value_is_exception (result) && jerry_value_is_true (result));
/* If the object has the desired property, store a new reference to it in args_p[1]. */
if (has_property)
{
args_p[1] = jerry_acquire_value (candidate);
args_p[1] = jerry_value_copy (candidate);
}
jerry_release_value (result);
jerry_value_free (result);
/* Stop iterating if we've found our object. */
return !has_property;
@@ -190,64 +190,64 @@ main (void)
/* Render strict-equal as a function. */
jerry_value_t parse_result = jerry_parse (strict_equal_source, sizeof (strict_equal_source) - 1, &parse_options);
TEST_ASSERT (!jerry_value_is_error (parse_result));
TEST_ASSERT (!jerry_value_is_exception (parse_result));
jerry_value_t strict_equal = jerry_run (parse_result);
TEST_ASSERT (!jerry_value_is_error (strict_equal));
jerry_release_value (parse_result);
TEST_ASSERT (!jerry_value_is_exception (strict_equal));
jerry_value_free (parse_result);
/* Create an object and associate some native data with it. */
jerry_value_t object = jerry_create_object ();
jerry_set_object_native_pointer (object, &test_data, &test_info);
jerry_value_t object = jerry_object ();
jerry_object_set_native_ptr (object, &test_info, &test_data);
/* Retrieve the object by its native pointer. */
jerry_value_t found_object;
TEST_ASSERT (jerry_objects_foreach_by_native_info (&test_info, find_test_object_by_data, &found_object));
TEST_ASSERT (jerry_foreach_live_object_with_info (&test_info, find_test_object_by_data, &found_object));
jerry_value_t args[2] = { object, found_object };
/* Assert that the correct object was retrieved. */
jerry_value_t undefined = jerry_create_undefined ();
jerry_value_t strict_equal_result = jerry_call_function (strict_equal, undefined, args, 2);
jerry_value_t undefined = jerry_undefined ();
jerry_value_t strict_equal_result = jerry_call (strict_equal, undefined, args, 2);
TEST_ASSERT (jerry_value_is_boolean (strict_equal_result) && jerry_value_is_true (strict_equal_result));
jerry_release_value (strict_equal_result);
jerry_release_value (found_object);
jerry_release_value (object);
jerry_value_free (strict_equal_result);
jerry_value_free (found_object);
jerry_value_free (object);
/* Collect garbage. */
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
/* Attempt to retrieve the object by its native pointer again. */
TEST_ASSERT (!jerry_objects_foreach_by_native_info (&test_info, find_test_object_by_data, &found_object));
TEST_ASSERT (!jerry_foreach_live_object_with_info (&test_info, find_test_object_by_data, &found_object));
/* Create an object and set a property on it. */
object = jerry_create_object ();
jerry_value_t property_name = jerry_create_string ((jerry_char_t *) "xyzzy");
jerry_value_t property_value = jerry_create_number (42);
jerry_release_value (jerry_set_property (object, property_name, property_value));
jerry_release_value (property_value);
object = jerry_object ();
jerry_value_t property_name = jerry_string_sz ("xyzzy");
jerry_value_t property_value = jerry_number (42);
jerry_value_free (jerry_object_set (object, property_name, property_value));
jerry_value_free (property_value);
/* Retrieve the object by the presence of its property, placing it at args[1]. */
args[0] = property_name;
TEST_ASSERT (jerry_objects_foreach (find_test_object_by_property, args));
TEST_ASSERT (jerry_foreach_live_object (find_test_object_by_property, args));
/* Assert that the right object was retrieved and release both the original reference to it and the retrieved one. */
args[0] = object;
strict_equal_result = jerry_call_function (strict_equal, undefined, args, 2);
strict_equal_result = jerry_call (strict_equal, undefined, args, 2);
TEST_ASSERT (jerry_value_is_boolean (strict_equal_result) && jerry_value_is_true (strict_equal_result));
jerry_release_value (strict_equal_result);
jerry_release_value (args[0]);
jerry_release_value (args[1]);
jerry_value_free (strict_equal_result);
jerry_value_free (args[0]);
jerry_value_free (args[1]);
/* Collect garbage. */
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
/* Attempt to retrieve the object by the presence of its property again. */
args[0] = property_name;
TEST_ASSERT (!jerry_objects_foreach (find_test_object_by_property, args));
TEST_ASSERT (!jerry_foreach_live_object (find_test_object_by_property, args));
jerry_release_value (property_name);
jerry_release_value (undefined);
jerry_release_value (strict_equal);
jerry_value_free (property_name);
jerry_value_free (undefined);
jerry_value_free (strict_equal);
test_container ();
test_internal_prop ();
tests/unit-core/test-promise-callback.c
+10 -10
View File
@@ -108,12 +108,12 @@ run_eval (const uint8_t *event_list_p, /**< event list */
jerry_value_t result = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), 0);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
result = jerry_run_all_enqueued_jobs ();
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
result = jerry_run_jobs ();
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
TEST_ASSERT (*next_event_p == UINT8_MAX);
} /* run_eval */
@@ -123,14 +123,14 @@ main (void)
{
TEST_INIT ();
if (!jerry_is_feature_enabled (JERRY_FEATURE_PROMISE))
if (!jerry_feature_enabled (JERRY_FEATURE_PROMISE))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Promise is disabled!\n");
return 0;
}
/* The test system enables this feature when Promises are enabled. */
TEST_ASSERT (jerry_is_feature_enabled (JERRY_FEATURE_PROMISE_CALLBACK));
TEST_ASSERT (jerry_feature_enabled (JERRY_FEATURE_PROMISE_CALLBACK));
jerry_init (JERRY_INIT_EMPTY);
@@ -139,7 +139,7 @@ main (void)
| JERRY_PROMISE_EVENT_FILTER_ERROR | JERRY_PROMISE_EVENT_FILTER_REACTION_JOB
| JERRY_PROMISE_EVENT_FILTER_ASYNC_MAIN | JERRY_PROMISE_EVENT_FILTER_ASYNC_REACTION_JOB);
jerry_promise_set_callback (filters, promise_callback, (void *) &user);
jerry_promise_on_event (filters, promise_callback, (void *) &user);
/* Test promise creation. */
static uint8_t events1[] = { C, C, C, E };
@@ -341,7 +341,7 @@ main (void)
"p.then(() => {}).catch(() => {})\n");
/* Test disabled filters. */
jerry_promise_set_callback (JERRY_PROMISE_EVENT_FILTER_DISABLE, promise_callback, (void *) &user);
jerry_promise_on_event (JERRY_PROMISE_EVENT_FILTER_DISABLE, promise_callback, (void *) &user);
static uint8_t events24[] = { E };
@@ -352,7 +352,7 @@ main (void)
/* Test filtered events. */
filters = JERRY_PROMISE_EVENT_FILTER_REACTION_JOB | JERRY_PROMISE_EVENT_FILTER_ASYNC_REACTION_JOB;
jerry_promise_set_callback (filters, promise_callback, (void *) &user);
jerry_promise_on_event (filters, promise_callback, (void *) &user);
static uint8_t events25[] = { BR, AR, BRS, ARS, E };
tests/unit-core/test-promise.c
+33 -33
View File
@@ -31,8 +31,8 @@ static const jerry_char_t test_source[] = TEST_STRING_LITERAL ("var p1 = create_
static int count_in_assert = 0;
static jerry_value_t my_promise1;
static jerry_value_t my_promise2;
static const jerry_char_t s1[] = "resolved";
static const jerry_char_t s2[] = "rejected";
static const char s1[] = "resolved";
static const char s2[] = "rejected";
static jerry_value_t
create_promise1_handler (const jerry_call_info_t *call_info_p, /**< call information */
@@ -43,8 +43,8 @@ create_promise1_handler (const jerry_call_info_t *call_info_p, /**< call informa
JERRY_UNUSED (args_p);
JERRY_UNUSED (args_cnt);
jerry_value_t ret = jerry_create_promise ();
my_promise1 = jerry_acquire_value (ret);
jerry_value_t ret = jerry_promise ();
my_promise1 = jerry_value_copy (ret);
return ret;
} /* create_promise1_handler */
@@ -58,8 +58,8 @@ create_promise2_handler (const jerry_call_info_t *call_info_p, /**< call informa
JERRY_UNUSED (args_p);
JERRY_UNUSED (args_cnt);
jerry_value_t ret = jerry_create_promise ();
my_promise2 = jerry_acquire_value (ret);
jerry_value_t ret = jerry_promise ();
my_promise2 = jerry_value_copy (ret);
return ret;
} /* create_promise2_handler */
@@ -75,7 +75,7 @@ assert_handler (const jerry_call_info_t *call_info_p, /**< call information */
if (args_cnt == 1 && jerry_value_is_true (args_p[0]))
{
return jerry_create_boolean (true);
return jerry_boolean (true);
}
else
{
@@ -90,17 +90,17 @@ static void
register_js_function (const char *name_p, /**< name of the function */
jerry_external_handler_t handler_p) /**< function callback */
{
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t function_val = jerry_create_external_function (handler_p);
jerry_value_t function_name_val = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t result_val = jerry_set_property (global_obj_val, function_name_val, function_val);
jerry_value_t function_val = jerry_function_external (handler_p);
jerry_value_t function_name_val = jerry_string_sz (name_p);
jerry_value_t result_val = jerry_object_set (global_obj_val, function_name_val, function_val);
jerry_release_value (function_name_val);
jerry_release_value (function_val);
jerry_release_value (global_obj_val);
jerry_value_free (function_name_val);
jerry_value_free (function_val);
jerry_value_free (global_obj_val);
jerry_release_value (result_val);
jerry_value_free (result_val);
} /* register_js_function */
int
@@ -108,7 +108,7 @@ main (void)
{
jerry_init (JERRY_INIT_EMPTY);
if (!jerry_is_feature_enabled (JERRY_FEATURE_PROMISE))
if (!jerry_feature_enabled (JERRY_FEATURE_PROMISE))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Promise is disabled!\n");
jerry_cleanup ();
@@ -120,41 +120,41 @@ main (void)
register_js_function ("assert", assert_handler);
jerry_value_t parsed_code_val = jerry_parse (test_source, sizeof (test_source) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (!jerry_value_is_exception (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_value_free (res);
jerry_value_free (parsed_code_val);
/* Test jerry_create_promise and jerry_value_is_promise. */
/* Test jerry_promise and jerry_value_is_promise. */
TEST_ASSERT (jerry_value_is_promise (my_promise1));
TEST_ASSERT (jerry_value_is_promise (my_promise2));
TEST_ASSERT (count_in_assert == 0);
/* Test jerry_resolve_or_reject_promise. */
jerry_value_t str_resolve = jerry_create_string (s1);
jerry_value_t str_reject = jerry_create_string (s2);
jerry_value_t str_resolve = jerry_string_sz (s1);
jerry_value_t str_reject = jerry_string_sz (s2);
jerry_resolve_or_reject_promise (my_promise1, str_resolve, true);
jerry_resolve_or_reject_promise (my_promise2, str_reject, false);
jerry_promise_resolve (my_promise1, str_resolve);
jerry_promise_reject (my_promise2, str_reject);
/* The resolve/reject function should be invalid after the promise has the result. */
jerry_resolve_or_reject_promise (my_promise2, str_resolve, true);
jerry_resolve_or_reject_promise (my_promise1, str_reject, false);
jerry_promise_resolve (my_promise2, str_resolve);
jerry_promise_reject (my_promise1, str_reject);
/* Run the jobqueue. */
res = jerry_run_all_enqueued_jobs ();
res = jerry_run_jobs ();
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (count_in_assert == 2);
jerry_release_value (my_promise1);
jerry_release_value (my_promise2);
jerry_release_value (str_resolve);
jerry_release_value (str_reject);
jerry_value_free (my_promise1);
jerry_value_free (my_promise2);
jerry_value_free (str_resolve);
jerry_value_free (str_reject);
jerry_cleanup ();
tests/unit-core/test-proxy.c
+86 -86
View File
@@ -71,14 +71,14 @@ handler_get (const jerry_call_info_t *call_info_p, /**< call information */
const char expected[] = "value";
char buffer[10];
jerry_size_t copied = jerry_string_to_char_buffer (args_p[1], (jerry_char_t *) buffer, 10);
jerry_size_t copied = jerry_string_to_buffer (args_p[1], JERRY_ENCODING_CESU8, (jerry_char_t *) buffer, 10);
TEST_ASSERT (copied == 5);
TEST_ASSERT (strncmp (expected, buffer, 5) == 0);
demo_value++;
return jerry_create_number (demo_value);
return jerry_number (demo_value);
} /* handler_get */
static jerry_value_t
@@ -98,15 +98,15 @@ handler_set (const jerry_call_info_t *call_info_p, /**< call information */
const char expected[] = "value";
char buffer[10];
jerry_size_t copied = jerry_string_to_char_buffer (args_p[1], (jerry_char_t *) buffer, 10);
jerry_size_t copied = jerry_string_to_buffer (args_p[1], JERRY_ENCODING_CESU8, (jerry_char_t *) buffer, 10);
TEST_ASSERT (copied == 5);
TEST_ASSERT (strncmp (expected, buffer, 5) == 0);
TEST_ASSERT (jerry_value_is_number (args_p[2]));
demo_value = (int) jerry_get_number_value (args_p[2]);
demo_value = (int) jerry_value_as_number (args_p[2]);
return jerry_create_number (demo_value);
return jerry_number (demo_value);
} /* handler_set */
static void
@@ -114,23 +114,23 @@ set_property (jerry_value_t target, /**< target object */
const char *name_p, /**< name of the property */
jerry_value_t value) /**< value of the property */
{
jerry_value_t name_val = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t result_val = jerry_set_property (target, name_val, value);
jerry_value_t name_val = jerry_string_sz (name_p);
jerry_value_t result_val = jerry_object_set (target, name_val, value);
TEST_ASSERT (jerry_value_is_boolean (result_val));
TEST_ASSERT (jerry_value_is_true (result_val));
jerry_release_value (name_val);
jerry_value_free (name_val);
} /* set_property */
static jerry_value_t
get_property (jerry_value_t target, /**< target object */
const char *name_p) /**< name of the property */
{
jerry_value_t name_val = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t result_val = jerry_get_property (target, name_val);
jerry_value_t name_val = jerry_string_sz (name_p);
jerry_value_t result_val = jerry_object_get (target, name_val);
TEST_ASSERT (!jerry_value_is_error (result_val));
jerry_release_value (name_val);
TEST_ASSERT (!jerry_value_is_exception (result_val));
jerry_value_free (name_val);
return result_val;
} /* get_property */
@@ -139,9 +139,9 @@ set_function (jerry_value_t target, /**< target object */
const char *name_p, /**< name of the function */
jerry_external_handler_t handler_p) /**< function callback */
{
jerry_value_t function_val = jerry_create_external_function (handler_p);
jerry_value_t function_val = jerry_function_external (handler_p);
set_property (target, name_p, function_val);
jerry_release_value (function_val);
jerry_value_free (function_val);
} /* set_function */
struct test_data
@@ -178,12 +178,12 @@ proxy_native_handler_get (const jerry_call_info_t *call_info_p, /**< call inform
TEST_ASSERT (jerry_value_is_proxy (receiver));
/* Check if proxy has the native ptr. */
struct test_data *native_p;
bool has_p = jerry_get_object_native_pointer (receiver, (void *) &native_p, &proxy_native_info);
TEST_ASSERT (has_p == true);
TEST_ASSERT (jerry_object_has_native_ptr (receiver, &proxy_native_info));
struct test_data *native_p = jerry_object_get_native_ptr (receiver, &proxy_native_info);
TEST_ASSERT (native_p != NULL);
native_p->value <<= 1;
return jerry_create_number (native_p->value);
return jerry_number (native_p->value);
} /* proxy_native_handler_get */
/**
@@ -192,30 +192,30 @@ proxy_native_handler_get (const jerry_call_info_t *call_info_p, /**< call inform
static void
test_proxy_native (void)
{
jerry_value_t handler = jerry_create_object ();
jerry_value_t handler = jerry_object ();
set_function (handler, "get", proxy_native_handler_get);
jerry_value_t target = jerry_create_object ();
jerry_value_t proxy = jerry_create_proxy (target, handler);
jerry_value_t target = jerry_object ();
jerry_value_t proxy = jerry_proxy (target, handler);
struct test_data *data = (struct test_data *) malloc (sizeof (struct test_data));
data->value = 2;
jerry_set_object_native_pointer (proxy, data, &proxy_native_info);
jerry_object_set_native_ptr (proxy, &proxy_native_info, data);
/* Call: proxy[10] */
jerry_value_t result_for_10 = jerry_get_property_by_index (proxy, 10);
jerry_value_t result_for_10 = jerry_object_get_index (proxy, 10);
TEST_ASSERT (jerry_value_is_number (result_for_10));
TEST_ASSERT (jerry_get_number_value (result_for_10) == 4.0);
TEST_ASSERT (jerry_value_as_number (result_for_10) == 4.0);
/* Call: proxy[5] */
data->value = 8;
jerry_value_t result_for_5 = jerry_get_property_by_index (proxy, 5);
jerry_value_t result_for_5 = jerry_object_get_index (proxy, 5);
TEST_ASSERT (jerry_value_is_number (result_for_5));
TEST_ASSERT (jerry_get_number_value (result_for_5) == 16.0);
TEST_ASSERT (jerry_value_as_number (result_for_5) == 16.0);
jerry_release_value (handler);
jerry_release_value (target);
jerry_release_value (proxy);
jerry_value_free (handler);
jerry_value_free (target);
jerry_value_free (proxy);
} /* test_proxy_native */
int
@@ -223,7 +223,7 @@ main (void)
{
TEST_INIT ();
if (!jerry_is_feature_enabled (JERRY_FEATURE_PROXY))
if (!jerry_feature_enabled (JERRY_FEATURE_PROXY))
{
printf ("Skipping test, Proxy not enabled\n");
return 0;
@@ -231,134 +231,134 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t handler = jerry_create_object ();
jerry_value_t handler = jerry_object ();
{
set_function (handler, "get", handler_get);
set_function (handler, "set", handler_set);
}
jerry_value_t target = jerry_create_object ();
jerry_value_t proxy = jerry_create_proxy (target, handler);
jerry_value_t target = jerry_object ();
jerry_value_t proxy = jerry_proxy (target, handler);
{
jerry_value_t global = jerry_get_global_object ();
jerry_value_t global = jerry_current_realm ();
set_property (global, "pdemo", proxy);
jerry_release_value (global);
jerry_value_free (global);
}
const jerry_char_t get_value_src[] = TEST_STRING_LITERAL ("pdemo.value");
jerry_value_t parsed_get_code_val = jerry_parse (get_value_src, sizeof (get_value_src) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_get_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_get_code_val));
{
jerry_value_t res = jerry_run (parsed_get_code_val);
TEST_ASSERT (jerry_value_is_number (res));
TEST_ASSERT (jerry_get_number_value (res) == 1.0);
jerry_release_value (res);
TEST_ASSERT (jerry_value_as_number (res) == 1.0);
jerry_value_free (res);
}
{
jerry_value_t res = get_property (proxy, "value");
TEST_ASSERT (jerry_value_is_number (res));
TEST_ASSERT (jerry_get_number_value (res) == 2.0);
jerry_release_value (res);
TEST_ASSERT (jerry_value_as_number (res) == 2.0);
jerry_value_free (res);
}
{
jerry_value_t res = jerry_run (parsed_get_code_val);
TEST_ASSERT (jerry_value_is_number (res));
TEST_ASSERT (jerry_get_number_value (res) == 3.0);
jerry_release_value (res);
TEST_ASSERT (jerry_value_as_number (res) == 3.0);
jerry_value_free (res);
}
const jerry_char_t set_value_src[] = TEST_STRING_LITERAL ("pdemo.value = 55");
jerry_value_t parsed_set_code_val = jerry_parse (set_value_src, sizeof (set_value_src) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_set_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_set_code_val));
{
jerry_value_t res = jerry_run (parsed_set_code_val);
TEST_ASSERT (jerry_value_is_number (res));
TEST_ASSERT (jerry_get_number_value (res) == 55);
jerry_release_value (res);
TEST_ASSERT (jerry_value_as_number (res) == 55);
jerry_value_free (res);
}
{
jerry_value_t res = jerry_run (parsed_get_code_val);
TEST_ASSERT (jerry_value_is_number (res));
TEST_ASSERT (jerry_get_number_value (res) == 56);
jerry_release_value (res);
TEST_ASSERT (jerry_value_as_number (res) == 56);
jerry_value_free (res);
}
{
jerry_value_t new_value = jerry_create_number (12);
jerry_value_t new_value = jerry_number (12);
set_property (proxy, "value", new_value);
jerry_release_value (new_value);
jerry_value_free (new_value);
}
{
jerry_value_t res = get_property (proxy, "value");
TEST_ASSERT (jerry_value_is_number (res));
TEST_ASSERT (jerry_get_number_value (res) == 13.0);
jerry_release_value (res);
TEST_ASSERT (jerry_value_as_number (res) == 13.0);
jerry_value_free (res);
}
jerry_release_value (parsed_set_code_val);
jerry_release_value (parsed_get_code_val);
jerry_release_value (proxy);
jerry_release_value (target);
jerry_release_value (handler);
jerry_value_free (parsed_set_code_val);
jerry_value_free (parsed_get_code_val);
jerry_value_free (proxy);
jerry_value_free (target);
jerry_value_free (handler);
{
const jerry_char_t has_value_src[] = TEST_STRING_LITERAL ("new Proxy({}, {\n"
" has: function(target, key) { throw 33 }\n"
"})");
jerry_value_t parsed_has_code_val = jerry_parse (has_value_src, sizeof (has_value_src) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_has_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_has_code_val));
jerry_value_t res = jerry_run (parsed_has_code_val);
jerry_release_value (parsed_has_code_val);
jerry_value_free (parsed_has_code_val);
TEST_ASSERT (jerry_value_is_proxy (res));
jerry_value_t name = jerry_create_string ((const jerry_char_t *) "key");
jerry_value_t name = jerry_string_sz ("key");
TEST_ASSERT (jerry_value_is_string (name));
jerry_value_t property = jerry_has_property (res, name);
jerry_release_value (name);
jerry_release_value (res);
jerry_value_t property = jerry_object_has (res, name);
jerry_value_free (name);
jerry_value_free (res);
TEST_ASSERT (jerry_value_is_error (property));
property = jerry_get_value_from_error (property, true);
TEST_ASSERT (jerry_get_number_value (property) == 33);
jerry_release_value (property);
TEST_ASSERT (jerry_value_is_exception (property));
property = jerry_exception_value (property, true);
TEST_ASSERT (jerry_value_as_number (property) == 33);
jerry_value_free (property);
}
target = jerry_create_object ();
handler = jerry_create_object ();
proxy = jerry_create_proxy (target, handler);
target = jerry_object ();
handler = jerry_object ();
proxy = jerry_proxy (target, handler);
{
jerry_value_t res = jerry_get_proxy_target (proxy);
jerry_value_t res = jerry_proxy_target (proxy);
TEST_ASSERT (res == target);
jerry_release_value (res);
jerry_value_free (res);
res = jerry_get_proxy_handler (proxy);
res = jerry_proxy_handler (proxy);
TEST_ASSERT (res == handler);
jerry_release_value (res);
jerry_value_free (res);
res = jerry_get_proxy_target (target);
TEST_ASSERT (jerry_value_is_error (res));
res = jerry_get_value_from_error (res, true);
TEST_ASSERT (jerry_get_error_type (res) == JERRY_ERROR_TYPE);
jerry_release_value (res);
res = jerry_proxy_target (target);
TEST_ASSERT (jerry_value_is_exception (res));
res = jerry_exception_value (res, true);
TEST_ASSERT (jerry_error_type (res) == JERRY_ERROR_TYPE);
jerry_value_free (res);
res = jerry_get_proxy_handler (handler);
TEST_ASSERT (jerry_value_is_error (res));
res = jerry_get_value_from_error (res, true);
TEST_ASSERT (jerry_get_error_type (res) == JERRY_ERROR_TYPE);
jerry_release_value (res);
res = jerry_proxy_handler (handler);
TEST_ASSERT (jerry_value_is_exception (res));
res = jerry_exception_value (res, true);
TEST_ASSERT (jerry_error_type (res) == JERRY_ERROR_TYPE);
jerry_value_free (res);
}
jerry_release_value (proxy);
jerry_release_value (handler);
jerry_release_value (target);
jerry_value_free (proxy);
jerry_value_free (handler);
jerry_value_free (target);
test_proxy_native ();
tests/unit-core/test-realm.c
+80 -80
View File
@@ -22,29 +22,29 @@ create_number_property (jerry_value_t object_value, /**< object value */
char *name_p, /**< name */
double number) /**< value */
{
jerry_value_t name_value = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t number_value = jerry_create_number (number);
jerry_value_t result_value = jerry_set_property (object_value, name_value, number_value);
TEST_ASSERT (!jerry_value_is_error (result_value));
jerry_value_t name_value = jerry_string_sz (name_p);
jerry_value_t number_value = jerry_number (number);
jerry_value_t result_value = jerry_object_set (object_value, name_value, number_value);
TEST_ASSERT (!jerry_value_is_exception (result_value));
jerry_release_value (result_value);
jerry_release_value (number_value);
jerry_release_value (name_value);
jerry_value_free (result_value);
jerry_value_free (number_value);
jerry_value_free (name_value);
} /* create_number_property */
static double
get_number_property (jerry_value_t object_value, /**< object value */
char *name_p) /**< name */
{
jerry_value_t name_value = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t result_value = jerry_get_property (object_value, name_value);
TEST_ASSERT (!jerry_value_is_error (result_value));
jerry_value_t name_value = jerry_string_sz (name_p);
jerry_value_t result_value = jerry_object_get (object_value, name_value);
TEST_ASSERT (!jerry_value_is_exception (result_value));
TEST_ASSERT (jerry_value_is_number (result_value));
double result = jerry_get_number_value (result_value);
double result = jerry_value_as_number (result_value);
jerry_release_value (result_value);
jerry_release_value (name_value);
jerry_value_free (result_value);
jerry_value_free (name_value);
return result;
} /* get_number_property */
@@ -55,39 +55,39 @@ eval_and_get_number (char *script_p) /**< script source */
result_value = jerry_eval ((const jerry_char_t *) script_p, strlen (script_p), JERRY_PARSE_NO_OPTS);
TEST_ASSERT (jerry_value_is_number (result_value));
double result = jerry_get_number_value (result_value);
jerry_release_value (result_value);
double result = jerry_value_as_number (result_value);
jerry_value_free (result_value);
return result;
} /* eval_and_get_number */
static void
check_type_error (jerry_value_t result_value) /**< result value */
{
TEST_ASSERT (jerry_value_is_error (result_value));
result_value = jerry_get_value_from_error (result_value, true);
TEST_ASSERT (jerry_get_error_type (result_value) == JERRY_ERROR_TYPE);
jerry_release_value (result_value);
TEST_ASSERT (jerry_value_is_exception (result_value));
result_value = jerry_exception_value (result_value, true);
TEST_ASSERT (jerry_error_type (result_value) == JERRY_ERROR_TYPE);
jerry_value_free (result_value);
} /* check_type_error */
static void
check_array_prototype (jerry_value_t realm_value, jerry_value_t result_value)
{
jerry_value_t name_value = jerry_create_string ((const jerry_char_t *) "Array");
jerry_value_t array_value = jerry_get_property (realm_value, name_value);
jerry_value_t name_value = jerry_string_sz ("Array");
jerry_value_t array_value = jerry_object_get (realm_value, name_value);
TEST_ASSERT (jerry_value_is_object (array_value));
jerry_release_value (name_value);
jerry_value_free (name_value);
name_value = jerry_create_string ((const jerry_char_t *) "prototype");
jerry_value_t prototype_value = jerry_get_property (array_value, name_value);
name_value = jerry_string_sz ("prototype");
jerry_value_t prototype_value = jerry_object_get (array_value, name_value);
TEST_ASSERT (jerry_value_is_object (prototype_value));
jerry_release_value (name_value);
jerry_release_value (array_value);
jerry_value_free (name_value);
jerry_value_free (array_value);
jerry_value_t compare_value = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, result_value, prototype_value);
jerry_release_value (prototype_value);
jerry_value_t compare_value = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, result_value, prototype_value);
jerry_value_free (prototype_value);
TEST_ASSERT (jerry_value_is_boolean (compare_value) && jerry_value_is_true (compare_value));
jerry_release_value (compare_value);
jerry_value_free (compare_value);
} /* check_array_prototype */
/**
@@ -100,22 +100,22 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t global_value = jerry_get_global_object ();
jerry_value_t result_value = jerry_realm_get_this (global_value);
jerry_value_t global_value = jerry_current_realm ();
jerry_value_t result_value = jerry_realm_this (global_value);
TEST_ASSERT (global_value == result_value);
jerry_release_value (global_value);
jerry_value_free (global_value);
jerry_value_t number_value = jerry_create_number (3);
check_type_error (jerry_realm_get_this (number_value));
jerry_release_value (number_value);
jerry_value_t number_value = jerry_number (3);
check_type_error (jerry_realm_this (number_value));
jerry_value_free (number_value);
if (!jerry_is_feature_enabled (JERRY_FEATURE_REALM))
if (!jerry_feature_enabled (JERRY_FEATURE_REALM))
{
printf ("Skipping test, Realms not enabled\n");
return 0;
}
jerry_value_t realm_value = jerry_create_realm ();
jerry_value_t realm_value = jerry_realm ();
create_number_property (global_value, "a", 3.5);
create_number_property (global_value, "b", 7.25);
@@ -139,120 +139,120 @@ main (void)
result_value = jerry_set_realm (global_value);
TEST_ASSERT (result_value == realm_value);
jerry_value_t object_value = jerry_create_object ();
jerry_value_t object_value = jerry_object ();
check_type_error (jerry_set_realm (object_value));
jerry_release_value (object_value);
jerry_value_free (object_value);
number_value = jerry_create_number (5);
number_value = jerry_number (5);
check_type_error (jerry_set_realm (number_value));
jerry_release_value (number_value);
jerry_value_free (number_value);
jerry_release_value (global_value);
jerry_release_value (realm_value);
jerry_value_free (global_value);
jerry_value_free (realm_value);
realm_value = jerry_create_realm ();
realm_value = jerry_realm ();
result_value = jerry_realm_get_this (realm_value);
result_value = jerry_realm_this (realm_value);
TEST_ASSERT (result_value == realm_value);
jerry_release_value (result_value);
jerry_value_free (result_value);
result_value = jerry_set_realm (realm_value);
TEST_ASSERT (!jerry_value_is_error (result_value));
object_value = jerry_create_object ();
TEST_ASSERT (!jerry_value_is_exception (result_value));
object_value = jerry_object ();
jerry_set_realm (result_value);
number_value = jerry_create_number (7);
number_value = jerry_number (7);
check_type_error (jerry_realm_set_this (realm_value, number_value));
check_type_error (jerry_realm_set_this (number_value, object_value));
jerry_release_value (number_value);
jerry_value_free (number_value);
result_value = jerry_realm_set_this (realm_value, object_value);
TEST_ASSERT (jerry_value_is_boolean (result_value) && jerry_value_is_true (result_value));
jerry_release_value (result_value);
jerry_value_free (result_value);
create_number_property (object_value, "x", 7.25);
create_number_property (object_value, "y", 1.25);
result_value = jerry_set_realm (realm_value);
TEST_ASSERT (!jerry_value_is_error (result_value));
TEST_ASSERT (!jerry_value_is_exception (result_value));
TEST_ASSERT (eval_and_get_number ("var z = -5.5; x + this.y") == 8.5);
jerry_set_realm (result_value);
TEST_ASSERT (get_number_property (object_value, "z") == -5.5);
result_value = jerry_realm_get_this (realm_value);
result_value = jerry_realm_this (realm_value);
TEST_ASSERT (result_value == object_value);
jerry_release_value (result_value);
jerry_value_free (result_value);
jerry_release_value (object_value);
jerry_release_value (realm_value);
jerry_value_free (object_value);
jerry_value_free (realm_value);
if (jerry_is_feature_enabled (JERRY_FEATURE_PROXY))
if (jerry_feature_enabled (JERRY_FEATURE_PROXY))
{
/* Check property creation. */
jerry_value_t handler_value = jerry_create_object ();
jerry_value_t target_value = jerry_create_realm ();
jerry_value_t proxy_value = jerry_create_proxy (target_value, handler_value);
jerry_value_t handler_value = jerry_object ();
jerry_value_t target_value = jerry_realm ();
jerry_value_t proxy_value = jerry_proxy (target_value, handler_value);
jerry_realm_set_this (target_value, proxy_value);
jerry_release_value (proxy_value);
jerry_release_value (handler_value);
jerry_value_free (proxy_value);
jerry_value_free (handler_value);
jerry_value_t old_realm_value = jerry_set_realm (target_value);
TEST_ASSERT (!jerry_value_is_error (old_realm_value));
TEST_ASSERT (!jerry_value_is_exception (old_realm_value));
TEST_ASSERT (eval_and_get_number ("var z = 1.5; z") == 1.5);
jerry_set_realm (old_realm_value);
TEST_ASSERT (get_number_property (target_value, "z") == 1.5);
jerry_release_value (target_value);
jerry_value_free (target_value);
/* Check isExtensible error. */
const char *script_p = "new Proxy({}, { isExtensible: function() { throw 42.5 } })";
proxy_value = jerry_eval ((const jerry_char_t *) script_p, strlen (script_p), JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (proxy_value) && jerry_value_is_object (proxy_value));
TEST_ASSERT (!jerry_value_is_exception (proxy_value) && jerry_value_is_object (proxy_value));
target_value = jerry_create_realm ();
target_value = jerry_realm ();
jerry_realm_set_this (target_value, proxy_value);
jerry_release_value (proxy_value);
jerry_value_free (proxy_value);
old_realm_value = jerry_set_realm (target_value);
TEST_ASSERT (!jerry_value_is_error (old_realm_value));
TEST_ASSERT (!jerry_value_is_exception (old_realm_value));
script_p = "var z = 1.5";
result_value = jerry_eval ((const jerry_char_t *) script_p, strlen (script_p), JERRY_PARSE_NO_OPTS);
jerry_set_realm (old_realm_value);
jerry_release_value (target_value);
jerry_value_free (target_value);
TEST_ASSERT (jerry_value_is_error (result_value));
result_value = jerry_get_value_from_error (result_value, true);
TEST_ASSERT (jerry_value_is_number (result_value) && jerry_get_number_value (result_value) == 42.5);
jerry_release_value (result_value);
TEST_ASSERT (jerry_value_is_exception (result_value));
result_value = jerry_exception_value (result_value, true);
TEST_ASSERT (jerry_value_is_number (result_value) && jerry_value_as_number (result_value) == 42.5);
jerry_value_free (result_value);
}
realm_value = jerry_create_realm ();
realm_value = jerry_realm ();
result_value = jerry_set_realm (realm_value);
TEST_ASSERT (!jerry_value_is_error (result_value));
TEST_ASSERT (!jerry_value_is_exception (result_value));
const char *script_p = "global2 = global1 - 1; Object.getPrototypeOf([])";
jerry_value_t script_value = jerry_parse ((const jerry_char_t *) script_p, strlen (script_p), NULL);
TEST_ASSERT (!jerry_value_is_error (script_value));
TEST_ASSERT (!jerry_value_is_exception (script_value));
jerry_set_realm (result_value);
/* Script is compiled in another realm. */
create_number_property (realm_value, "global1", 7.5);
result_value = jerry_run (script_value);
TEST_ASSERT (!jerry_value_is_error (result_value));
TEST_ASSERT (!jerry_value_is_exception (result_value));
check_array_prototype (realm_value, result_value);
jerry_release_value (result_value);
jerry_release_value (script_value);
jerry_value_free (result_value);
jerry_value_free (script_value);
TEST_ASSERT (get_number_property (realm_value, "global2") == 6.5);
jerry_release_value (realm_value);
jerry_value_free (realm_value);
jerry_cleanup ();
return 0;
tests/unit-core/test-regexp-dotall-unicode.c
+22 -22
View File
@@ -23,38 +23,38 @@ main (void)
TEST_INIT ();
jerry_init (JERRY_INIT_EMPTY);
if (!jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
if (!jerry_feature_enabled (JERRY_FEATURE_SYMBOL))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "ES.next support is disabled\n");
jerry_cleanup ();
return 0;
}
jerry_value_t undefined_this_arg = jerry_create_undefined ();
jerry_char_t pattern2[] = "\\u{61}.\\u{62}";
jerry_value_t undefined_this_arg = jerry_undefined ();
char pattern2[] = "\\u{61}.\\u{62}";
uint16_t flags = JERRY_REGEXP_FLAG_DOTALL | JERRY_REGEXP_FLAG_UNICODE | JERRY_REGEXP_FLAG_STICKY;
jerry_value_t regex_obj = jerry_create_regexp (pattern2, flags);
jerry_value_t regex_obj = jerry_regexp_sz (pattern2, flags);
TEST_ASSERT (jerry_value_is_object (regex_obj));
const jerry_char_t func_src2[] = "return [regex.exec('a\\nb'), regex.dotAll, regex.sticky, regex.unicode ];";
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_ARGUMENT_LIST;
parse_options.argument_list = jerry_create_string ((const jerry_char_t *) "regex");
parse_options.argument_list = jerry_string_sz ("regex");
jerry_value_t func_val = jerry_parse (func_src2, sizeof (func_src2) - 1, &parse_options);
jerry_release_value (parse_options.argument_list);
jerry_value_free (parse_options.argument_list);
jerry_value_t res = jerry_call_function (func_val, undefined_this_arg, &regex_obj, 1);
jerry_value_t regex_res = jerry_get_property_by_index (res, 0);
jerry_value_t regex_res_str = jerry_get_property_by_index (regex_res, 0);
jerry_value_t is_dotall = jerry_get_property_by_index (res, 1);
jerry_value_t is_sticky = jerry_get_property_by_index (res, 2);
jerry_value_t is_unicode = jerry_get_property_by_index (res, 3);
jerry_value_t res = jerry_call (func_val, undefined_this_arg, &regex_obj, 1);
jerry_value_t regex_res = jerry_object_get_index (res, 0);
jerry_value_t regex_res_str = jerry_object_get_index (regex_res, 0);
jerry_value_t is_dotall = jerry_object_get_index (res, 1);
jerry_value_t is_sticky = jerry_object_get_index (res, 2);
jerry_value_t is_unicode = jerry_object_get_index (res, 3);
jerry_size_t str_size = jerry_get_string_size (regex_res_str);
jerry_size_t str_size = jerry_string_size (regex_res_str, JERRY_ENCODING_CESU8);
JERRY_VLA (jerry_char_t, res_buff, str_size);
jerry_size_t res_size = jerry_string_to_char_buffer (regex_res_str, res_buff, str_size);
jerry_size_t res_size = jerry_string_to_buffer (regex_res_str, JERRY_ENCODING_CESU8, res_buff, str_size);
const char expected_result[] = "a\nb";
TEST_ASSERT (res_size == (sizeof (expected_result) - 1));
@@ -63,14 +63,14 @@ main (void)
TEST_ASSERT (jerry_value_is_true (is_sticky));
TEST_ASSERT (jerry_value_is_true (is_unicode));
jerry_release_value (regex_obj);
jerry_release_value (res);
jerry_release_value (func_val);
jerry_release_value (regex_res);
jerry_release_value (regex_res_str);
jerry_release_value (is_dotall);
jerry_release_value (is_sticky);
jerry_release_value (is_unicode);
jerry_value_free (regex_obj);
jerry_value_free (res);
jerry_value_free (func_val);
jerry_value_free (regex_res);
jerry_value_free (regex_res_str);
jerry_value_free (is_dotall);
jerry_value_free (is_sticky);
jerry_value_free (is_unicode);
jerry_cleanup ();
return 0;
tests/unit-core/test-regexp.c
+20 -20
View File
@@ -23,48 +23,48 @@ main (void)
TEST_INIT ();
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_char_t pattern[] = "[^.]+";
char pattern[] = "[^.]+";
uint16_t flags = JERRY_REGEXP_FLAG_GLOBAL | JERRY_REGEXP_FLAG_MULTILINE;
jerry_value_t regex_obj = jerry_create_regexp (pattern, flags);
jerry_value_t regex_obj = jerry_regexp_sz (pattern, flags);
TEST_ASSERT (jerry_value_is_object (regex_obj));
const jerry_char_t func_src[] = "return [regex.exec('something.domain.com'), regex.multiline, regex.global];";
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_ARGUMENT_LIST;
parse_options.argument_list = jerry_create_string ((const jerry_char_t *) "regex");
parse_options.argument_list = jerry_string_sz ("regex");
jerry_value_t func_val = jerry_parse (func_src, sizeof (func_src) - 1, &parse_options);
jerry_release_value (parse_options.argument_list);
jerry_value_free (parse_options.argument_list);
jerry_value_t res = jerry_call_function (func_val, global_obj_val, &regex_obj, 1);
jerry_value_t regex_res = jerry_get_property_by_index (res, 0);
jerry_value_t regex_res_str = jerry_get_property_by_index (regex_res, 0);
jerry_value_t is_multiline = jerry_get_property_by_index (res, 1);
jerry_value_t is_global = jerry_get_property_by_index (res, 2);
jerry_value_t res = jerry_call (func_val, global_obj_val, &regex_obj, 1);
jerry_value_t regex_res = jerry_object_get_index (res, 0);
jerry_value_t regex_res_str = jerry_object_get_index (regex_res, 0);
jerry_value_t is_multiline = jerry_object_get_index (res, 1);
jerry_value_t is_global = jerry_object_get_index (res, 2);
const char expected_result[] = "something";
jerry_size_t str_size = jerry_get_string_size (regex_res_str);
jerry_size_t str_size = jerry_string_size (regex_res_str, JERRY_ENCODING_CESU8);
TEST_ASSERT (str_size == (sizeof (expected_result) - 1));
JERRY_VLA (jerry_char_t, res_buff, str_size);
jerry_size_t res_size = jerry_string_to_char_buffer (regex_res_str, res_buff, str_size);
jerry_size_t res_size = jerry_string_to_buffer (regex_res_str, JERRY_ENCODING_CESU8, res_buff, str_size);
TEST_ASSERT (res_size == str_size);
TEST_ASSERT (strncmp (expected_result, (const char *) res_buff, res_size) == 0);
TEST_ASSERT (jerry_value_is_true (is_multiline));
TEST_ASSERT (jerry_value_is_true (is_global));
jerry_release_value (regex_obj);
jerry_release_value (res);
jerry_release_value (func_val);
jerry_release_value (regex_res);
jerry_release_value (regex_res_str);
jerry_release_value (is_multiline);
jerry_release_value (is_global);
jerry_release_value (global_obj_val);
jerry_value_free (regex_obj);
jerry_value_free (res);
jerry_value_free (func_val);
jerry_value_free (regex_res);
jerry_value_free (regex_res_str);
jerry_value_free (is_multiline);
jerry_value_free (is_global);
jerry_value_free (global_obj_val);
jerry_cleanup ();
return 0;
tests/unit-core/test-regression-3588.c
+20 -20
View File
@@ -30,16 +30,16 @@ construct_handler (const jerry_call_info_t *call_info_p, /**< call information *
JERRY_UNUSED (call_info_p);
TEST_ASSERT (args_cnt == 1);
TEST_ASSERT (jerry_get_number_value (args_p[0]) == 1.0);
TEST_ASSERT (jerry_value_as_number (args_p[0]) == 1.0);
return jerry_create_undefined ();
return jerry_undefined ();
} /* construct_handler */
int
main (void)
{
/* Test JERRY_FEATURE_SYMBOL feature as it is a must-have in ES.next */
if (!jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
if (!jerry_feature_enabled (JERRY_FEATURE_SYMBOL))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Skipping test, ES.next support is disabled.\n");
return 0;
@@ -48,17 +48,17 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
{
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t function_val = jerry_create_external_function (construct_handler);
jerry_value_t function_name_val = jerry_create_string ((const jerry_char_t *) "Demo");
jerry_value_t result_val = jerry_set_property (global_obj_val, function_name_val, function_val);
TEST_ASSERT (!jerry_value_is_error (result_val));
jerry_value_t function_val = jerry_function_external (construct_handler);
jerry_value_t function_name_val = jerry_string_sz ("Demo");
jerry_value_t result_val = jerry_object_set (global_obj_val, function_name_val, function_val);
TEST_ASSERT (!jerry_value_is_exception (result_val));
TEST_ASSERT (jerry_value_is_true (result_val));
jerry_release_value (result_val);
jerry_release_value (function_name_val);
jerry_release_value (global_obj_val);
jerry_release_value (function_val);
jerry_value_free (result_val);
jerry_value_free (function_name_val);
jerry_value_free (global_obj_val);
jerry_value_free (function_val);
}
{
@@ -67,13 +67,13 @@ main (void)
"new Sub1 ()");
jerry_value_t parsed_code_val = jerry_parse (test_source, sizeof (test_source) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
jerry_value_t result = jerry_run (parsed_code_val);
TEST_ASSERT (!jerry_value_is_error (result));
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_release_value (result);
jerry_release_value (parsed_code_val);
jerry_value_free (result);
jerry_value_free (parsed_code_val);
}
{
@@ -81,13 +81,13 @@ main (void)
"new Sub2 (1)");
jerry_value_t parsed_code_val = jerry_parse (test_source, sizeof (test_source) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
jerry_value_t result = jerry_run (parsed_code_val);
TEST_ASSERT (!jerry_value_is_error (result));
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_release_value (result);
jerry_release_value (parsed_code_val);
jerry_value_free (result);
jerry_value_free (parsed_code_val);
}
jerry_cleanup ();
tests/unit-core/test-resource-name.c
+92 -93
View File
@@ -19,25 +19,25 @@
#include "test-common.h"
static jerry_value_t
resource_name_handler (const jerry_call_info_t *call_info_p, /**< call information */
const jerry_value_t args_p[], /**< argument list */
const jerry_length_t args_count) /**< argument count */
source_name_handler (const jerry_call_info_t *call_info_p, /**< call information */
const jerry_value_t args_p[], /**< argument list */
const jerry_length_t args_count) /**< argument count */
{
(void) call_info_p;
jerry_value_t undefined_value = jerry_create_undefined ();
jerry_value_t resource_name = jerry_get_resource_name (args_count > 0 ? args_p[0] : undefined_value);
jerry_release_value (undefined_value);
jerry_value_t undefined_value = jerry_undefined ();
jerry_value_t source_name = jerry_source_name (args_count > 0 ? args_p[0] : undefined_value);
jerry_value_free (undefined_value);
return resource_name;
} /* resource_name_handler */
return source_name;
} /* source_name_handler */
int
main (void)
{
TEST_INIT ();
if (!jerry_is_feature_enabled (JERRY_FEATURE_LINE_INFO))
if (!jerry_feature_enabled (JERRY_FEATURE_LINE_INFO))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Line info support is disabled!\n");
return 0;
@@ -45,22 +45,22 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t global = jerry_get_global_object ();
jerry_value_t global = jerry_current_realm ();
/* Register the "resourceName" method. */
{
jerry_value_t func = jerry_create_external_function (resource_name_handler);
jerry_value_t name = jerry_create_string ((const jerry_char_t *) "resourceName");
jerry_value_t result = jerry_set_property (global, name, func);
jerry_release_value (result);
jerry_release_value (name);
jerry_release_value (func);
jerry_value_t func = jerry_function_external (source_name_handler);
jerry_value_t name = jerry_string_sz ("resourceName");
jerry_value_t result = jerry_object_set (global, name, func);
jerry_value_free (result);
jerry_value_free (name);
jerry_value_free (func);
}
jerry_release_value (global);
jerry_value_free (global);
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
const char *source_1 = ("function f1 () {\n"
" if (resourceName() !== 'demo1.js') return false; \n"
@@ -70,26 +70,25 @@ main (void)
"} \n"
"f1();");
parse_options.resource_name = jerry_create_string ((jerry_char_t *) "demo1.js");
parse_options.source_name = jerry_string_sz ("demo1.js");
jerry_value_t program = jerry_parse ((const jerry_char_t *) source_1, strlen (source_1), &parse_options);
TEST_ASSERT (!jerry_value_is_error (program));
TEST_ASSERT (!jerry_value_is_exception (program));
jerry_value_t run_result = jerry_run (program);
TEST_ASSERT (!jerry_value_is_error (run_result));
TEST_ASSERT (!jerry_value_is_exception (run_result));
TEST_ASSERT (jerry_value_is_object (run_result));
jerry_value_t resource_value = jerry_get_resource_name (run_result);
jerry_value_t compare_result =
jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.resource_name);
jerry_value_t resource_value = jerry_source_name (run_result);
jerry_value_t compare_result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.source_name);
TEST_ASSERT (jerry_value_is_true (compare_result));
jerry_release_value (compare_result);
jerry_release_value (resource_value);
jerry_release_value (parse_options.resource_name);
jerry_value_free (compare_result);
jerry_value_free (resource_value);
jerry_value_free (parse_options.source_name);
jerry_release_value (run_result);
jerry_release_value (program);
jerry_value_free (run_result);
jerry_value_free (program);
const char *source_2 = ("function f2 () { \n"
" if (resourceName() !== 'demo2.js') return false; \n"
@@ -101,127 +100,127 @@ main (void)
"} \n"
"f2(); \n");
parse_options.resource_name = jerry_create_string ((const jerry_char_t *) "demo2.js");
parse_options.source_name = jerry_string_sz ("demo2.js");
program = jerry_parse ((const jerry_char_t *) source_2, strlen (source_2), &parse_options);
TEST_ASSERT (!jerry_value_is_error (program));
TEST_ASSERT (!jerry_value_is_exception (program));
run_result = jerry_run (program);
TEST_ASSERT (!jerry_value_is_error (run_result));
TEST_ASSERT (!jerry_value_is_exception (run_result));
TEST_ASSERT (jerry_value_is_object (run_result));
resource_value = jerry_get_resource_name (run_result);
compare_result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.resource_name);
resource_value = jerry_source_name (run_result);
compare_result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.source_name);
TEST_ASSERT (jerry_value_is_true (compare_result));
jerry_release_value (compare_result);
jerry_release_value (resource_value);
jerry_release_value (parse_options.resource_name);
jerry_value_free (compare_result);
jerry_value_free (resource_value);
jerry_value_free (parse_options.source_name);
jerry_release_value (run_result);
jerry_release_value (program);
if (jerry_is_feature_enabled (JERRY_FEATURE_MODULE))
jerry_value_free (run_result);
jerry_value_free (program);
if (jerry_feature_enabled (JERRY_FEATURE_MODULE))
{
jerry_value_t anon = jerry_create_string ((const jerry_char_t *) "<anonymous>");
jerry_value_t anon = jerry_string_sz ("<anonymous>");
const char *source_3 = "";
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name = jerry_create_string ((const jerry_char_t *) "demo3.js");
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string_sz ("demo3.js");
program = jerry_parse ((const jerry_char_t *) source_3, strlen (source_3), &parse_options);
TEST_ASSERT (!jerry_value_is_error (program));
TEST_ASSERT (!jerry_value_is_exception (program));
resource_value = jerry_get_resource_name (program);
compare_result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.resource_name);
resource_value = jerry_source_name (program);
compare_result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.source_name);
TEST_ASSERT (jerry_value_is_true (compare_result));
jerry_release_value (compare_result);
jerry_release_value (resource_value);
jerry_value_free (compare_result);
jerry_value_free (resource_value);
run_result = jerry_module_link (program, NULL, NULL);
TEST_ASSERT (!jerry_value_is_error (run_result));
TEST_ASSERT (!jerry_value_is_exception (run_result));
resource_value = jerry_get_resource_name (run_result);
compare_result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, resource_value, anon);
resource_value = jerry_source_name (run_result);
compare_result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, resource_value, anon);
TEST_ASSERT (jerry_value_is_true (compare_result));
jerry_release_value (compare_result);
jerry_release_value (resource_value);
jerry_release_value (run_result);
jerry_value_free (compare_result);
jerry_value_free (resource_value);
jerry_value_free (run_result);
run_result = jerry_module_evaluate (program);
TEST_ASSERT (!jerry_value_is_error (run_result));
TEST_ASSERT (!jerry_value_is_exception (run_result));
resource_value = jerry_get_resource_name (run_result);
compare_result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, resource_value, anon);
resource_value = jerry_source_name (run_result);
compare_result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, resource_value, anon);
TEST_ASSERT (jerry_value_is_true (compare_result));
jerry_release_value (compare_result);
jerry_release_value (resource_value);
jerry_release_value (run_result);
jerry_release_value (program);
jerry_release_value (parse_options.resource_name);
jerry_value_free (compare_result);
jerry_value_free (resource_value);
jerry_value_free (run_result);
jerry_value_free (program);
jerry_value_free (parse_options.source_name);
}
const char *source_4 = ("function f(){} \n"
"f.bind().bind();");
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name = jerry_create_string ((jerry_char_t *) "demo4.js");
parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string_sz ("demo4.js");
program = jerry_parse ((const jerry_char_t *) source_4, strlen (source_4), &parse_options);
TEST_ASSERT (!jerry_value_is_error (program));
TEST_ASSERT (!jerry_value_is_exception (program));
run_result = jerry_run (program);
TEST_ASSERT (!jerry_value_is_error (run_result));
TEST_ASSERT (!jerry_value_is_exception (run_result));
TEST_ASSERT (jerry_value_is_object (run_result));
resource_value = jerry_get_resource_name (run_result);
compare_result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.resource_name);
resource_value = jerry_source_name (run_result);
compare_result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.source_name);
TEST_ASSERT (jerry_value_is_true (compare_result));
jerry_release_value (compare_result);
jerry_value_free (compare_result);
jerry_release_value (resource_value);
jerry_release_value (parse_options.resource_name);
jerry_release_value (run_result);
jerry_release_value (program);
jerry_value_free (resource_value);
jerry_value_free (parse_options.source_name);
jerry_value_free (run_result);
jerry_value_free (program);
const char *source_5 = "";
parse_options.options = JERRY_PARSE_HAS_USER_VALUE | JERRY_PARSE_HAS_RESOURCE;
parse_options.user_value = jerry_create_object ();
parse_options.resource_name = jerry_create_string ((jerry_char_t *) "demo5.js");
parse_options.options = JERRY_PARSE_HAS_USER_VALUE | JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.user_value = jerry_object ();
parse_options.source_name = jerry_string_sz ("demo5.js");
program = jerry_parse ((const jerry_char_t *) source_5, strlen (source_5), &parse_options);
TEST_ASSERT (!jerry_value_is_error (program));
TEST_ASSERT (!jerry_value_is_exception (program));
resource_value = jerry_get_resource_name (program);
compare_result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.resource_name);
resource_value = jerry_source_name (program);
compare_result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.source_name);
TEST_ASSERT (jerry_value_is_true (compare_result));
jerry_release_value (resource_value);
jerry_release_value (compare_result);
jerry_release_value (parse_options.user_value);
jerry_release_value (parse_options.resource_name);
jerry_release_value (program);
jerry_value_free (resource_value);
jerry_value_free (compare_result);
jerry_value_free (parse_options.user_value);
jerry_value_free (parse_options.source_name);
jerry_value_free (program);
const char *source_6 = "(class {})";
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name = jerry_create_string ((jerry_char_t *) "demo6.js");
parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string_sz ("demo6.js");
program = jerry_parse ((const jerry_char_t *) source_6, strlen (source_6), &parse_options);
if (!jerry_value_is_error (program))
if (!jerry_value_is_exception (program))
{
resource_value = jerry_get_resource_name (program);
compare_result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.resource_name);
resource_value = jerry_source_name (program);
compare_result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, resource_value, parse_options.source_name);
TEST_ASSERT (jerry_value_is_true (compare_result));
jerry_release_value (resource_value);
jerry_release_value (compare_result);
jerry_value_free (resource_value);
jerry_value_free (compare_result);
}
jerry_release_value (parse_options.resource_name);
jerry_release_value (program);
jerry_value_free (parse_options.source_name);
jerry_value_free (program);
jerry_cleanup ();
tests/unit-core/test-script-user-value.c
+30 -30
View File
@@ -32,24 +32,24 @@ test_parse (const char *source_p, /**< source code */
options_p->user_value = user_values[i];
jerry_value_t result = jerry_parse ((const jerry_char_t *) source_p, strlen (source_p), options_p);
TEST_ASSERT (!jerry_value_is_error (result));
TEST_ASSERT (!jerry_value_is_exception (result));
if (run_code)
{
jerry_value_t parse_result = result;
result = jerry_run (result);
jerry_release_value (parse_result);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_value_free (parse_result);
TEST_ASSERT (!jerry_value_is_exception (result));
}
jerry_value_t user_value = jerry_get_user_value (result);
jerry_value_t compare_value = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, user_value, user_values[i]);
jerry_value_t user_value = jerry_source_user_value (result);
jerry_value_t compare_value = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, user_value, user_values[i]);
TEST_ASSERT (jerry_value_is_true (compare_value));
jerry_release_value (compare_value);
jerry_release_value (user_value);
jerry_release_value (result);
jerry_value_free (compare_value);
jerry_value_free (user_value);
jerry_value_free (result);
}
} /* test_parse */
@@ -59,36 +59,36 @@ test_parse_function (const char *source_p, /**< source code */
bool run_code) /**< run the code after parsing */
{
options_p->options |= JERRY_PARSE_HAS_ARGUMENT_LIST;
options_p->argument_list = jerry_create_string ((const jerry_char_t *) "");
options_p->argument_list = jerry_string_sz ("");
for (size_t i = 0; i < USER_VALUES_SIZE; i++)
{
options_p->user_value = user_values[i];
jerry_value_t result = jerry_parse ((const jerry_char_t *) source_p, strlen (source_p), options_p);
TEST_ASSERT (!jerry_value_is_error (result));
TEST_ASSERT (!jerry_value_is_exception (result));
if (run_code)
{
jerry_value_t parse_result = result;
jerry_value_t this_value = jerry_create_undefined ();
result = jerry_call_function (result, this_value, NULL, 0);
jerry_release_value (parse_result);
jerry_release_value (this_value);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_value_t this_value = jerry_undefined ();
result = jerry_call (result, this_value, NULL, 0);
jerry_value_free (parse_result);
jerry_value_free (this_value);
TEST_ASSERT (!jerry_value_is_exception (result));
}
jerry_value_t user_value = jerry_get_user_value (result);
jerry_value_t compare_value = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, user_value, user_values[i]);
jerry_value_t user_value = jerry_source_user_value (result);
jerry_value_t compare_value = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, user_value, user_values[i]);
TEST_ASSERT (jerry_value_is_true (compare_value));
jerry_release_value (compare_value);
jerry_release_value (user_value);
jerry_release_value (result);
jerry_value_free (compare_value);
jerry_value_free (user_value);
jerry_value_free (result);
}
jerry_release_value (options_p->argument_list);
jerry_value_free (options_p->argument_list);
} /* test_parse_function */
int
@@ -98,10 +98,10 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
user_values[0] = jerry_create_object ();
user_values[1] = jerry_create_null ();
user_values[2] = jerry_create_number (5.5);
user_values[3] = jerry_create_string ((const jerry_char_t *) "AnyString...");
user_values[0] = jerry_object ();
user_values[1] = jerry_null ();
user_values[2] = jerry_number (5.5);
user_values[3] = jerry_string_sz ("AnyString...");
jerry_parse_options_t parse_options;
const char *source_p = TEST_STRING_LITERAL ("");
@@ -110,7 +110,7 @@ main (void)
test_parse (source_p, &parse_options, false);
test_parse_function (source_p, &parse_options, false);
if (jerry_is_feature_enabled (JERRY_FEATURE_MODULE))
if (jerry_feature_enabled (JERRY_FEATURE_MODULE))
{
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_USER_VALUE;
test_parse (source_p, &parse_options, false);
@@ -131,7 +131,7 @@ main (void)
test_parse_function (source_p, &parse_options, true);
/* There is no test for ESNEXT, using SYMBOL instead. */
if (jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
if (jerry_feature_enabled (JERRY_FEATURE_SYMBOL))
{
source_p = TEST_STRING_LITERAL ("(class {})");
parse_options.options = JERRY_PARSE_HAS_USER_VALUE;
@@ -180,14 +180,14 @@ main (void)
for (size_t i = 0; i < USER_VALUES_SIZE; i++)
{
jerry_value_t result = jerry_get_user_value (user_values[i]);
jerry_value_t result = jerry_source_user_value (user_values[i]);
TEST_ASSERT (jerry_value_is_undefined (result));
jerry_release_value (result);
jerry_value_free (result);
}
for (size_t i = 0; i < USER_VALUES_SIZE; i++)
{
jerry_release_value (user_values[i]);
jerry_value_free (user_values[i]);
}
jerry_cleanup ();
tests/unit-core/test-snapshot.c
+79 -80
View File
@@ -45,8 +45,7 @@ static void
test_function_snapshot (void)
{
/* function to snapshot */
if (!jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE)
|| !jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
if (!jerry_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE) || !jerry_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
{
return;
}
@@ -60,20 +59,20 @@ test_function_snapshot (void)
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_ARGUMENT_LIST;
parse_options.argument_list = jerry_create_string ((const jerry_char_t *) "a, b");
parse_options.argument_list = jerry_string_sz ("a, b");
jerry_value_t parse_result = jerry_parse (code_to_snapshot, sizeof (code_to_snapshot) - 1, &parse_options);
TEST_ASSERT (!jerry_value_is_error (parse_result));
TEST_ASSERT (!jerry_value_is_exception (parse_result));
jerry_value_t generate_result =
jerry_generate_snapshot (parse_result, 0, function_snapshot_buffer, SNAPSHOT_BUFFER_SIZE);
jerry_release_value (parse_result);
jerry_release_value (parse_options.argument_list);
jerry_value_free (parse_result);
jerry_value_free (parse_options.argument_list);
TEST_ASSERT (!jerry_value_is_error (generate_result) && jerry_value_is_number (generate_result));
TEST_ASSERT (!jerry_value_is_exception (generate_result) && jerry_value_is_number (generate_result));
size_t function_snapshot_size = (size_t) jerry_get_number_value (generate_result);
jerry_release_value (generate_result);
size_t function_snapshot_size = (size_t) jerry_value_as_number (generate_result);
jerry_value_free (generate_result);
jerry_cleanup ();
@@ -85,25 +84,25 @@ test_function_snapshot (void)
JERRY_SNAPSHOT_EXEC_LOAD_AS_FUNCTION,
NULL);
TEST_ASSERT (!jerry_value_is_error (function_obj));
TEST_ASSERT (!jerry_value_is_exception (function_obj));
TEST_ASSERT (jerry_value_is_function (function_obj));
jerry_value_t this_val = jerry_create_undefined ();
jerry_value_t this_val = jerry_undefined ();
jerry_value_t args[2];
args[0] = jerry_create_number (1.0);
args[1] = jerry_create_number (2.0);
args[0] = jerry_number (1.0);
args[1] = jerry_number (2.0);
jerry_value_t res = jerry_call_function (function_obj, this_val, args, 2);
jerry_value_t res = jerry_call (function_obj, this_val, args, 2);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (jerry_value_is_number (res));
double num = jerry_get_number_value (res);
double num = jerry_value_as_number (res);
TEST_ASSERT (num == 3);
jerry_release_value (args[0]);
jerry_release_value (args[1]);
jerry_release_value (res);
jerry_release_value (function_obj);
jerry_value_free (args[0]);
jerry_value_free (args[1]);
jerry_value_free (res);
jerry_value_free (function_obj);
jerry_cleanup ();
} /* test_function_snapshot */
@@ -113,11 +112,11 @@ arguments_test_exec_snapshot (uint32_t *snapshot_p, size_t snapshot_size, uint32
{
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t res = jerry_exec_snapshot (snapshot_p, snapshot_size, 0, exec_snapshot_flags, NULL);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (jerry_value_is_number (res));
double raw_value = jerry_get_number_value (res);
double raw_value = jerry_value_as_number (res);
TEST_ASSERT (raw_value == 15);
jerry_release_value (res);
jerry_value_free (res);
jerry_cleanup ();
} /* arguments_test_exec_snapshot */
@@ -125,7 +124,7 @@ arguments_test_exec_snapshot (uint32_t *snapshot_p, size_t snapshot_size, uint32
static void
test_function_arguments_snapshot (void)
{
if (jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE) && jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
if (jerry_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE) && jerry_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
{
static uint32_t arguments_snapshot_buffer[SNAPSHOT_BUFFER_SIZE];
@@ -139,16 +138,16 @@ test_function_arguments_snapshot (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t parse_result = jerry_parse (code_to_snapshot, sizeof (code_to_snapshot) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
TEST_ASSERT (!jerry_value_is_exception (parse_result));
jerry_value_t generate_result =
jerry_generate_snapshot (parse_result, 0, arguments_snapshot_buffer, SNAPSHOT_BUFFER_SIZE);
jerry_release_value (parse_result);
jerry_value_free (parse_result);
TEST_ASSERT (!jerry_value_is_error (generate_result) && jerry_value_is_number (generate_result));
TEST_ASSERT (!jerry_value_is_exception (generate_result) && jerry_value_is_number (generate_result));
size_t snapshot_size = (size_t) jerry_get_number_value (generate_result);
jerry_release_value (generate_result);
size_t snapshot_size = (size_t) jerry_value_as_number (generate_result);
jerry_value_free (generate_result);
jerry_cleanup ();
@@ -170,13 +169,13 @@ test_exec_snapshot (uint32_t *snapshot_p, size_t snapshot_size, uint32_t exec_sn
jerry_value_t res = jerry_exec_snapshot (snapshot_p, snapshot_size, 0, exec_snapshot_flags, NULL);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (jerry_value_is_string (res));
jerry_size_t sz = jerry_get_string_size (res);
jerry_size_t sz = jerry_string_size (res, JERRY_ENCODING_CESU8);
TEST_ASSERT (sz == 20);
sz = jerry_string_to_char_buffer (res, (jerry_char_t *) string_data, sz);
sz = jerry_string_to_buffer (res, JERRY_ENCODING_CESU8, (jerry_char_t *) string_data, sz);
TEST_ASSERT (sz == 20);
jerry_release_value (res);
jerry_value_free (res);
TEST_ASSERT (!strncmp (string_data, "string from snapshot", (size_t) sz));
jerry_cleanup ();
@@ -185,7 +184,7 @@ test_exec_snapshot (uint32_t *snapshot_p, size_t snapshot_size, uint32_t exec_sn
static void
test_snapshot_with_user (void)
{
if (jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE) && jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
if (jerry_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE) && jerry_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
{
static uint32_t snapshot_buffer[SNAPSHOT_BUFFER_SIZE];
@@ -194,15 +193,15 @@ test_snapshot_with_user (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t parse_result = jerry_parse (code_to_snapshot, sizeof (code_to_snapshot) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
TEST_ASSERT (!jerry_value_is_exception (parse_result));
jerry_value_t generate_result = jerry_generate_snapshot (parse_result, 0, snapshot_buffer, SNAPSHOT_BUFFER_SIZE);
jerry_release_value (parse_result);
jerry_value_free (parse_result);
TEST_ASSERT (!jerry_value_is_error (generate_result) && jerry_value_is_number (generate_result));
TEST_ASSERT (!jerry_value_is_exception (generate_result) && jerry_value_is_number (generate_result));
size_t snapshot_size = (size_t) jerry_get_number_value (generate_result);
jerry_release_value (generate_result);
size_t snapshot_size = (size_t) jerry_value_as_number (generate_result);
jerry_value_free (generate_result);
for (int i = 0; i < 3; i++)
{
@@ -210,15 +209,15 @@ test_snapshot_with_user (void)
if (i == 0)
{
snapshot_exec_options.user_value = jerry_create_object ();
snapshot_exec_options.user_value = jerry_object ();
}
else if (i == 1)
{
snapshot_exec_options.user_value = jerry_create_number (-3.5);
snapshot_exec_options.user_value = jerry_number (-3.5);
}
else
{
snapshot_exec_options.user_value = jerry_create_string ((const jerry_char_t *) "AnyString...");
snapshot_exec_options.user_value = jerry_string_sz ("AnyString...");
}
jerry_value_t result = jerry_exec_snapshot (snapshot_buffer,
@@ -227,18 +226,18 @@ test_snapshot_with_user (void)
JERRY_SNAPSHOT_EXEC_HAS_USER_VALUE,
&snapshot_exec_options);
TEST_ASSERT (!jerry_value_is_error (result) && jerry_value_is_function (result));
TEST_ASSERT (!jerry_value_is_exception (result) && jerry_value_is_function (result));
jerry_value_t user_value = jerry_get_user_value (result);
jerry_release_value (result);
jerry_value_t user_value = jerry_source_user_value (result);
jerry_value_free (result);
result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, user_value, snapshot_exec_options.user_value);
result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, user_value, snapshot_exec_options.user_value);
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_release_value (user_value);
jerry_release_value (snapshot_exec_options.user_value);
jerry_value_free (result);
jerry_value_free (user_value);
jerry_value_free (snapshot_exec_options.user_value);
}
jerry_cleanup ();
@@ -251,7 +250,7 @@ main (void)
TEST_INIT ();
/* Static snapshot */
if (jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE) && jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
if (jerry_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE) && jerry_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
{
static uint32_t snapshot_buffer[SNAPSHOT_BUFFER_SIZE];
const jerry_char_t code_to_snapshot[] = TEST_STRING_LITERAL ("function func(a, b, c) {"
@@ -266,21 +265,21 @@ main (void)
magic_string_lengths);
jerry_value_t parse_result = jerry_parse (code_to_snapshot, sizeof (code_to_snapshot) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
TEST_ASSERT (!jerry_value_is_exception (parse_result));
jerry_value_t generate_result =
jerry_generate_snapshot (parse_result, JERRY_SNAPSHOT_SAVE_STATIC, snapshot_buffer, SNAPSHOT_BUFFER_SIZE);
jerry_release_value (parse_result);
jerry_value_free (parse_result);
TEST_ASSERT (!jerry_value_is_error (generate_result) && jerry_value_is_number (generate_result));
TEST_ASSERT (!jerry_value_is_exception (generate_result) && jerry_value_is_number (generate_result));
size_t snapshot_size = (size_t) jerry_get_number_value (generate_result);
jerry_release_value (generate_result);
size_t snapshot_size = (size_t) jerry_value_as_number (generate_result);
jerry_value_free (generate_result);
/* Static snapshots are not supported by default. */
jerry_value_t exec_result = jerry_exec_snapshot (snapshot_buffer, snapshot_size, 0, 0, NULL);
TEST_ASSERT (jerry_value_is_error (exec_result));
jerry_release_value (exec_result);
TEST_ASSERT (jerry_value_is_exception (exec_result));
jerry_value_free (exec_result);
jerry_cleanup ();
@@ -288,7 +287,7 @@ main (void)
}
/* Merge snapshot */
if (jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE) && jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
if (jerry_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE) && jerry_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
{
static uint32_t snapshot_buffer_0[SNAPSHOT_BUFFER_SIZE];
static uint32_t snapshot_buffer_1[SNAPSHOT_BUFFER_SIZE];
@@ -300,15 +299,15 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t parse_result = jerry_parse (code_to_snapshot1, sizeof (code_to_snapshot1) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
TEST_ASSERT (!jerry_value_is_exception (parse_result));
jerry_value_t generate_result = jerry_generate_snapshot (parse_result, 0, snapshot_buffer_0, SNAPSHOT_BUFFER_SIZE);
jerry_release_value (parse_result);
jerry_value_free (parse_result);
TEST_ASSERT (!jerry_value_is_error (generate_result) && jerry_value_is_number (generate_result));
TEST_ASSERT (!jerry_value_is_exception (generate_result) && jerry_value_is_number (generate_result));
snapshot_sizes[0] = (size_t) jerry_get_number_value (generate_result);
jerry_release_value (generate_result);
snapshot_sizes[0] = (size_t) jerry_value_as_number (generate_result);
jerry_value_free (generate_result);
jerry_cleanup ();
@@ -317,15 +316,15 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
parse_result = jerry_parse (code_to_snapshot2, sizeof (code_to_snapshot2) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
TEST_ASSERT (!jerry_value_is_exception (parse_result));
generate_result = jerry_generate_snapshot (parse_result, 0, snapshot_buffer_1, SNAPSHOT_BUFFER_SIZE);
jerry_release_value (parse_result);
jerry_value_free (parse_result);
TEST_ASSERT (!jerry_value_is_error (generate_result) && jerry_value_is_number (generate_result));
TEST_ASSERT (!jerry_value_is_exception (generate_result) && jerry_value_is_number (generate_result));
snapshot_sizes[1] = (size_t) jerry_get_number_value (generate_result);
jerry_release_value (generate_result);
snapshot_sizes[1] = (size_t) jerry_value_as_number (generate_result);
jerry_value_free (generate_result);
jerry_cleanup ();
@@ -358,20 +357,20 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t res = jerry_exec_snapshot (merged_snapshot_buffer, merged_size, 0, 0, NULL);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (jerry_get_number_value (res) == 123);
jerry_release_value (res);
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (jerry_value_as_number (res) == 123);
jerry_value_free (res);
res = jerry_exec_snapshot (merged_snapshot_buffer, merged_size, 1, 0, NULL);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (jerry_get_number_value (res) == 456);
jerry_release_value (res);
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (jerry_value_as_number (res) == 456);
jerry_value_free (res);
jerry_cleanup ();
}
/* Save literals */
if (jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE))
if (jerry_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE))
{
/* C format generation */
jerry_init (JERRY_INIT_EMPTY);
@@ -381,17 +380,17 @@ main (void)
static const jerry_char_t code_for_c_format[] = "var object = { aa:'fo\" o\\n \\\\', Bb:'max', aaa:'xzy0' };";
jerry_value_t parse_result = jerry_parse (code_for_c_format, sizeof (code_for_c_format) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
TEST_ASSERT (!jerry_value_is_exception (parse_result));
jerry_value_t generate_result =
jerry_generate_snapshot (parse_result, 0, literal_snapshot_buffer, SNAPSHOT_BUFFER_SIZE);
jerry_release_value (parse_result);
jerry_value_free (parse_result);
TEST_ASSERT (!jerry_value_is_error (generate_result));
TEST_ASSERT (!jerry_value_is_exception (generate_result));
TEST_ASSERT (jerry_value_is_number (generate_result));
size_t snapshot_size = (size_t) jerry_get_number_value (generate_result);
jerry_release_value (generate_result);
size_t snapshot_size = (size_t) jerry_value_as_number (generate_result);
jerry_value_free (generate_result);
const size_t lit_c_buf_sz = jerry_get_literals_from_snapshot (literal_snapshot_buffer,
snapshot_size,
tests/unit-core/test-source-info.c
+36 -36
View File
@@ -25,9 +25,9 @@ compare_string (jerry_value_t left_string, /**< left string */
size_t size = strlen (right_string_p);
uint8_t buffer[64];
TEST_ASSERT (size == jerry_get_string_size (left_string));
TEST_ASSERT (size == jerry_string_size (left_string, JERRY_ENCODING_CESU8));
TEST_ASSERT (size < sizeof (buffer));
TEST_ASSERT (jerry_string_to_char_buffer (left_string, buffer, (jerry_size_t) size) == size);
TEST_ASSERT (jerry_string_to_buffer (left_string, JERRY_ENCODING_CESU8, buffer, (jerry_size_t) size) == size);
TEST_ASSERT (memcmp (buffer, right_string_p, size) == 0);
} /* compare_string */
@@ -38,73 +38,73 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
if (!jerry_is_feature_enabled (JERRY_FEATURE_FUNCTION_TO_STRING))
if (!jerry_feature_enabled (JERRY_FEATURE_FUNCTION_TO_STRING))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Source code is not stored!\n");
jerry_cleanup ();
return 0;
}
jerry_value_t value = jerry_create_null ();
jerry_source_info_t *source_info_p = jerry_get_source_info (value);
jerry_value_t value = jerry_null ();
jerry_source_info_t *source_info_p = jerry_source_info (value);
TEST_ASSERT (source_info_p == NULL);
jerry_free_source_info (source_info_p);
jerry_release_value (value);
jerry_source_info_free (source_info_p);
jerry_value_free (value);
value = jerry_create_object ();
source_info_p = jerry_get_source_info (value);
value = jerry_object ();
source_info_p = jerry_source_info (value);
TEST_ASSERT (source_info_p == NULL);
jerry_free_source_info (source_info_p);
jerry_release_value (value);
jerry_source_info_free (source_info_p);
jerry_value_free (value);
jerry_parse_options_t parse_options;
const char *source_p = TEST_STRING_LITERAL ("var a = 6");
value = jerry_parse ((jerry_char_t *) source_p, strlen (source_p), NULL);
source_info_p = jerry_get_source_info (value);
source_info_p = jerry_source_info (value);
TEST_ASSERT (source_info_p != NULL);
TEST_ASSERT (source_info_p->enabled_fields == JERRY_SOURCE_INFO_HAS_SOURCE_CODE);
compare_string (source_info_p->source_code, source_p);
TEST_ASSERT (jerry_value_is_undefined (source_info_p->function_arguments));
TEST_ASSERT (source_info_p->source_range_start == 0);
TEST_ASSERT (source_info_p->source_range_length == 0);
jerry_free_source_info (source_info_p);
jerry_release_value (value);
jerry_source_info_free (source_info_p);
jerry_value_free (value);
if (jerry_is_feature_enabled (JERRY_FEATURE_MODULE))
if (jerry_feature_enabled (JERRY_FEATURE_MODULE))
{
parse_options.options = JERRY_PARSE_MODULE;
value = jerry_parse ((jerry_char_t *) source_p, strlen (source_p), &parse_options);
jerry_value_t result = jerry_module_link (value, NULL, NULL);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
source_info_p = jerry_get_source_info (value);
source_info_p = jerry_source_info (value);
TEST_ASSERT (source_info_p != NULL);
TEST_ASSERT (source_info_p->enabled_fields == JERRY_SOURCE_INFO_HAS_SOURCE_CODE);
compare_string (source_info_p->source_code, source_p);
TEST_ASSERT (jerry_value_is_undefined (source_info_p->function_arguments));
TEST_ASSERT (source_info_p->source_range_start == 0);
TEST_ASSERT (source_info_p->source_range_length == 0);
jerry_free_source_info (source_info_p);
jerry_source_info_free (source_info_p);
result = jerry_module_evaluate (value);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
/* Byte code is released after a successful evaluation. */
source_info_p = jerry_get_source_info (value);
source_info_p = jerry_source_info (value);
TEST_ASSERT (source_info_p == NULL);
jerry_free_source_info (source_info_p);
jerry_release_value (value);
jerry_source_info_free (source_info_p);
jerry_value_free (value);
}
source_p = TEST_STRING_LITERAL ("( function f() {} )");
value = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), 0);
source_info_p = jerry_get_source_info (value);
source_info_p = jerry_source_info (value);
TEST_ASSERT (source_info_p != NULL);
TEST_ASSERT (source_info_p->enabled_fields
== (JERRY_SOURCE_INFO_HAS_SOURCE_CODE | JERRY_SOURCE_INFO_HAS_SOURCE_RANGE));
@@ -112,13 +112,13 @@ main (void)
TEST_ASSERT (jerry_value_is_undefined (source_info_p->function_arguments));
TEST_ASSERT (source_info_p->source_range_start == 2);
TEST_ASSERT (source_info_p->source_range_length == 15);
jerry_free_source_info (source_info_p);
jerry_release_value (value);
jerry_source_info_free (source_info_p);
jerry_value_free (value);
source_p = TEST_STRING_LITERAL ("new Function('a', 'b', 'return 0;')");
value = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), 0);
source_info_p = jerry_get_source_info (value);
source_info_p = jerry_source_info (value);
TEST_ASSERT (source_info_p != NULL);
TEST_ASSERT (source_info_p->enabled_fields
== (JERRY_SOURCE_INFO_HAS_SOURCE_CODE | JERRY_SOURCE_INFO_HAS_FUNCTION_ARGUMENTS));
@@ -126,13 +126,13 @@ main (void)
compare_string (source_info_p->function_arguments, "a,b");
TEST_ASSERT (source_info_p->source_range_start == 0);
TEST_ASSERT (source_info_p->source_range_length == 0);
jerry_free_source_info (source_info_p);
jerry_release_value (value);
jerry_source_info_free (source_info_p);
jerry_value_free (value);
source_p = TEST_STRING_LITERAL ("(new Function('a = ( function() { } )', 'return a;'))()");
value = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), 0);
source_info_p = jerry_get_source_info (value);
source_info_p = jerry_source_info (value);
TEST_ASSERT (source_info_p != NULL);
TEST_ASSERT (source_info_p->enabled_fields
== (JERRY_SOURCE_INFO_HAS_SOURCE_CODE | JERRY_SOURCE_INFO_HAS_SOURCE_RANGE));
@@ -140,13 +140,13 @@ main (void)
TEST_ASSERT (jerry_value_is_undefined (source_info_p->function_arguments));
TEST_ASSERT (source_info_p->source_range_start == 6);
TEST_ASSERT (source_info_p->source_range_length == 14);
jerry_free_source_info (source_info_p);
jerry_release_value (value);
jerry_source_info_free (source_info_p);
jerry_value_free (value);
source_p = TEST_STRING_LITERAL ("(function f(a) { return 7 }).bind({})");
value = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), 0);
source_info_p = jerry_get_source_info (value);
source_info_p = jerry_source_info (value);
TEST_ASSERT (source_info_p != NULL);
TEST_ASSERT (source_info_p->enabled_fields
== (JERRY_SOURCE_INFO_HAS_SOURCE_CODE | JERRY_SOURCE_INFO_HAS_SOURCE_RANGE));
@@ -154,8 +154,8 @@ main (void)
TEST_ASSERT (jerry_value_is_undefined (source_info_p->function_arguments));
TEST_ASSERT (source_info_p->source_range_start == 1);
TEST_ASSERT (source_info_p->source_range_length == 26);
jerry_free_source_info (source_info_p);
jerry_release_value (value);
jerry_source_info_free (source_info_p);
jerry_value_free (value);
jerry_cleanup ();
return 0;
tests/unit-core/test-special-proxy.c
+14 -14
View File
@@ -26,10 +26,10 @@ create_special_proxy_handler (const jerry_call_info_t *call_info_p, /**< call in
if (args_count < 2)
{
return jerry_create_undefined ();
return jerry_undefined ();
}
return jerry_create_special_proxy (args_p[0], args_p[1], JERRY_PROXY_SKIP_RESULT_VALIDATION);
return jerry_proxy_custom (args_p[0], args_p[1], JERRY_PROXY_SKIP_RESULT_VALIDATION);
} /* create_special_proxy_handler */
static void
@@ -37,8 +37,8 @@ run_eval (const char *source_p)
{
jerry_value_t result = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), 0);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
} /* run_eval */
/**
@@ -49,7 +49,7 @@ main (void)
{
TEST_INIT ();
if (!jerry_is_feature_enabled (JERRY_FEATURE_PROXY))
if (!jerry_feature_enabled (JERRY_FEATURE_PROXY))
{
printf ("Skipping test, Proxy not enabled\n");
return 0;
@@ -57,18 +57,18 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t global = jerry_get_global_object ();
jerry_value_t global = jerry_current_realm ();
jerry_value_t function = jerry_create_external_function (create_special_proxy_handler);
jerry_value_t name = jerry_create_string ((const jerry_char_t *) "create_special_proxy");
jerry_value_t result = jerry_set_property (global, name, function);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_value_t function = jerry_function_external (create_special_proxy_handler);
jerry_value_t name = jerry_string_sz ("create_special_proxy");
jerry_value_t result = jerry_object_set (global, name, function);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_release_value (result);
jerry_release_value (name);
jerry_release_value (function);
jerry_value_free (result);
jerry_value_free (name);
jerry_value_free (function);
jerry_release_value (global);
jerry_value_free (global);
run_eval ("function assert (v) {\n"
" if (v !== true)\n"
tests/unit-core/test-symbol.c
+113 -114
View File
@@ -20,10 +20,10 @@
#include "test-common.h"
/* foo string */
#define STRING_FOO ((const jerry_char_t *) "foo")
#define STRING_FOO ("foo")
/* bar string */
#define STRING_BAR ((const jerry_char_t *) "bar")
#define STRING_BAR ("bar")
/* Symbol(bar) desciptive string */
#define SYMBOL_DESCIPTIVE_STRING_BAR "Symbol(bar)"
@@ -34,7 +34,7 @@
int
main (void)
{
if (!jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
if (!jerry_feature_enabled (JERRY_FEATURE_SYMBOL))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Symbol support is disabled!\n");
return 0;
@@ -42,59 +42,59 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t object = jerry_create_object ();
jerry_value_t object = jerry_object ();
/* Test for that each symbol is unique independently from their descriptor strings */
jerry_value_t symbol_desc_1 = jerry_create_string (STRING_FOO);
jerry_value_t symbol_desc_2 = jerry_create_string (STRING_FOO);
jerry_value_t symbol_desc_1 = jerry_string_sz (STRING_FOO);
jerry_value_t symbol_desc_2 = jerry_string_sz (STRING_FOO);
jerry_value_t symbol_1 = jerry_create_symbol (symbol_desc_1);
TEST_ASSERT (!jerry_value_is_error (symbol_1));
jerry_value_t symbol_1 = jerry_symbol_with_description (symbol_desc_1);
TEST_ASSERT (!jerry_value_is_exception (symbol_1));
TEST_ASSERT (jerry_value_is_symbol (symbol_1));
jerry_value_t symbol_2 = jerry_create_symbol (symbol_desc_2);
TEST_ASSERT (!jerry_value_is_error (symbol_2));
jerry_value_t symbol_2 = jerry_symbol_with_description (symbol_desc_2);
TEST_ASSERT (!jerry_value_is_exception (symbol_2));
TEST_ASSERT (jerry_value_is_symbol (symbol_2));
/* The descriptor strings are no longer needed */
jerry_release_value (symbol_desc_1);
jerry_release_value (symbol_desc_2);
jerry_value_free (symbol_desc_1);
jerry_value_free (symbol_desc_2);
jerry_value_t value_1 = jerry_create_number (1);
jerry_value_t value_2 = jerry_create_number (2);
jerry_value_t value_1 = jerry_number (1);
jerry_value_t value_2 = jerry_number (2);
jerry_value_t result_val = jerry_set_property (object, symbol_1, value_1);
jerry_value_t result_val = jerry_object_set (object, symbol_1, value_1);
TEST_ASSERT (jerry_value_is_boolean (result_val));
TEST_ASSERT (jerry_value_is_true (jerry_has_property (object, symbol_1)));
TEST_ASSERT (jerry_value_is_true (jerry_has_own_property (object, symbol_1)));
TEST_ASSERT (jerry_value_is_true (jerry_object_has (object, symbol_1)));
TEST_ASSERT (jerry_value_is_true (jerry_object_has_own (object, symbol_1)));
result_val = jerry_set_property (object, symbol_2, value_2);
result_val = jerry_object_set (object, symbol_2, value_2);
TEST_ASSERT (jerry_value_is_boolean (result_val));
TEST_ASSERT (jerry_value_is_true (jerry_has_property (object, symbol_2)));
TEST_ASSERT (jerry_value_is_true (jerry_has_own_property (object, symbol_2)));
TEST_ASSERT (jerry_value_is_true (jerry_object_has (object, symbol_2)));
TEST_ASSERT (jerry_value_is_true (jerry_object_has_own (object, symbol_2)));
jerry_value_t get_value_1 = jerry_get_property (object, symbol_1);
TEST_ASSERT (jerry_get_number_value (get_value_1) == jerry_get_number_value (value_1));
jerry_release_value (get_value_1);
jerry_value_t get_value_1 = jerry_object_get (object, symbol_1);
TEST_ASSERT (jerry_value_as_number (get_value_1) == jerry_value_as_number (value_1));
jerry_value_free (get_value_1);
jerry_value_t get_value_2 = jerry_get_property (object, symbol_2);
TEST_ASSERT (jerry_get_number_value (get_value_2) == jerry_get_number_value (value_2));
jerry_release_value (get_value_2);
jerry_value_t get_value_2 = jerry_object_get (object, symbol_2);
TEST_ASSERT (jerry_value_as_number (get_value_2) == jerry_value_as_number (value_2));
jerry_value_free (get_value_2);
/* Test delete / has_{own}_property */
TEST_ASSERT (jerry_delete_property (object, symbol_1));
TEST_ASSERT (!jerry_value_is_true (jerry_has_property (object, symbol_1)));
TEST_ASSERT (!jerry_value_is_true (jerry_has_own_property (object, symbol_1)));
TEST_ASSERT (jerry_value_is_true (jerry_object_delete (object, symbol_1)));
TEST_ASSERT (!jerry_value_is_true (jerry_object_has (object, symbol_1)));
TEST_ASSERT (!jerry_value_is_true (jerry_object_has_own (object, symbol_1)));
jerry_release_value (value_1);
jerry_release_value (symbol_1);
jerry_value_free (value_1);
jerry_value_free (symbol_1);
/* Test {get, define}_own_property_descriptor */
jerry_property_descriptor_t prop_desc;
TEST_ASSERT (jerry_get_own_property_descriptor (object, symbol_2, &prop_desc));
TEST_ASSERT (jerry_object_get_own_prop (object, symbol_2, &prop_desc));
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_VALUE_DEFINED);
TEST_ASSERT (value_2 == prop_desc.value);
TEST_ASSERT (jerry_get_number_value (value_2) == jerry_get_number_value (prop_desc.value));
TEST_ASSERT (jerry_value_as_number (value_2) == jerry_value_as_number (prop_desc.value));
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_WRITABLE);
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_ENUMERABLE);
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE);
@@ -105,17 +105,17 @@ main (void)
jerry_property_descriptor_free (&prop_desc);
/* Modify the descriptor fields */
prop_desc = jerry_property_descriptor_create ();
jerry_value_t value_3 = jerry_create_string (STRING_BAR);
prop_desc = jerry_property_descriptor ();
jerry_value_t value_3 = jerry_string_sz (STRING_BAR);
prop_desc.flags |= JERRY_PROP_IS_VALUE_DEFINED | JERRY_PROP_IS_WRITABLE_DEFINED | JERRY_PROP_IS_ENUMERABLE_DEFINED
| JERRY_PROP_IS_CONFIGURABLE_DEFINED;
prop_desc.value = jerry_acquire_value (value_3);
TEST_ASSERT (jerry_value_is_true (jerry_define_own_property (object, symbol_2, &prop_desc)));
prop_desc.value = jerry_value_copy (value_3);
TEST_ASSERT (jerry_value_is_true (jerry_object_define_own_prop (object, symbol_2, &prop_desc)));
jerry_property_descriptor_free (&prop_desc);
/* Check the modified fields */
TEST_ASSERT (jerry_get_own_property_descriptor (object, symbol_2, &prop_desc));
TEST_ASSERT (jerry_object_get_own_prop (object, symbol_2, &prop_desc));
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_VALUE_DEFINED);
TEST_ASSERT (value_3 == prop_desc.value);
TEST_ASSERT (jerry_value_is_string (prop_desc.value));
@@ -131,88 +131,88 @@ main (void)
TEST_ASSERT (jerry_value_is_undefined (prop_desc.setter));
jerry_property_descriptor_free (&prop_desc);
jerry_release_value (value_3);
jerry_release_value (value_2);
jerry_release_value (symbol_2);
jerry_release_value (object);
jerry_value_free (value_3);
jerry_value_free (value_2);
jerry_value_free (symbol_2);
jerry_value_free (object);
/* Test creating symbol with a symbol description */
jerry_value_t empty_symbol_desc = jerry_create_string ((const jerry_char_t *) "");
jerry_value_t empty_symbol_desc = jerry_string_sz ("");
jerry_value_t empty_symbol = jerry_create_symbol (empty_symbol_desc);
TEST_ASSERT (!jerry_value_is_error (empty_symbol));
jerry_value_t empty_symbol = jerry_symbol_with_description (empty_symbol_desc);
TEST_ASSERT (!jerry_value_is_exception (empty_symbol));
TEST_ASSERT (jerry_value_is_symbol (empty_symbol));
jerry_release_value (empty_symbol_desc);
jerry_value_free (empty_symbol_desc);
jerry_value_t symbol_symbol = jerry_create_symbol (empty_symbol);
jerry_value_t symbol_symbol = jerry_symbol_with_description (empty_symbol);
TEST_ASSERT (!jerry_value_is_symbol (symbol_symbol));
TEST_ASSERT (jerry_value_is_error (symbol_symbol));
TEST_ASSERT (jerry_value_is_exception (symbol_symbol));
jerry_value_t error_obj = jerry_get_value_from_error (symbol_symbol, true);
jerry_value_t error_obj = jerry_exception_value (symbol_symbol, true);
TEST_ASSERT (jerry_get_error_type (error_obj) == JERRY_ERROR_TYPE);
TEST_ASSERT (jerry_error_type (error_obj) == JERRY_ERROR_TYPE);
jerry_release_value (error_obj);
jerry_release_value (empty_symbol);
jerry_value_free (error_obj);
jerry_value_free (empty_symbol);
/* Test symbol to string operation with symbol argument */
jerry_value_t bar_symbol_desc = jerry_create_string (STRING_BAR);
jerry_value_t bar_symbol_desc = jerry_string_sz (STRING_BAR);
jerry_value_t bar_symbol = jerry_create_symbol (bar_symbol_desc);
TEST_ASSERT (!jerry_value_is_error (bar_symbol));
jerry_value_t bar_symbol = jerry_symbol_with_description (bar_symbol_desc);
TEST_ASSERT (!jerry_value_is_exception (bar_symbol));
TEST_ASSERT (jerry_value_is_symbol (bar_symbol));
jerry_release_value (bar_symbol_desc);
jerry_value_free (bar_symbol_desc);
jerry_value_t bar_symbol_string = jerry_get_symbol_descriptive_string (bar_symbol);
jerry_value_t bar_symbol_string = jerry_symbol_descriptive_string (bar_symbol);
TEST_ASSERT (jerry_value_is_string (bar_symbol_string));
jerry_size_t bar_symbol_string_size = jerry_get_string_size (bar_symbol_string);
jerry_size_t bar_symbol_string_size = jerry_string_size (bar_symbol_string, JERRY_ENCODING_CESU8);
TEST_ASSERT (bar_symbol_string_size == (sizeof (SYMBOL_DESCIPTIVE_STRING_BAR) - 1));
JERRY_VLA (jerry_char_t, str_buff, bar_symbol_string_size);
jerry_string_to_char_buffer (bar_symbol_string, str_buff, bar_symbol_string_size);
jerry_string_to_buffer (bar_symbol_string, JERRY_ENCODING_CESU8, str_buff, bar_symbol_string_size);
TEST_ASSERT (memcmp (str_buff, SYMBOL_DESCIPTIVE_STRING_BAR, sizeof (SYMBOL_DESCIPTIVE_STRING_BAR) - 1) == 0);
jerry_release_value (bar_symbol_string);
jerry_value_free (bar_symbol_string);
/* Test symbol get description operation with string description */
bar_symbol_string = jerry_get_symbol_description (bar_symbol);
bar_symbol_string = jerry_symbol_description (bar_symbol);
TEST_ASSERT (jerry_value_is_string (bar_symbol_string));
bar_symbol_string_size = jerry_get_string_size (bar_symbol_string);
bar_symbol_string_size = jerry_string_size (bar_symbol_string, JERRY_ENCODING_CESU8);
TEST_ASSERT (bar_symbol_string_size == (sizeof (SYMBOL_DESCIPTION_BAR) - 1));
jerry_string_to_char_buffer (bar_symbol_string, str_buff, bar_symbol_string_size);
jerry_string_to_buffer (bar_symbol_string, JERRY_ENCODING_CESU8, str_buff, bar_symbol_string_size);
TEST_ASSERT (memcmp (str_buff, STRING_BAR, sizeof (SYMBOL_DESCIPTION_BAR) - 1) == 0);
jerry_release_value (bar_symbol_string);
jerry_release_value (bar_symbol);
jerry_value_free (bar_symbol_string);
jerry_value_free (bar_symbol);
/* Test symbol get description operation with undefined description */
jerry_value_t undefined_value = jerry_create_undefined ();
jerry_value_t undefined_symbol = jerry_create_symbol (undefined_value);
jerry_release_value (undefined_value);
TEST_ASSERT (!jerry_value_is_error (bar_symbol));
jerry_value_t undefined_value = jerry_undefined ();
jerry_value_t undefined_symbol = jerry_symbol_with_description (undefined_value);
jerry_value_free (undefined_value);
TEST_ASSERT (!jerry_value_is_exception (bar_symbol));
TEST_ASSERT (jerry_value_is_symbol (bar_symbol));
undefined_value = jerry_get_symbol_description (undefined_symbol);
undefined_value = jerry_symbol_description (undefined_symbol);
TEST_ASSERT (jerry_value_is_undefined (undefined_value));
jerry_release_value (undefined_value);
jerry_release_value (undefined_symbol);
jerry_value_free (undefined_value);
jerry_value_free (undefined_symbol);
/* Test symbol to string operation with non-symbol argument */
jerry_value_t null_value = jerry_create_null ();
jerry_value_t to_string_value = jerry_get_symbol_descriptive_string (null_value);
TEST_ASSERT (jerry_value_is_error (to_string_value));
jerry_value_t null_value = jerry_null ();
jerry_value_t to_string_value = jerry_symbol_descriptive_string (null_value);
TEST_ASSERT (jerry_value_is_exception (to_string_value));
error_obj = jerry_get_value_from_error (to_string_value, true);
error_obj = jerry_exception_value (to_string_value, true);
TEST_ASSERT (jerry_get_error_type (error_obj) == JERRY_ERROR_TYPE);
TEST_ASSERT (jerry_error_type (error_obj) == JERRY_ERROR_TYPE);
jerry_release_value (error_obj);
jerry_release_value (null_value);
jerry_value_free (error_obj);
jerry_value_free (null_value);
const jerry_char_t obj_src[] = ""
"({"
@@ -239,9 +239,9 @@ main (void)
jerry_value_t obj = jerry_eval (obj_src, sizeof (obj_src) - 1, JERRY_PARSE_NO_OPTS);
TEST_ASSERT (jerry_value_is_object (obj));
jerry_value_t global_obj = jerry_get_global_object ();
jerry_value_t symbol_str = jerry_create_string ((const jerry_char_t *) "Symbol");
jerry_value_t builtin_symbol = jerry_get_property (global_obj, symbol_str);
jerry_value_t global_obj = jerry_current_realm ();
jerry_value_t symbol_str = jerry_string_sz ("Symbol");
jerry_value_t builtin_symbol = jerry_object_get (global_obj, symbol_str);
TEST_ASSERT (jerry_value_is_object (builtin_symbol));
double expected = 1.0;
@@ -250,49 +250,48 @@ main (void)
for (jerry_well_known_symbol_t id = JERRY_SYMBOL_ASYNC_ITERATOR; id <= JERRY_SYMBOL_MATCH_ALL;
id++, expected++, prop_index++)
{
jerry_value_t well_known_symbol = jerry_get_well_known_symbol (id);
jerry_value_t well_known_symbol = jerry_symbol (id);
jerry_value_t prop_str = jerry_create_string ((const jerry_char_t *) symbols[prop_index]);
jerry_value_t current_global_symbol = jerry_get_property (builtin_symbol, prop_str);
jerry_release_value (prop_str);
jerry_value_t prop_str = jerry_string_sz (symbols[prop_index]);
jerry_value_t current_global_symbol = jerry_object_get (builtin_symbol, prop_str);
jerry_value_free (prop_str);
jerry_value_t relation =
jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, well_known_symbol, current_global_symbol);
jerry_value_t relation = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, well_known_symbol, current_global_symbol);
TEST_ASSERT (jerry_value_is_boolean (relation) && jerry_value_is_true (relation));
jerry_release_value (relation);
jerry_value_free (relation);
jerry_value_t prop_result_wn = jerry_get_property (obj, well_known_symbol);
jerry_value_t prop_result_global = jerry_get_property (obj, current_global_symbol);
jerry_value_t prop_result_wn = jerry_object_get (obj, well_known_symbol);
jerry_value_t prop_result_global = jerry_object_get (obj, current_global_symbol);
TEST_ASSERT (jerry_value_is_number (prop_result_wn));
double number_wn = jerry_get_number_value (prop_result_wn);
double number_wn = jerry_value_as_number (prop_result_wn);
TEST_ASSERT (number_wn == expected);
TEST_ASSERT (jerry_value_is_number (prop_result_global));
double number_global = jerry_get_number_value (prop_result_global);
double number_global = jerry_value_as_number (prop_result_global);
TEST_ASSERT (number_global == expected);
jerry_release_value (prop_result_global);
jerry_release_value (prop_result_wn);
jerry_release_value (current_global_symbol);
jerry_release_value (well_known_symbol);
jerry_value_free (prop_result_global);
jerry_value_free (prop_result_wn);
jerry_value_free (current_global_symbol);
jerry_value_free (well_known_symbol);
}
jerry_release_value (builtin_symbol);
jerry_value_free (builtin_symbol);
/* Deletion of the 'Symbol' builtin makes the well-known symbols unaccessible from JS context
but the symbols still can be obtained via 'jerry_get_well_known_symbol' */
but the symbols still can be obtained via 'jerry_symbol' */
const jerry_char_t deleter_src[] = "delete Symbol";
jerry_value_t deleter = jerry_eval (deleter_src, sizeof (deleter_src) - 1, JERRY_PARSE_NO_OPTS);
TEST_ASSERT (jerry_value_is_boolean (deleter) && jerry_value_is_true (deleter));
jerry_release_value (deleter);
jerry_value_free (deleter);
builtin_symbol = jerry_get_property (global_obj, symbol_str);
builtin_symbol = jerry_object_get (global_obj, symbol_str);
TEST_ASSERT (jerry_value_is_undefined (builtin_symbol));
jerry_release_value (builtin_symbol);
jerry_value_free (builtin_symbol);
expected = 1.0;
prop_index = 0;
@@ -300,30 +299,30 @@ main (void)
for (jerry_well_known_symbol_t id = JERRY_SYMBOL_ASYNC_ITERATOR; id <= JERRY_SYMBOL_MATCH_ALL;
id++, expected++, prop_index++)
{
jerry_value_t well_known_symbol = jerry_get_well_known_symbol (id);
jerry_value_t prop_result_wn = jerry_get_property (obj, well_known_symbol);
jerry_value_t well_known_symbol = jerry_symbol (id);
jerry_value_t prop_result_wn = jerry_object_get (obj, well_known_symbol);
TEST_ASSERT (jerry_value_is_number (prop_result_wn));
double number_wn = jerry_get_number_value (prop_result_wn);
double number_wn = jerry_value_as_number (prop_result_wn);
TEST_ASSERT (number_wn == expected);
jerry_release_value (prop_result_wn);
jerry_release_value (well_known_symbol);
jerry_value_free (prop_result_wn);
jerry_value_free (well_known_symbol);
}
jerry_well_known_symbol_t invalid_symbol = (jerry_well_known_symbol_t) (JERRY_SYMBOL_MATCH_ALL + 1);
jerry_value_t invalid_well_known_symbol = jerry_get_well_known_symbol (invalid_symbol);
jerry_value_t invalid_well_known_symbol = jerry_symbol (invalid_symbol);
TEST_ASSERT (jerry_value_is_undefined (invalid_well_known_symbol));
jerry_release_value (invalid_well_known_symbol);
jerry_value_free (invalid_well_known_symbol);
invalid_symbol = (jerry_well_known_symbol_t) (JERRY_SYMBOL_ASYNC_ITERATOR - 1);
invalid_well_known_symbol = jerry_get_well_known_symbol (invalid_symbol);
invalid_well_known_symbol = jerry_symbol (invalid_symbol);
TEST_ASSERT (jerry_value_is_undefined (invalid_well_known_symbol));
jerry_release_value (invalid_well_known_symbol);
jerry_value_free (invalid_well_known_symbol);
jerry_release_value (symbol_str);
jerry_release_value (global_obj);
jerry_release_value (obj);
jerry_value_free (symbol_str);
jerry_value_free (global_obj);
jerry_value_free (obj);
jerry_cleanup ();
tests/unit-core/test-to-integer.c
+1 -2
View File
@@ -49,8 +49,7 @@ main (void)
TEST_ASSERT (num == 123);
/* 2 */
ecma_value_t error =
ecma_raise_standard_error (JERRY_ERROR_TYPE, (const lit_utf8_byte_t *) "I am a neat little error message");
ecma_value_t error = ecma_raise_standard_error (JERRY_ERROR_TYPE, "I am a neat little error message");
result = ecma_op_to_integer (error, &num);
tests/unit-core/test-to-length.c
+1 -1
View File
@@ -51,7 +51,7 @@ main (void)
TEST_ASSERT (num == 123);
/* 1, 3 */
ecma_value_t error_throw = ecma_raise_standard_error (JERRY_ERROR_TYPE, (const lit_utf8_byte_t *) "I'm an error");
ecma_value_t error_throw = ecma_raise_standard_error (JERRY_ERROR_TYPE, "I'm an error");
result = ecma_op_to_length (error_throw, &num);
tests/unit-core/test-to-property-descriptor.c
+23 -23
View File
@@ -31,8 +31,8 @@ check_attribute (jerry_value_t attribute, /**< attribute to be checked */
jerry_value_t object, /**< original object */
const char *name_p) /**< name of the attribute */
{
jerry_value_t prop_name = jerry_create_string_from_utf8 ((const jerry_char_t *) name_p);
jerry_value_t value = jerry_get_property (object, prop_name);
jerry_value_t prop_name = jerry_string_sz (name_p);
jerry_value_t value = jerry_object_get (object, prop_name);
if (jerry_value_is_undefined (value))
{
@@ -40,23 +40,23 @@ check_attribute (jerry_value_t attribute, /**< attribute to be checked */
}
else
{
jerry_value_t result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, attribute, value);
jerry_value_t result = jerry_binary_op (JERRY_BIN_OP_STRICT_EQUAL, attribute, value);
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
}
jerry_release_value (value);
jerry_release_value (prop_name);
jerry_value_free (value);
jerry_value_free (prop_name);
} /* check_attribute */
static jerry_property_descriptor_t
to_property_descriptor (jerry_value_t object /**< object */)
{
jerry_property_descriptor_t prop_desc = jerry_property_descriptor_create ();
jerry_property_descriptor_t prop_desc = jerry_property_descriptor ();
jerry_value_t result = jerry_to_property_descriptor (object, &prop_desc);
jerry_value_t result = jerry_property_descriptor_from_object (object, &prop_desc);
TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
return prop_desc;
} /* to_property_descriptor */
@@ -86,7 +86,7 @@ main (void)
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE_DEFINED);
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE);
jerry_release_value (object);
jerry_value_free (object);
jerry_property_descriptor_free (&prop_desc);
/* Next test. */
@@ -104,7 +104,7 @@ main (void)
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE_DEFINED);
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE);
jerry_release_value (object);
jerry_value_free (object);
jerry_property_descriptor_free (&prop_desc);
/* Next test. */
@@ -126,7 +126,7 @@ main (void)
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE_DEFINED);
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE);
jerry_release_value (object);
jerry_value_free (object);
jerry_property_descriptor_free (&prop_desc);
/* Next test. */
@@ -145,7 +145,7 @@ main (void)
TEST_ASSERT (!(prop_desc.flags & JERRY_PROP_IS_ENUMERABLE));
TEST_ASSERT (!(prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE_DEFINED));
jerry_release_value (object);
jerry_value_free (object);
jerry_property_descriptor_free (&prop_desc);
/* Next test. */
@@ -165,23 +165,23 @@ main (void)
TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE_DEFINED);
TEST_ASSERT (!(prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE));
jerry_release_value (object);
jerry_value_free (object);
jerry_property_descriptor_free (&prop_desc);
/* Next test. */
source_p = "({ get: function(v) {}, writable:true })";
object = create_property_descriptor (source_p);
jerry_value_t result = jerry_to_property_descriptor (object, &prop_desc);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
jerry_release_value (object);
jerry_value_t result = jerry_property_descriptor_from_object (object, &prop_desc);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
jerry_value_free (object);
/* Next test. */
object = jerry_create_null ();
result = jerry_to_property_descriptor (object, &prop_desc);
TEST_ASSERT (jerry_value_is_error (result));
jerry_release_value (result);
jerry_release_value (object);
object = jerry_null ();
result = jerry_property_descriptor_from_object (object, &prop_desc);
TEST_ASSERT (jerry_value_is_exception (result));
jerry_value_free (result);
jerry_value_free (object);
jerry_cleanup ();
return 0;
tests/unit-core/test-typedarray.c
+170 -177
View File
@@ -39,15 +39,15 @@ static void
register_js_value (const char *name_p, /**< name of the function */
jerry_value_t value) /**< function callback */
{
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t name_val = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t result_val = jerry_set_property (global_obj_val, name_val, value);
jerry_value_t name_val = jerry_string_sz (name_p);
jerry_value_t result_val = jerry_object_set (global_obj_val, name_val, value);
jerry_release_value (name_val);
jerry_release_value (global_obj_val);
jerry_value_free (name_val);
jerry_value_free (global_obj_val);
jerry_release_value (result_val);
jerry_value_free (result_val);
} /* register_js_value */
static jerry_value_t
@@ -59,20 +59,18 @@ assert_handler (const jerry_call_info_t *call_info_p, /**< call information */
if (jerry_value_is_true (args_p[0]))
{
return jerry_create_boolean (true);
return jerry_boolean (true);
}
else
{
if (args_cnt > 1 && jerry_value_is_string (args_p[1]))
{
jerry_length_t utf8_sz = jerry_get_string_size (args_p[1]);
TEST_ASSERT (utf8_sz <= 127); /* 127 is the expected max assert fail message size. */
JERRY_VLA (char, string_from_utf8, utf8_sz + 1);
string_from_utf8[utf8_sz] = 0;
jerry_char_t utf8_string[128];
jerry_size_t copied =
jerry_string_to_buffer (args_p[1], JERRY_ENCODING_UTF8, utf8_string, sizeof (utf8_string) - 1);
utf8_string[copied] = '\0';
jerry_string_to_char_buffer (args_p[1], (jerry_char_t *) string_from_utf8, utf8_sz);
printf ("JS assert: %s\n", string_from_utf8);
printf ("JS assert: %s\n", utf8_string);
}
TEST_ASSERT (false);
}
@@ -87,20 +85,20 @@ test_typedarray_info (jerry_value_t typedarray, /**< target TypedArray to query
jerry_length_t element_count, /**< expected element count */
jerry_length_t bytes_per_element) /**< bytes per element for the given type */
{
TEST_ASSERT (!jerry_value_is_error (typedarray));
TEST_ASSERT (!jerry_value_is_exception (typedarray));
TEST_ASSERT (jerry_value_is_typedarray (typedarray));
TEST_ASSERT (jerry_get_typedarray_type (typedarray) == typedarray_type);
TEST_ASSERT (jerry_get_typedarray_length (typedarray) == element_count);
TEST_ASSERT (jerry_typedarray_type (typedarray) == typedarray_type);
TEST_ASSERT (jerry_typedarray_length (typedarray) == element_count);
jerry_length_t byte_length = (uint32_t) -1;
jerry_length_t byte_offset = (uint32_t) -1;
jerry_value_t arraybuffer = jerry_get_typedarray_buffer (typedarray, &byte_offset, &byte_length);
jerry_value_t arraybuffer = jerry_typedarray_buffer (typedarray, &byte_offset, &byte_length);
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (byte_length == element_count * bytes_per_element);
TEST_ASSERT (byte_offset == 0);
jerry_release_value (arraybuffer);
jerry_value_free (arraybuffer);
} /* test_typedarray_info */
/**
@@ -109,43 +107,42 @@ test_typedarray_info (jerry_value_t typedarray, /**< target TypedArray to query
static void
test_typedarray_queries (test_entry_t test_entries[]) /**< test cases */
{
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t global_obj_val = jerry_current_realm ();
for (uint32_t i = 0; test_entries[i].constructor_name != NULL; i++)
{
/* Create TypedArray via construct call */
{
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) test_entries[i].constructor_name);
jerry_value_t prop_value = jerry_get_property (global_obj_val, prop_name);
TEST_ASSERT (!jerry_value_is_error (prop_value));
jerry_value_t length_arg = jerry_create_number (test_entries[i].element_count);
jerry_value_t prop_name = jerry_string_sz (test_entries[i].constructor_name);
jerry_value_t prop_value = jerry_object_get (global_obj_val, prop_name);
TEST_ASSERT (!jerry_value_is_exception (prop_value));
jerry_value_t length_arg = jerry_number (test_entries[i].element_count);
jerry_value_t typedarray = jerry_construct_object (prop_value, &length_arg, 1);
jerry_value_t typedarray = jerry_construct (prop_value, &length_arg, 1);
jerry_release_value (prop_name);
jerry_release_value (prop_value);
jerry_release_value (length_arg);
jerry_value_free (prop_name);
jerry_value_free (prop_value);
jerry_value_free (length_arg);
test_typedarray_info (typedarray,
test_entries[i].typedarray_type,
test_entries[i].element_count,
test_entries[i].bytes_per_element);
jerry_release_value (typedarray);
jerry_value_free (typedarray);
}
/* Create TypedArray via api call */
{
jerry_value_t typedarray =
jerry_create_typedarray (test_entries[i].typedarray_type, test_entries[i].element_count);
jerry_value_t typedarray = jerry_typedarray (test_entries[i].typedarray_type, test_entries[i].element_count);
test_typedarray_info (typedarray,
test_entries[i].typedarray_type,
test_entries[i].element_count,
test_entries[i].bytes_per_element);
jerry_release_value (typedarray);
jerry_value_free (typedarray);
}
}
jerry_release_value (global_obj_val);
jerry_value_free (global_obj_val);
} /* test_typedarray_queries */
/**
@@ -242,28 +239,26 @@ test_typedarray_complex_creation (test_entry_t test_entries[], /**< test cases *
if (use_external_buffer)
{
buffer_p = (uint8_t *) jerry_heap_alloc (arraybuffer_size);
arraybuffer = jerry_create_arraybuffer_external (arraybuffer_size, buffer_p, NULL);
arraybuffer = jerry_arraybuffer_external (buffer_p, arraybuffer_size, NULL);
}
else
{
arraybuffer = jerry_create_arraybuffer (arraybuffer_size);
arraybuffer = jerry_arraybuffer (arraybuffer_size);
}
jerry_value_t js_offset = jerry_create_number (offset);
jerry_value_t js_element_count = jerry_create_number (element_count);
jerry_value_t js_offset = jerry_number (offset);
jerry_value_t js_element_count = jerry_number (element_count);
register_js_value ("expected_offset", js_offset);
register_js_value ("expected_length", js_element_count);
typedarray = jerry_create_typedarray_for_arraybuffer_sz (test_entries[i].typedarray_type,
arraybuffer,
offset,
element_count);
TEST_ASSERT (!jerry_value_is_error (typedarray));
typedarray =
jerry_typedarray_with_buffer_span (test_entries[i].typedarray_type, arraybuffer, offset, element_count);
TEST_ASSERT (!jerry_value_is_exception (typedarray));
jerry_release_value (js_offset);
jerry_release_value (js_element_count);
jerry_release_value (arraybuffer);
jerry_value_free (js_offset);
jerry_value_free (js_element_count);
jerry_value_free (arraybuffer);
}
register_js_value ("array", typedarray);
@@ -273,8 +268,8 @@ test_typedarray_complex_creation (test_entry_t test_entries[], /**< test cases *
" 'expected length: ' + expected_length + ' got: ' + array.length);"
"assert (array.byteOffset == expected_offset);");
jerry_value_t result = jerry_eval (test_exptected_src, sizeof (test_exptected_src) - 1, JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
const jerry_char_t set_element_src[] = TEST_STRING_LITERAL ("array[0] = 0x11223344n");
@@ -288,19 +283,19 @@ test_typedarray_complex_creation (test_entry_t test_entries[], /**< test cases *
}
result = jerry_eval (set_element_src, src_length, JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
{
jerry_length_t byte_length = 0;
jerry_length_t byte_offset = 0;
jerry_value_t buffer = jerry_get_typedarray_buffer (typedarray, &byte_offset, &byte_length);
jerry_value_t buffer = jerry_typedarray_buffer (typedarray, &byte_offset, &byte_length);
TEST_ASSERT (byte_length == element_count * bytes_per_element);
TEST_ASSERT (byte_offset == offset);
JERRY_VLA (uint8_t, test_buffer, arraybuffer_size);
jerry_typedarray_type_t type = jerry_get_typedarray_type (typedarray);
jerry_typedarray_type_t type = jerry_typedarray_type (typedarray);
jerry_value_t read_count = jerry_arraybuffer_read (buffer, 0, test_buffer, offset + byte_length);
TEST_ASSERT (read_count == offset + byte_length);
test_buffer_value (0x11223344, test_buffer, offset, type, bytes_per_element);
@@ -311,10 +306,10 @@ test_typedarray_complex_creation (test_entry_t test_entries[], /**< test cases *
TEST_ASSERT (memcmp (buffer_p, test_buffer, offset + byte_length) == 0);
}
jerry_release_value (buffer);
jerry_value_free (buffer);
}
jerry_release_value (typedarray);
jerry_value_free (typedarray);
}
} /* test_typedarray_complex_creation */
@@ -334,8 +329,8 @@ test_property_by_index (test_entry_t test_entries[])
{
jerry_value_t test_number;
uint32_t test_numbers_length = sizeof (test_int_numbers) / sizeof (int);
jerry_value_t typedarray = jerry_create_typedarray (test_entries[i].typedarray_type, test_numbers_length);
jerry_typedarray_type_t type = jerry_get_typedarray_type (typedarray);
jerry_value_t typedarray = jerry_typedarray (test_entries[i].typedarray_type, test_numbers_length);
jerry_typedarray_type_t type = jerry_typedarray_type (typedarray);
jerry_value_t set_result;
jerry_value_t get_result;
@@ -348,19 +343,19 @@ test_property_by_index (test_entry_t test_entries[])
{
for (uint8_t j = 0; j < test_numbers_length; j++)
{
test_number = jerry_create_number (test_int_numbers[j]);
TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
set_result = jerry_set_property_by_index (typedarray, j, test_number);
get_result = jerry_get_property_by_index (typedarray, j);
test_number = jerry_number (test_int_numbers[j]);
TEST_ASSERT (jerry_value_is_false (jerry_object_delete_index (typedarray, j)));
set_result = jerry_object_set_index (typedarray, j, test_number);
get_result = jerry_object_get_index (typedarray, j);
TEST_ASSERT (jerry_value_is_boolean (set_result));
TEST_ASSERT (jerry_value_is_true (set_result));
TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
TEST_ASSERT (jerry_get_number_value (get_result) == test_int_numbers[j]);
TEST_ASSERT (jerry_value_is_false (jerry_object_delete_index (typedarray, j)));
TEST_ASSERT (jerry_value_as_number (get_result) == test_int_numbers[j]);
jerry_release_value (test_number);
jerry_release_value (set_result);
jerry_release_value (get_result);
jerry_value_free (test_number);
jerry_value_free (set_result);
jerry_value_free (get_result);
}
break;
}
@@ -369,36 +364,36 @@ test_property_by_index (test_entry_t test_entries[])
{
for (uint8_t j = 0; j < test_numbers_length; j++)
{
test_number = jerry_create_number (test_double_numbers[j]);
TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
set_result = jerry_set_property_by_index (typedarray, j, test_number);
get_result = jerry_get_property_by_index (typedarray, j);
test_number = jerry_number (test_double_numbers[j]);
TEST_ASSERT (jerry_value_is_false (jerry_object_delete_index (typedarray, j)));
set_result = jerry_object_set_index (typedarray, j, test_number);
get_result = jerry_object_get_index (typedarray, j);
TEST_ASSERT (jerry_value_is_boolean (set_result));
TEST_ASSERT (jerry_value_is_true (set_result));
TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
TEST_ASSERT (jerry_value_is_false (jerry_object_delete_index (typedarray, j)));
double epsilon = pow (10, -5);
double get_abs = fabs (jerry_get_number_value (get_result) - test_double_numbers[j]);
double get_abs = fabs (jerry_value_as_number (get_result) - test_double_numbers[j]);
TEST_ASSERT (get_abs < epsilon);
jerry_release_value (test_number);
jerry_release_value (set_result);
jerry_release_value (get_result);
jerry_value_free (test_number);
jerry_value_free (set_result);
jerry_value_free (get_result);
/* Testing positive and negative infinity */
for (uint8_t k = 0; k < 2; k++)
{
jerry_value_t inf = jerry_create_number_infinity (k);
jerry_value_t set_inf = jerry_set_property_by_index (typedarray, 0, inf);
jerry_value_t inf = jerry_infinity (k);
jerry_value_t set_inf = jerry_object_set_index (typedarray, 0, inf);
TEST_ASSERT (jerry_value_is_boolean (set_inf));
TEST_ASSERT (jerry_value_is_true (set_inf));
jerry_value_t get_inf = jerry_get_property_by_index (typedarray, 0);
TEST_ASSERT (isinf (jerry_get_number_value (get_inf)));
jerry_value_t get_inf = jerry_object_get_index (typedarray, 0);
TEST_ASSERT (isinf (jerry_value_as_number (get_inf)));
jerry_release_value (inf);
jerry_release_value (set_inf);
jerry_release_value (get_inf);
jerry_value_free (inf);
jerry_value_free (set_inf);
jerry_value_free (get_inf);
}
}
break;
@@ -407,23 +402,23 @@ test_property_by_index (test_entry_t test_entries[])
{
for (uint8_t j = 0; j < test_numbers_length; j++)
{
test_number = jerry_create_bigint ((uint64_t *) &test_int64_numbers[j], 1, true);
TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
set_result = jerry_set_property_by_index (typedarray, j, test_number);
get_result = jerry_get_property_by_index (typedarray, j);
test_number = jerry_bigint ((uint64_t *) &test_int64_numbers[j], 1, true);
TEST_ASSERT (jerry_value_is_false (jerry_object_delete_index (typedarray, j)));
set_result = jerry_object_set_index (typedarray, j, test_number);
get_result = jerry_object_get_index (typedarray, j);
TEST_ASSERT (jerry_value_is_boolean (set_result));
TEST_ASSERT (jerry_value_is_true (set_result));
TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
TEST_ASSERT (jerry_value_is_false (jerry_object_delete_index (typedarray, j)));
int64_t get_number;
bool sign;
jerry_get_bigint_digits (get_result, (uint64_t *) &get_number, 1, &sign);
jerry_bigint_to_digits (get_result, (uint64_t *) &get_number, 1, &sign);
TEST_ASSERT (sign ? get_number : -get_number == test_int64_numbers[j]);
jerry_release_value (test_number);
jerry_release_value (set_result);
jerry_release_value (get_result);
jerry_value_free (test_number);
jerry_value_free (set_result);
jerry_value_free (get_result);
}
break;
}
@@ -431,23 +426,23 @@ test_property_by_index (test_entry_t test_entries[])
{
for (uint8_t j = 0; j < test_numbers_length; j++)
{
test_number = jerry_create_bigint (&test_uint64_numbers[j], 1, false);
TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
set_result = jerry_set_property_by_index (typedarray, j, test_number);
get_result = jerry_get_property_by_index (typedarray, j);
test_number = jerry_bigint (&test_uint64_numbers[j], 1, false);
TEST_ASSERT (jerry_value_is_false (jerry_object_delete_index (typedarray, j)));
set_result = jerry_object_set_index (typedarray, j, test_number);
get_result = jerry_object_get_index (typedarray, j);
TEST_ASSERT (jerry_value_is_boolean (set_result));
TEST_ASSERT (jerry_value_is_true (set_result));
TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
TEST_ASSERT (jerry_value_is_false (jerry_object_delete_index (typedarray, j)));
uint64_t get_number;
bool sign;
jerry_get_bigint_digits (get_result, &get_number, 1, &sign);
jerry_bigint_to_digits (get_result, &get_number, 1, &sign);
TEST_ASSERT (get_number == test_uint64_numbers[j]);
jerry_release_value (test_number);
jerry_release_value (set_result);
jerry_release_value (get_result);
jerry_value_free (test_number);
jerry_value_free (set_result);
jerry_value_free (get_result);
}
break;
}
@@ -455,40 +450,40 @@ test_property_by_index (test_entry_t test_entries[])
{
for (uint8_t j = 0; j < test_numbers_length; j++)
{
test_number = jerry_create_number (test_uint_numbers[j]);
TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
set_result = jerry_set_property_by_index (typedarray, j, test_number);
get_result = jerry_get_property_by_index (typedarray, j);
test_number = jerry_number (test_uint_numbers[j]);
TEST_ASSERT (jerry_value_is_false (jerry_object_delete_index (typedarray, j)));
set_result = jerry_object_set_index (typedarray, j, test_number);
get_result = jerry_object_get_index (typedarray, j);
TEST_ASSERT (jerry_value_is_boolean (set_result));
TEST_ASSERT (jerry_value_is_true (set_result));
TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
TEST_ASSERT (jerry_get_number_value (get_result) == test_uint_numbers[j]);
TEST_ASSERT (jerry_value_is_false (jerry_object_delete_index (typedarray, j)));
TEST_ASSERT (jerry_value_as_number (get_result) == test_uint_numbers[j]);
jerry_release_value (test_number);
jerry_release_value (set_result);
jerry_release_value (get_result);
jerry_value_free (test_number);
jerry_value_free (set_result);
jerry_value_free (get_result);
}
break;
}
}
jerry_value_t set_undefined = jerry_set_property_by_index (typedarray, 100, jerry_create_number (50));
jerry_value_t set_undefined = jerry_object_set_index (typedarray, 100, jerry_number (50));
if (type == JERRY_TYPEDARRAY_BIGINT64 || type == JERRY_TYPEDARRAY_BIGUINT64)
{
TEST_ASSERT (jerry_value_is_error (set_undefined));
TEST_ASSERT (jerry_value_is_exception (set_undefined));
}
else
{
TEST_ASSERT (jerry_value_is_boolean (set_undefined) && !jerry_value_is_true (set_undefined));
}
jerry_value_t get_undefined = jerry_get_property_by_index (typedarray, 100);
jerry_value_t get_undefined = jerry_object_get_index (typedarray, 100);
if (type == JERRY_TYPEDARRAY_BIGINT64 || type == JERRY_TYPEDARRAY_BIGUINT64)
{
TEST_ASSERT (jerry_value_is_error (set_undefined));
TEST_ASSERT (jerry_value_is_exception (set_undefined));
}
else
{
@@ -496,9 +491,9 @@ test_property_by_index (test_entry_t test_entries[])
}
TEST_ASSERT (jerry_value_is_undefined (get_undefined));
jerry_release_value (set_undefined);
jerry_release_value (get_undefined);
jerry_release_value (typedarray);
jerry_value_free (set_undefined);
jerry_value_free (get_undefined);
jerry_value_free (typedarray);
}
} /* test_property_by_index */
@@ -515,58 +510,56 @@ test_detached_arraybuffer (void)
{
const uint32_t length = 1;
uint8_t *buffer_p = (uint8_t *) jerry_heap_alloc (length);
jerry_value_t arraybuffer = jerry_create_arraybuffer_external (length, buffer_p, NULL);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
jerry_value_t arraybuffer = jerry_arraybuffer_external (buffer_p, length, NULL);
TEST_ASSERT (!jerry_value_is_exception (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == length);
jerry_value_t is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
TEST_ASSERT (!jerry_value_is_error (is_detachable));
TEST_ASSERT (jerry_value_is_true (is_detachable));
jerry_release_value (is_detachable);
TEST_ASSERT (jerry_arraybuffer_is_detachable (arraybuffer));
jerry_value_t res = jerry_detach_arraybuffer (arraybuffer);
TEST_ASSERT (!jerry_value_is_error (res));
jerry_release_value (res);
jerry_value_t res = jerry_arraybuffer_detach (arraybuffer);
TEST_ASSERT (!jerry_value_is_exception (res));
jerry_value_free (res);
TEST_ASSERT (!jerry_arraybuffer_is_detachable (arraybuffer));
for (size_t idx = 0; idx < (sizeof (types) / sizeof (types[0])); idx++)
{
jerry_value_t typedarray = jerry_create_typedarray_for_arraybuffer_sz (types[idx], arraybuffer, 0, 4);
TEST_ASSERT (jerry_value_is_error (typedarray));
TEST_ASSERT (jerry_get_error_type (typedarray) == JERRY_ERROR_TYPE);
jerry_release_value (typedarray);
jerry_value_t typedarray = jerry_typedarray_with_buffer_span (types[idx], arraybuffer, 0, 4);
TEST_ASSERT (jerry_value_is_exception (typedarray));
TEST_ASSERT (jerry_error_type (typedarray) == JERRY_ERROR_TYPE);
jerry_value_free (typedarray);
}
jerry_release_value (arraybuffer);
jerry_value_free (arraybuffer);
}
/* Creating an TypedArray for a detached array buffer without length/offset is valid */
{
const uint32_t length = 1;
uint8_t *buffer_p = (uint8_t *) jerry_heap_alloc (length);
jerry_value_t arraybuffer = jerry_create_arraybuffer_external (length, buffer_p, NULL);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
jerry_value_t arraybuffer = jerry_arraybuffer_external (buffer_p, length, NULL);
TEST_ASSERT (!jerry_value_is_exception (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
TEST_ASSERT (jerry_arraybuffer_size (arraybuffer) == length);
jerry_value_t is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
TEST_ASSERT (!jerry_value_is_error (is_detachable));
TEST_ASSERT (jerry_value_is_true (is_detachable));
jerry_release_value (is_detachable);
TEST_ASSERT (jerry_arraybuffer_is_detachable (arraybuffer));
jerry_value_t res = jerry_detach_arraybuffer (arraybuffer);
TEST_ASSERT (!jerry_value_is_error (res));
jerry_release_value (res);
jerry_value_t res = jerry_arraybuffer_detach (arraybuffer);
TEST_ASSERT (!jerry_value_is_exception (res));
jerry_value_free (res);
TEST_ASSERT (!jerry_arraybuffer_is_detachable (arraybuffer));
for (size_t idx = 0; idx < (sizeof (types) / sizeof (types[0])); idx++)
{
jerry_value_t typedarray = jerry_create_typedarray_for_arraybuffer (types[idx], arraybuffer);
TEST_ASSERT (jerry_value_is_error (typedarray));
TEST_ASSERT (jerry_get_error_type (typedarray) == JERRY_ERROR_TYPE);
jerry_release_value (typedarray);
jerry_value_t typedarray = jerry_typedarray_with_buffer (types[idx], arraybuffer);
TEST_ASSERT (jerry_value_is_exception (typedarray));
TEST_ASSERT (jerry_error_type (typedarray) == JERRY_ERROR_TYPE);
jerry_value_free (typedarray);
}
jerry_release_value (arraybuffer);
jerry_value_free (arraybuffer);
}
} /* test_detached_arraybuffer */
@@ -575,16 +568,16 @@ main (void)
{
jerry_init (JERRY_INIT_EMPTY);
if (!jerry_is_feature_enabled (JERRY_FEATURE_TYPEDARRAY))
if (!jerry_feature_enabled (JERRY_FEATURE_TYPEDARRAY))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "TypedArray is disabled!\n");
jerry_cleanup ();
return 0;
}
jerry_value_t function_val = jerry_create_external_function (assert_handler);
jerry_value_t function_val = jerry_function_external (assert_handler);
register_js_value ("assert", function_val);
jerry_release_value (function_val);
jerry_value_free (function_val);
test_entry_t test_entries[] = {
#define TEST_ENTRY(TYPE, CONSTRUCTOR, COUNT, BYTES_PER_ELEMENT) { TYPE, CONSTRUCTOR, COUNT, BYTES_PER_ELEMENT }
@@ -614,7 +607,7 @@ main (void)
{
const uint32_t element_count = 14;
jerry_value_t array = jerry_create_typedarray (JERRY_TYPEDARRAY_UINT8, element_count);
jerry_value_t array = jerry_typedarray (JERRY_TYPEDARRAY_UINT8, element_count);
{
uint8_t expected_value = 42;
@@ -623,21 +616,21 @@ main (void)
jerry_length_t byte_length;
jerry_length_t offset;
jerry_value_t buffer = jerry_get_typedarray_buffer (array, &offset, &byte_length);
jerry_value_t buffer = jerry_typedarray_buffer (array, &offset, &byte_length);
TEST_ASSERT (byte_length == element_count);
jerry_length_t written = jerry_arraybuffer_write (buffer, offset, expected_data, element_count);
TEST_ASSERT (written == element_count);
jerry_release_value (buffer);
jerry_value_free (buffer);
jerry_value_t js_element_count = jerry_create_number (element_count);
jerry_value_t js_expected_value = jerry_create_number (expected_value);
jerry_value_t js_element_count = jerry_number (element_count);
jerry_value_t js_expected_value = jerry_number (expected_value);
register_js_value ("array", array);
register_js_value ("expected_length", js_element_count);
register_js_value ("expected_value", js_expected_value);
jerry_release_value (js_element_count);
jerry_release_value (js_expected_value);
jerry_value_free (js_element_count);
jerry_value_free (js_expected_value);
}
/* Check read and to write */
@@ -650,14 +643,14 @@ main (void)
"};");
jerry_value_t result = jerry_eval (eval_src, sizeof (eval_src) - 1, JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
/* Check write results */
{
jerry_length_t byte_length;
jerry_length_t offset;
jerry_value_t buffer = jerry_get_typedarray_buffer (array, &offset, &byte_length);
jerry_value_t buffer = jerry_typedarray_buffer (array, &offset, &byte_length);
TEST_ASSERT (byte_length == element_count);
JERRY_VLA (uint8_t, result_data, element_count);
@@ -670,10 +663,10 @@ main (void)
TEST_ASSERT (result_data[i] == i);
}
jerry_release_value (buffer);
jerry_value_free (buffer);
}
jerry_release_value (array);
jerry_value_free (array);
}
test_typedarray_complex_creation (test_entries, false);
@@ -684,15 +677,15 @@ main (void)
/* test invalid things */
{
jerry_value_t values[] = {
jerry_create_number (11),
jerry_create_boolean (false),
jerry_create_string ((const jerry_char_t *) "test"),
jerry_create_object (),
jerry_create_null (),
jerry_create_arraybuffer (16),
jerry_create_error (JERRY_ERROR_TYPE, (const jerry_char_t *) "error"),
jerry_create_undefined (),
jerry_create_promise (),
jerry_number (11),
jerry_boolean (false),
jerry_string_sz ("test"),
jerry_object (),
jerry_null (),
jerry_arraybuffer (16),
jerry_error_sz (JERRY_ERROR_TYPE, "error"),
jerry_undefined (),
jerry_promise (),
};
for (size_t idx = 0; idx < sizeof (values) / sizeof (values[0]); idx++)
@@ -702,11 +695,11 @@ main (void)
TEST_ASSERT (is_typedarray == false);
/* JERRY_TYPEDARRAY_INVALID should be returned for non-TypedArray objects */
jerry_typedarray_type_t type = jerry_get_typedarray_type (values[idx]);
jerry_typedarray_type_t type = jerry_typedarray_type (values[idx]);
TEST_ASSERT (type == JERRY_TYPEDARRAY_INVALID);
/* Zero should be returned for non-TypedArray objects */
jerry_length_t length = jerry_get_typedarray_length (values[idx]);
jerry_length_t length = jerry_typedarray_length (values[idx]);
TEST_ASSERT (length == 0);
/**
@@ -716,11 +709,11 @@ main (void)
{
jerry_length_t offset = 22;
jerry_length_t byte_count = 23;
jerry_value_t error = jerry_get_typedarray_buffer (values[idx], &offset, &byte_count);
TEST_ASSERT (jerry_value_is_error (error));
jerry_value_t error = jerry_typedarray_buffer (values[idx], &offset, &byte_count);
TEST_ASSERT (jerry_value_is_exception (error));
TEST_ASSERT (offset == 22);
TEST_ASSERT (byte_count == 23);
jerry_release_value (error);
jerry_value_free (error);
}
/**
@@ -728,12 +721,12 @@ main (void)
*/
if (!jerry_value_is_arraybuffer (values[idx]))
{
jerry_value_t error = jerry_create_typedarray_for_arraybuffer (JERRY_TYPEDARRAY_UINT8, values[idx]);
TEST_ASSERT (jerry_value_is_error (error));
jerry_release_value (error);
jerry_value_t error = jerry_typedarray_with_buffer (JERRY_TYPEDARRAY_UINT8, values[idx]);
TEST_ASSERT (jerry_value_is_exception (error));
jerry_value_free (error);
}
jerry_release_value (values[idx]);
jerry_value_free (values[idx]);
}
}
tests/unit-core/test-unicode.c
+3 -3
View File
@@ -24,13 +24,13 @@ test_syntax_error (char *script_p) /**< script */
bool result = false;
if (jerry_value_is_error (parse_result))
if (jerry_value_is_exception (parse_result))
{
result = true;
TEST_ASSERT (jerry_get_error_type (parse_result) == JERRY_ERROR_SYNTAX);
TEST_ASSERT (jerry_error_type (parse_result) == JERRY_ERROR_SYNTAX);
}
jerry_release_value (parse_result);
jerry_value_free (parse_result);
return result;
} /* test_syntax_error */
tests/unit-core/test-vm-exec-stop.c
+12 -12
View File
@@ -27,10 +27,10 @@ vm_exec_stop_callback (void *user_p)
{
(*int_p)--;
return jerry_create_undefined ();
return jerry_undefined ();
}
return jerry_create_string ((const jerry_char_t *) "Abort script");
return jerry_string_sz ("Abort script");
} /* vm_exec_stop_callback */
int
@@ -39,7 +39,7 @@ main (void)
TEST_INIT ();
/* Test stopping an infinite loop. */
if (!jerry_is_feature_enabled (JERRY_FEATURE_VM_EXEC_STOP))
if (!jerry_feature_enabled (JERRY_FEATURE_VM_EXEC_STOP))
{
return 0;
}
@@ -47,19 +47,19 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
int countdown = 6;
jerry_set_vm_exec_stop_callback (vm_exec_stop_callback, &countdown, 16);
jerry_halt_handler (16, vm_exec_stop_callback, &countdown);
const jerry_char_t inf_loop_code_src1[] = "while(true) {}";
jerry_value_t parsed_code_val = jerry_parse (inf_loop_code_src1, sizeof (inf_loop_code_src1) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);
TEST_ASSERT (countdown == 0);
TEST_ASSERT (jerry_value_is_error (res));
TEST_ASSERT (jerry_value_is_exception (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_value_free (res);
jerry_value_free (parsed_code_val);
/* A more complex example. Although the callback error is captured
* by the catch block, it is automatically thrown again. */
@@ -72,16 +72,16 @@ main (void)
parsed_code_val = jerry_parse (inf_loop_code_src2, sizeof (inf_loop_code_src2) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
res = jerry_run (parsed_code_val);
TEST_ASSERT (countdown == 0);
/* The result must have an error flag which proves that
* the error is thrown again inside the catch block. */
TEST_ASSERT (jerry_value_is_error (res));
TEST_ASSERT (jerry_value_is_exception (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_value_free (res);
jerry_value_free (parsed_code_val);
jerry_cleanup ();
return 0;
tests/unit-core/test-vm-throw.c
+28 -28
View File
@@ -33,7 +33,7 @@ vm_throw_callback (const jerry_value_t error_value, /**< captured error */
case 0:
{
TEST_ASSERT (counter == 1);
TEST_ASSERT (jerry_value_is_number (error_value) && jerry_get_number_value (error_value) == -5.6);
TEST_ASSERT (jerry_value_is_number (error_value) && jerry_value_as_number (error_value) == -5.6);
break;
}
case 1:
@@ -52,15 +52,15 @@ vm_throw_callback (const jerry_value_t error_value, /**< captured error */
TEST_ASSERT (counter >= 1 && counter <= 3);
TEST_ASSERT (jerry_value_is_string (error_value));
TEST_ASSERT (jerry_get_string_size (error_value) == size);
TEST_ASSERT (jerry_string_to_char_buffer (error_value, string_buf, size) == size);
TEST_ASSERT (jerry_string_size (error_value, JERRY_ENCODING_CESU8) == size);
TEST_ASSERT (jerry_string_to_buffer (error_value, JERRY_ENCODING_CESU8, string_buf, size) == size);
TEST_ASSERT (string_buf[0] == 'e' && string_buf[1] == (char) ('0' + counter));
break;
}
case 3:
{
TEST_ASSERT (counter == 1);
TEST_ASSERT (jerry_get_error_type (error_value) == JERRY_ERROR_RANGE);
TEST_ASSERT (jerry_error_type (error_value) == JERRY_ERROR_RANGE);
break;
}
case 4:
@@ -69,7 +69,7 @@ vm_throw_callback (const jerry_value_t error_value, /**< captured error */
TEST_ASSERT (counter >= 1 && counter <= 2);
jerry_error_t error = (counter == 1) ? JERRY_ERROR_REFERENCE : JERRY_ERROR_TYPE;
TEST_ASSERT (jerry_get_error_type (error_value) == error);
TEST_ASSERT (jerry_error_type (error_value) == error);
break;
}
case 5:
@@ -100,23 +100,23 @@ native_handler (const jerry_call_info_t *call_info_p, /**< call info */
if (mode == 7)
{
jerry_value_t result = jerry_create_error (JERRY_ERROR_COMMON, (const jerry_char_t *) "Error!");
jerry_value_t result = jerry_throw_sz (JERRY_ERROR_COMMON, "Error!");
TEST_ASSERT (!jerry_error_is_throw_captured (result));
jerry_error_set_throw_capture (result, false);
TEST_ASSERT (jerry_error_is_throw_captured (result));
TEST_ASSERT (!jerry_exception_is_captured (result));
jerry_exception_allow_capture (result, false);
TEST_ASSERT (jerry_exception_is_captured (result));
return result;
}
jerry_char_t source[] = TEST_STRING_LITERAL ("throw false");
jerry_value_t result = jerry_eval (source, sizeof (source) - 1, JERRY_PARSE_NO_OPTS);
TEST_ASSERT (jerry_error_is_throw_captured (result));
TEST_ASSERT (jerry_exception_is_captured (result));
if (mode == 6)
{
jerry_error_set_throw_capture (result, true);
TEST_ASSERT (!jerry_error_is_throw_captured (result));
jerry_exception_allow_capture (result, true);
TEST_ASSERT (!jerry_exception_is_captured (result));
}
return result;
} /* native_handler */
@@ -126,8 +126,8 @@ do_eval (const char *script_p, /**< script to evaluate */
bool should_throw) /**< script throws an error */
{
jerry_value_t result = jerry_eval ((const jerry_char_t *) script_p, strlen (script_p), JERRY_PARSE_NO_OPTS);
TEST_ASSERT (jerry_value_is_error (result) == should_throw);
jerry_release_value (result);
TEST_ASSERT (jerry_value_is_exception (result) == should_throw);
jerry_value_free (result);
} /* do_eval */
int
@@ -136,14 +136,14 @@ main (void)
TEST_INIT ();
/* Test stopping an infinite loop. */
if (!jerry_is_feature_enabled (JERRY_FEATURE_VM_THROW))
if (!jerry_feature_enabled (JERRY_FEATURE_VM_THROW))
{
return 0;
}
jerry_init (JERRY_INIT_EMPTY);
jerry_set_vm_throw_callback (vm_throw_callback, (void *) &mode);
jerry_on_throw (vm_throw_callback, (void *) &mode);
mode = 0;
counter = 0;
@@ -183,14 +183,14 @@ main (void)
TEST_ASSERT (counter == 2);
/* Native functions may trigger the call twice: */
jerry_value_t global_object_value = jerry_get_global_object ();
jerry_value_t function_value = jerry_create_external_function (native_handler);
jerry_value_t function_name_value = jerry_create_string ((const jerry_char_t *) "native");
jerry_value_t global_object_value = jerry_current_realm ();
jerry_value_t function_value = jerry_function_external (native_handler);
jerry_value_t function_name_value = jerry_string_sz ("native");
jerry_release_value (jerry_set_property (global_object_value, function_name_value, function_value));
jerry_release_value (function_name_value);
jerry_release_value (function_value);
jerry_release_value (global_object_value);
jerry_value_free (jerry_object_set (global_object_value, function_name_value, function_value));
jerry_value_free (function_name_value);
jerry_value_free (function_value);
jerry_value_free (global_object_value);
mode = 5;
counter = 0;
@@ -222,11 +222,11 @@ main (void)
true);
TEST_ASSERT (counter == 1);
jerry_value_t value = jerry_create_object ();
TEST_ASSERT (!jerry_error_is_throw_captured (value));
jerry_error_set_throw_capture (value, false);
TEST_ASSERT (!jerry_error_is_throw_captured (value));
jerry_release_value (value);
jerry_value_t value = jerry_object ();
TEST_ASSERT (!jerry_exception_is_captured (value));
jerry_exception_allow_capture (value, false);
TEST_ASSERT (!jerry_exception_is_captured (value));
jerry_value_free (value);
jerry_cleanup ();
return 0;
tests/unit-ext/module/jerry-module-test.c
+25 -25
View File
@@ -80,13 +80,13 @@ const char eval_string7[] = "(function() {"
static bool
resolve_differently_handled_module (const jerry_value_t name, jerry_value_t *result)
{
jerry_size_t name_size = jerry_get_utf8_string_size (name);
jerry_size_t name_size = jerry_string_size (name, JERRY_ENCODING_UTF8);
JERRY_VLA (jerry_char_t, name_string, name_size);
jerry_string_to_utf8_char_buffer (name, name_string, name_size);
jerry_string_to_buffer (name, JERRY_ENCODING_UTF8, name_string, name_size);
if (!strncmp ((char *) name_string, "differently-handled-module", name_size))
{
(*result) = jerry_create_number (29);
(*result) = jerry_number (29);
return true;
}
return false;
@@ -102,13 +102,13 @@ static jerryx_module_resolver_t differently_handled_module_resolver = { NULL, re
static bool
cache_check (const jerry_value_t name, jerry_value_t *result)
{
jerry_size_t name_size = jerry_get_utf8_string_size (name);
jerry_size_t name_size = jerry_string_size (name, JERRY_ENCODING_UTF8);
JERRY_VLA (jerry_char_t, name_string, name_size);
jerry_string_to_utf8_char_buffer (name, name_string, name_size);
jerry_string_to_buffer (name, JERRY_ENCODING_UTF8, name_string, name_size);
if (!strncmp ((char *) name_string, "cache-check", name_size))
{
(*result) = jerry_create_object ();
(*result) = jerry_object ();
return true;
}
return false;
@@ -151,8 +151,8 @@ handle_require (const jerry_call_info_t *call_info_p, const jerry_value_t args_p
static void
assert_number (jerry_value_t js_value, double expected_result)
{
TEST_ASSERT (!jerry_value_is_error (js_value));
TEST_ASSERT (jerry_get_number_value (js_value) == expected_result);
TEST_ASSERT (!jerry_value_is_exception (js_value));
TEST_ASSERT (jerry_value_as_number (js_value) == expected_result);
} /* assert_number */
static void
@@ -161,7 +161,7 @@ eval_one (const char *the_string, double expected_result)
jerry_value_t js_eval_result =
jerry_eval ((const jerry_char_t *) the_string, strlen (the_string), JERRY_PARSE_STRICT_MODE);
assert_number (js_eval_result, expected_result);
jerry_release_value (js_eval_result);
jerry_value_free (js_eval_result);
} /* eval_one */
#ifndef ENABLE_INIT_FINI
@@ -184,27 +184,27 @@ main (int argc, char **argv)
jerry_init (JERRY_INIT_EMPTY);
js_global = jerry_get_global_object ();
js_global = jerry_current_realm ();
js_function = jerry_create_external_function (handle_require);
js_property_name = jerry_create_string ((const jerry_char_t *) "require");
res = jerry_set_property (js_global, js_property_name, js_function);
TEST_ASSERT (!jerry_value_is_error (res));
js_function = jerry_function_external (handle_require);
js_property_name = jerry_string_sz ("require");
res = jerry_object_set (js_global, js_property_name, js_function);
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (jerry_value_is_boolean (res) && jerry_value_is_true (res));
jerry_release_value (res);
jerry_release_value (js_property_name);
jerry_release_value (js_function);
jerry_value_free (res);
jerry_value_free (js_property_name);
jerry_value_free (js_function);
js_function = jerry_create_external_function (handle_clear_require_cache);
js_property_name = jerry_create_string ((const jerry_char_t *) "clear_require_cache");
res = jerry_set_property (js_global, js_property_name, js_function);
TEST_ASSERT (!jerry_value_is_error (res));
js_function = jerry_function_external (handle_clear_require_cache);
js_property_name = jerry_string_sz ("clear_require_cache");
res = jerry_object_set (js_global, js_property_name, js_function);
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (jerry_value_is_boolean (res) && jerry_value_is_true (res));
jerry_release_value (res);
jerry_release_value (js_property_name);
jerry_release_value (js_function);
jerry_value_free (res);
jerry_value_free (js_property_name);
jerry_value_free (js_function);
jerry_release_value (js_global);
jerry_value_free (js_global);
eval_one (eval_string1, 42);
eval_one (eval_string2, 29);
tests/unit-ext/module/my-custom-module.c
+1 -1
View File
@@ -22,7 +22,7 @@
static jerry_value_t
my_custom_module_on_resolve (void)
{
return jerry_create_number (42);
return jerry_number (42);
} /* my_custom_module_on_resolve */
JERRYX_NATIVE_MODULE (MODULE_NAME, my_custom_module_on_resolve)
tests/unit-ext/test-ext-arg.c
+72 -72
View File
@@ -116,7 +116,7 @@ test_validator1_handler (const jerry_call_info_t *call_info_p, /**< call informa
bool arg1;
double arg2 = 0.0;
char arg3[5] = "1234";
jerry_value_t arg4 = jerry_create_undefined ();
jerry_value_t arg4 = jerry_undefined ();
jerryx_arg_t mapping[] = { /* ignore this */
jerryx_arg_ignore (),
@@ -135,7 +135,7 @@ test_validator1_handler (const jerry_call_info_t *call_info_p, /**< call informa
if (validator1_count == 0)
{
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
TEST_ASSERT (arg1);
TEST_ASSERT (arg2 == 10.5);
TEST_ASSERT (strcmp (arg3, "abc") == 0);
@@ -143,7 +143,7 @@ test_validator1_handler (const jerry_call_info_t *call_info_p, /**< call informa
}
else if (validator1_count == 1)
{
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
TEST_ASSERT (arg1);
TEST_ASSERT (arg2 == 10.5);
TEST_ASSERT (strcmp (arg3, "abc") == 0);
@@ -151,7 +151,7 @@ test_validator1_handler (const jerry_call_info_t *call_info_p, /**< call informa
}
else if (validator1_count == 2)
{
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
TEST_ASSERT (arg1);
TEST_ASSERT (arg2 == 10.5);
TEST_ASSERT (strcmp (arg3, "") == 0);
@@ -159,14 +159,14 @@ test_validator1_handler (const jerry_call_info_t *call_info_p, /**< call informa
}
else
{
TEST_ASSERT (jerry_value_is_error (is_ok));
TEST_ASSERT (jerry_value_is_exception (is_ok));
}
jerry_release_value (is_ok);
jerry_release_value (arg4);
jerry_value_free (is_ok);
jerry_value_free (arg4);
validator1_count++;
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator1_handler */
/**
@@ -179,22 +179,22 @@ my_custom_transform (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< available JS
jerry_value_t js_arg = jerryx_arg_js_iterator_pop (js_arg_iter_p);
jerry_value_t to_number = jerry_value_to_number (js_arg);
if (jerry_value_is_error (to_number))
if (jerry_value_is_exception (to_number))
{
jerry_release_value (to_number);
jerry_value_free (to_number);
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "It can not be converted to a number.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "It can not be converted to a number.");
}
int expected_num = (int) c_arg_p->extra_info;
int get_num = (int) jerry_get_number_value (to_number);
int get_num = (int) jerry_value_as_number (to_number);
if (get_num != expected_num)
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "Number value is not expected.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "Number value is not expected.");
}
return jerry_create_undefined ();
return jerry_undefined ();
} /* my_custom_transform */
/**
@@ -220,19 +220,19 @@ test_validator2_handler (const jerry_call_info_t *call_info_p, /**< call informa
if (validator2_count == 0)
{
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
TEST_ASSERT (thing_p == &my_thing_a);
TEST_ASSERT (thing_p->x == 1);
}
else
{
TEST_ASSERT (jerry_value_is_error (is_ok));
TEST_ASSERT (jerry_value_is_exception (is_ok));
}
jerry_release_value (is_ok);
jerry_value_free (is_ok);
validator2_count++;
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator2_handler */
/**
@@ -262,20 +262,20 @@ test_validator3_handler (const jerry_call_info_t *call_info_p, /**< call informa
if (validator3_count == 0)
{
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
TEST_ASSERT (arg1);
TEST_ASSERT (arg2);
}
else if (validator3_count == 1)
{
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
TEST_ASSERT (arg1);
/* arg2 must be unchanged */
TEST_ASSERT (!arg2);
}
else if (validator3_count == 2)
{
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
/* arg1 must be unchanged */
TEST_ASSERT (!arg1);
/* arg2 must be unchanged */
@@ -283,17 +283,17 @@ test_validator3_handler (const jerry_call_info_t *call_info_p, /**< call informa
}
else if (validator3_count == 3)
{
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
/* arg1 must be unchanged */
TEST_ASSERT (!arg1);
/* arg2 must be unchanged */
TEST_ASSERT (!arg2);
}
jerry_release_value (is_ok);
jerry_value_free (is_ok);
validator3_count++;
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator3_handler */
/**
@@ -323,14 +323,14 @@ test_validator_prop1_handler (const jerry_call_info_t *call_info_p, /**< call in
mapping,
ARRAY_SIZE (mapping));
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
TEST_ASSERT (native1);
TEST_ASSERT (native2 == 1.5);
TEST_ASSERT (native3 == 3);
validator_prop_count++;
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator_prop1_handler */
/**
@@ -367,7 +367,7 @@ test_validator_prop2_handler (const jerry_call_info_t *call_info_p, /**< call in
jerry_value_t is_ok = jerryx_arg_transform_args (args_p, args_cnt, mapping, ARRAY_SIZE (mapping));
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
if (validator_prop_count == 1)
{
@@ -378,7 +378,7 @@ test_validator_prop2_handler (const jerry_call_info_t *call_info_p, /**< call in
validator_prop_count++;
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator_prop2_handler */
static jerry_value_t
@@ -405,14 +405,14 @@ test_validator_prop3_handler (const jerry_call_info_t *call_info_p, /**< call in
mapping,
ARRAY_SIZE (mapping));
TEST_ASSERT (jerry_value_is_error (is_ok));
TEST_ASSERT (jerry_value_is_exception (is_ok));
TEST_ASSERT (!native1);
TEST_ASSERT (native2);
validator_prop_count++;
jerry_release_value (is_ok);
jerry_value_free (is_ok);
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator_prop3_handler */
/*
@@ -447,7 +447,7 @@ test_validator_int1_handler (const jerry_call_info_t *call_info_p, /**< call inf
jerry_value_t is_ok = jerryx_arg_transform_args (args_p, args_cnt, mapping, ARRAY_SIZE (mapping));
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
TEST_ASSERT (num0 == 0);
TEST_ASSERT (num1 == 255);
TEST_ASSERT (num2 == 128);
@@ -461,10 +461,10 @@ test_validator_int1_handler (const jerry_call_info_t *call_info_p, /**< call inf
TEST_ASSERT (num10 == 2147483647);
TEST_ASSERT (num11 == -2147483647);
jerry_release_value (is_ok);
jerry_value_free (is_ok);
validator_int_count++;
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator_int1_handler */
static jerry_value_t
@@ -493,7 +493,7 @@ test_validator_int2_handler (const jerry_call_info_t *call_info_p, /**< call inf
jerry_value_t is_ok = jerryx_arg_transform_args (args_p, args_cnt, mapping, ARRAY_SIZE (mapping));
TEST_ASSERT (jerry_value_is_error (is_ok));
TEST_ASSERT (jerry_value_is_exception (is_ok));
TEST_ASSERT (num0 == -2);
TEST_ASSERT (num1 == -2);
TEST_ASSERT (num2 == -1);
@@ -505,10 +505,10 @@ test_validator_int2_handler (const jerry_call_info_t *call_info_p, /**< call inf
TEST_ASSERT (num8 == 127);
TEST_ASSERT (num9 == 123);
jerry_release_value (is_ok);
jerry_value_free (is_ok);
validator_int_count++;
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator_int2_handler */
static jerry_value_t
@@ -526,12 +526,12 @@ test_validator_int3_handler (const jerry_call_info_t *call_info_p, /**< call inf
jerry_value_t is_ok = jerryx_arg_transform_args (args_p, args_cnt, mapping, ARRAY_SIZE (mapping));
TEST_ASSERT (jerry_value_is_error (is_ok));
TEST_ASSERT (jerry_value_is_exception (is_ok));
jerry_release_value (is_ok);
jerry_value_free (is_ok);
validator_int_count++;
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator_int3_handler */
static jerry_value_t
@@ -560,7 +560,7 @@ test_validator_array1_handler (const jerry_call_info_t *call_info_p, /**< call i
jerry_value_t is_ok = jerryx_arg_transform_args (args_p, args_cnt, mapping, ARRAY_SIZE (mapping));
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
if (validator_array_count == 0)
{
@@ -571,7 +571,7 @@ test_validator_array1_handler (const jerry_call_info_t *call_info_p, /**< call i
validator_array_count++;
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator_array1_handler */
static jerry_value_t
@@ -590,14 +590,14 @@ test_validator_array2_handler (const jerry_call_info_t *call_info_p, /**< call i
jerry_value_t is_ok = jerryx_arg_transform_array (args_p[0], item_mapping, ARRAY_SIZE (item_mapping));
TEST_ASSERT (jerry_value_is_error (is_ok));
TEST_ASSERT (jerry_value_is_exception (is_ok));
TEST_ASSERT (native1 == 1);
TEST_ASSERT (!native2);
validator_array_count++;
jerry_release_value (is_ok);
jerry_value_free (is_ok);
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator_array2_handler */
/**
@@ -673,7 +673,7 @@ jerry_arg_to_double_or_bool_t (jerryx_arg_js_iterator_t *js_arg_iter_p, const je
(jerryx_arg_coerce_t) extra_info[0],
JERRYX_ARG_OPTIONAL);
conversion_result = conversion_function.func (js_arg_iter_p, &conversion_function);
if (!jerry_value_is_error (conversion_result))
if (!jerry_value_is_exception (conversion_result))
{
if (last_parameter)
{
@@ -696,9 +696,9 @@ jerry_arg_to_double_or_bool_t (jerryx_arg_js_iterator_t *js_arg_iter_p, const je
(jerryx_arg_coerce_t) extra_info[0],
(jerryx_arg_optional_t) extra_info[1]);
jerry_release_value (conversion_result);
jerry_value_free (conversion_result);
conversion_result = conversion_function.func (js_arg_iter_p, &conversion_function);
if (!jerry_value_is_error (conversion_result))
if (!jerry_value_is_exception (conversion_result))
{
if (last_parameter)
{
@@ -717,8 +717,8 @@ jerry_arg_to_double_or_bool_t (jerryx_arg_js_iterator_t *js_arg_iter_p, const je
/* Fall through indicates that whatever they gave us, it wasn't
* one of the types we were expecting... */
jerry_release_value (conversion_result);
return jerry_create_error (JERRY_ERROR_TYPE, (const jerry_char_t *) "double_or_bool-type error.");
jerry_value_free (conversion_result);
return jerry_throw_sz (JERRY_ERROR_TYPE, "double_or_bool-type error.");
} /* jerry_arg_to_double_or_bool_t */
/**
@@ -740,7 +740,7 @@ test_validator_restore_handler (const jerry_call_info_t *call_info_p, /**< call
jerry_value_t is_ok = jerryx_arg_transform_args (args_p, args_cnt, item_mapping, ARRAY_SIZE (item_mapping));
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
/* We are going to call this with [false, 3.0] and [3.0, false] parameters... */
bool arg1_is_false = (arg1.type_of_value == BOOL_VALUE && arg1.value.bool_field == false);
@@ -749,16 +749,16 @@ test_validator_restore_handler (const jerry_call_info_t *call_info_p, /**< call
bool arg2_is_three = (arg2.type_of_value == DOUBLE_VALUE && arg2.value.double_field == 3.0);
TEST_ASSERT ((arg1_is_false && arg2_is_three) || (arg1_is_three && arg2_is_false));
jerry_release_value (is_ok);
jerry_value_free (is_ok);
return jerry_create_undefined ();
return jerry_undefined ();
} /* test_validator_restore_handler */
static void
test_utf8_string (void)
{
/* test string: 'str: {DESERET CAPITAL LETTER LONG I}' */
jerry_value_t str = jerry_create_string ((jerry_char_t *) "\x73\x74\x72\x3a \xed\xa0\x81\xed\xb0\x80");
jerry_value_t str = jerry_string_sz ("\x73\x74\x72\x3a \xed\xa0\x81\xed\xb0\x80");
char expect_utf8_buf[] = "\x73\x74\x72\x3a \xf0\x90\x90\x80";
size_t buf_len = sizeof (expect_utf8_buf) - 1;
JERRY_VLA (char, buf, buf_len + 1);
@@ -769,10 +769,10 @@ test_utf8_string (void)
jerry_value_t is_ok = jerryx_arg_transform_args (&str, 1, mapping, ARRAY_SIZE (mapping));
TEST_ASSERT (!jerry_value_is_error (is_ok));
TEST_ASSERT (!jerry_value_is_exception (is_ok));
TEST_ASSERT (!strcmp (buf, expect_utf8_buf));
jerry_release_value (str);
jerry_value_free (str);
} /* test_utf8_string */
static jerry_value_t
@@ -786,9 +786,9 @@ create_object_a_handler (const jerry_call_info_t *call_info_p, /**< call informa
TEST_ASSERT (jerry_value_is_object (call_info_p->this_value));
my_thing_a.x = 1;
jerry_set_object_native_pointer (call_info_p->this_value, &my_thing_a, &thing_a_info);
jerry_object_set_native_ptr (call_info_p->this_value, &thing_a_info, &my_thing_a);
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* create_object_a_handler */
static jerry_value_t
@@ -802,9 +802,9 @@ create_object_b_handler (const jerry_call_info_t *call_info_p, /**< call informa
TEST_ASSERT (jerry_value_is_object (call_info_p->this_value));
my_thing_b.x = false;
jerry_set_object_native_pointer (call_info_p->this_value, &my_thing_b, &thing_b_info);
jerry_object_set_native_ptr (call_info_p->this_value, &thing_b_info, &my_thing_b);
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* create_object_b_handler */
/**
@@ -814,17 +814,17 @@ static void
register_js_function (const char *name_p, /**< name of the function */
jerry_external_handler_t handler_p) /**< function callback */
{
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t function_val = jerry_create_external_function (handler_p);
jerry_value_t function_name_val = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t result_val = jerry_set_property (global_obj_val, function_name_val, function_val);
jerry_value_t function_val = jerry_function_external (handler_p);
jerry_value_t function_name_val = jerry_string_sz (name_p);
jerry_value_t result_val = jerry_object_set (global_obj_val, function_name_val, function_val);
jerry_release_value (function_name_val);
jerry_release_value (function_val);
jerry_release_value (global_obj_val);
jerry_value_free (function_name_val);
jerry_value_free (function_val);
jerry_value_free (global_obj_val);
jerry_release_value (result_val);
jerry_value_free (result_val);
} /* register_js_function */
int
@@ -850,10 +850,10 @@ main (void)
register_js_function ("test_validator_restore", test_validator_restore_handler);
jerry_value_t parsed_code_val = jerry_parse (test_source, sizeof (test_source) - 1, NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
TEST_ASSERT (!jerry_value_is_exception (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);
TEST_ASSERT (!jerry_value_is_error (res));
TEST_ASSERT (!jerry_value_is_exception (res));
TEST_ASSERT (validator1_count == 5);
TEST_ASSERT (validator2_count == 3);
TEST_ASSERT (validator_prop_count == 4);
@@ -861,8 +861,8 @@ main (void)
TEST_ASSERT (validator_array_count == 3);
TEST_ASSERT (validator_restore_count == 4);
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_value_free (res);
jerry_value_free (parsed_code_val);
jerry_cleanup ();
} /* main */
tests/unit-ext/test-ext-autorelease.c
+3 -3
View File
@@ -42,8 +42,8 @@ static const jerry_object_native_info_t native_info = {
static jerry_value_t
create_object (void)
{
jerry_value_t obj = jerry_create_object ();
jerry_set_object_native_pointer (obj, NULL, &native_info);
jerry_value_t obj = jerry_object ();
jerry_object_set_native_ptr (obj, &native_info, NULL);
return obj;
} /* create_object */
@@ -61,7 +61,7 @@ main (void)
native_free_cb_call_count = 0;
test_autorelease_val ();
jerry_gc (JERRY_GC_PRESSURE_HIGH);
jerry_heap_gc (JERRY_GC_PRESSURE_HIGH);
TEST_ASSERT (native_free_cb_call_count == 1);
jerry_cleanup ();
tests/unit-ext/test-ext-handle-scope-escape.c
+4 -4
View File
@@ -44,8 +44,8 @@ create_object (void)
{
jerryx_escapable_handle_scope scope;
jerryx_open_escapable_handle_scope (&scope);
jerry_value_t obj = jerryx_create_handle (jerry_create_object ());
jerry_set_object_native_pointer (obj, NULL, &native_info);
jerry_value_t obj = jerryx_create_handle (jerry_object ());
jerry_object_set_native_ptr (obj, &native_info, NULL);
// If leaves `escaped` uninitialized, there will be a style error on linux thrown by compiler
jerry_value_t escaped = 0;
@@ -65,7 +65,7 @@ test_handle_scope_val (void)
jerry_value_t obj = create_object ();
(void) obj;
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == 0);
jerryx_close_handle_scope (scope);
@@ -79,7 +79,7 @@ main (void)
native_free_cb_call_count = 0;
test_handle_scope_val ();
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == 1);
jerry_cleanup ();
tests/unit-ext/test-ext-handle-scope-handle-prelist-escape.c
+4 -4
View File
@@ -51,8 +51,8 @@ create_object (void)
jerry_value_t obj;
for (size_t idx = 0; idx < handle_count; idx++)
{
obj = jerryx_create_handle (jerry_create_object ());
jerry_set_object_native_pointer (obj, NULL, &native_info);
obj = jerryx_create_handle (jerry_object ());
jerry_object_set_native_ptr (obj, &native_info, NULL);
}
// If leaves `escaped` uninitialized, there will be a style error on linux thrown by compiler
@@ -72,7 +72,7 @@ test_handle_scope_val (void)
jerry_value_t obj = create_object ();
(void) obj;
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == (handle_count - 1));
jerryx_close_handle_scope (scope);
@@ -86,7 +86,7 @@ main (void)
native_free_cb_call_count = 0;
test_handle_scope_val ();
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == handle_count);
jerry_cleanup ();
tests/unit-ext/test-ext-handle-scope-handle-prelist.c
+4 -4
View File
@@ -51,8 +51,8 @@ create_object (void)
jerry_value_t obj;
for (size_t idx = 0; idx < handle_count; idx++)
{
obj = jerryx_create_handle (jerry_create_object ());
jerry_set_object_native_pointer (obj, NULL, &native_info);
obj = jerryx_create_handle (jerry_object ());
jerry_object_set_native_ptr (obj, &native_info, NULL);
}
// If leaves `escaped` uninitialized, there will be a style error on linux thrown by compiler
@@ -72,7 +72,7 @@ test_handle_scope_val (void)
jerry_value_t obj = create_object ();
(void) obj;
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == (handle_count - 1));
jerryx_close_handle_scope (scope);
@@ -86,7 +86,7 @@ main (void)
native_free_cb_call_count = 0;
test_handle_scope_val ();
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == handle_count);
jerry_cleanup ();
tests/unit-ext/test-ext-handle-scope-nested.c
+4 -4
View File
@@ -51,8 +51,8 @@ create_object_nested (int times)
jerry_value_t obj;
if (times == 0)
{
obj = jerryx_create_handle (jerry_create_object ());
jerry_set_object_native_pointer (obj, NULL, &native_info);
obj = jerryx_create_handle (jerry_object ());
jerry_object_set_native_ptr (obj, &native_info, NULL);
}
else
{
@@ -85,7 +85,7 @@ test_handle_scope_val (void)
TEST_ASSERT (jerryx_handle_scope_get_current () == scope);
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == 0);
jerryx_close_handle_scope (scope);
@@ -99,7 +99,7 @@ main (void)
native_free_cb_call_count = 0;
test_handle_scope_val ();
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == 2);
jerry_cleanup ();
tests/unit-ext/test-ext-handle-scope-remove.c
+6 -6
View File
@@ -44,8 +44,8 @@ create_object (void)
{
jerryx_escapable_handle_scope scope;
jerryx_open_escapable_handle_scope (&scope);
jerry_value_t obj = jerryx_create_handle (jerry_create_object ());
jerry_set_object_native_pointer (obj, NULL, &native_info);
jerry_value_t obj = jerryx_create_handle (jerry_object ());
jerry_object_set_native_ptr (obj, &native_info, NULL);
// If leaves `escaped` uninitialized, there will be a style error on linux thrown by compiler
jerry_value_t escaped = 0;
@@ -65,15 +65,15 @@ test_handle_scope_val (void)
jerry_value_t obj = create_object ();
(void) obj;
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == 0);
jerryx_close_handle_scope (scope);
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == 0);
jerry_release_value (obj);
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_value_free (obj);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == 1);
} /* test_handle_scope_val */
tests/unit-ext/test-ext-handle-scope-root.c
+4 -4
View File
@@ -43,8 +43,8 @@ static const jerry_object_native_info_t native_info = {
static jerry_value_t
create_object (void)
{
jerry_value_t obj = jerry_create_object ();
jerry_set_object_native_pointer (obj, NULL, &native_info);
jerry_value_t obj = jerry_object ();
jerry_object_set_native_ptr (obj, &native_info, NULL);
return obj;
} /* create_object */
@@ -58,7 +58,7 @@ test_handle_scope_val (void)
jerry_value_t obj = jerryx_create_handle (create_object ());
(void) obj;
jerryx_close_handle_scope (root);
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == (i + 1));
}
} /* test_handle_scope_val */
@@ -71,7 +71,7 @@ main (void)
native_free_cb_call_count = 0;
test_handle_scope_val ();
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == reusing_times);
jerry_cleanup ();
tests/unit-ext/test-ext-handle-scope.c
+3 -3
View File
@@ -42,8 +42,8 @@ static const jerry_object_native_info_t native_info = {
static jerry_value_t
create_object (void)
{
jerry_value_t obj = jerry_create_object ();
jerry_set_object_native_pointer (obj, NULL, &native_info);
jerry_value_t obj = jerry_object ();
jerry_object_set_native_ptr (obj, &native_info, NULL);
return obj;
} /* create_object */
@@ -64,7 +64,7 @@ main (void)
native_free_cb_call_count = 0;
test_handle_scope_val ();
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
TEST_ASSERT (native_free_cb_call_count == 1);
jerry_cleanup ();
tests/unit-ext/test-ext-method-register.c
+60 -60
View File
@@ -31,7 +31,7 @@ method_hello (const jerry_call_info_t *call_info_p, /**< call information */
{
(void) call_info_p;
(void) jargv;
return jerry_create_number (jargc);
return jerry_number (jargc);
} /* method_hello */
/**
@@ -42,14 +42,14 @@ freeze_property (jerry_value_t target_obj, /**< target object */
const char *target_prop) /**< target property name */
{
// "freeze" property
jerry_property_descriptor_t prop_desc = jerry_property_descriptor_create ();
jerry_property_descriptor_t prop_desc = jerry_property_descriptor ();
prop_desc.flags |= JERRY_PROP_IS_CONFIGURABLE_DEFINED;
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) target_prop);
jerry_value_t return_value = jerry_define_own_property (target_obj, prop_name, &prop_desc);
jerry_value_t prop_name = jerry_string_sz (target_prop);
jerry_value_t return_value = jerry_object_define_own_prop (target_obj, prop_name, &prop_desc);
TEST_ASSERT (jerry_value_is_boolean (return_value));
jerry_release_value (return_value);
jerry_release_value (prop_name);
jerry_value_free (return_value);
jerry_value_free (prop_name);
jerry_property_descriptor_free (&prop_desc);
} /* freeze_property */
@@ -62,14 +62,14 @@ test_simple_registration (void)
{
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t target_object = jerry_create_object ();
jerry_value_t target_object = jerry_object ();
// Test simple registration
jerryx_property_entry methods[] = {
JERRYX_PROPERTY_FUNCTION ("hello", method_hello), JERRYX_PROPERTY_NUMBER ("my_number", 42.5),
JERRYX_PROPERTY_STRING ("my_str", "super_str"), JERRYX_PROPERTY_STRING_SZ ("my_str_sz", "super_str", 6),
JERRYX_PROPERTY_BOOLEAN ("my_bool", true), JERRYX_PROPERTY_BOOLEAN ("my_bool_false", false),
JERRYX_PROPERTY_UNDEFINED ("my_non_value"), JERRYX_PROPERTY_LIST_END (),
JERRYX_PROPERTY_FUNCTION ("hello", method_hello), JERRYX_PROPERTY_NUMBER ("my_number", 42.5),
JERRYX_PROPERTY_STRING_SZ ("my_str", "super_str"), JERRYX_PROPERTY_STRING ("my_str_sz", "super_str", 6),
JERRYX_PROPERTY_BOOLEAN ("my_bool", true), JERRYX_PROPERTY_BOOLEAN ("my_bool_false", false),
JERRYX_PROPERTY_UNDEFINED ("my_non_value"), JERRYX_PROPERTY_LIST_END (),
};
jerryx_register_result register_result = jerryx_set_properties (target_object, methods);
@@ -78,19 +78,19 @@ test_simple_registration (void)
TEST_ASSERT (jerry_value_is_undefined (register_result.result));
jerryx_release_property_entry (methods, register_result);
jerry_release_value (register_result.result);
jerry_value_free (register_result.result);
jerry_value_t global_obj = jerry_get_global_object ();
jerry_value_t global_obj = jerry_current_realm ();
jerryx_set_property_str (global_obj, "test", target_object);
jerry_release_value (target_object);
jerry_release_value (global_obj);
jerry_value_free (target_object);
jerry_value_free (global_obj);
{
const char *test_A = "test.my_number";
jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
TEST_ASSERT (jerry_value_is_number (result));
TEST_ASSERT (jerry_get_number_value (result) == 42.5);
jerry_release_value (result);
TEST_ASSERT (jerry_value_as_number (result) == 42.5);
jerry_value_free (result);
}
{
@@ -98,7 +98,7 @@ test_simple_registration (void)
jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
}
{
@@ -106,7 +106,7 @@ test_simple_registration (void)
jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
}
{
@@ -114,7 +114,7 @@ test_simple_registration (void)
jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result));
jerry_release_value (result);
jerry_value_free (result);
}
{
@@ -122,30 +122,30 @@ test_simple_registration (void)
jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_value_is_true (result) == false);
jerry_release_value (result);
jerry_value_free (result);
}
{
const char *test_A = "test.my_non_value";
jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
TEST_ASSERT (jerry_value_is_undefined (result));
jerry_release_value (result);
jerry_value_free (result);
}
{
const char *test_A = "test.hello(33, 42, 2);";
jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
TEST_ASSERT (jerry_value_is_number (result));
TEST_ASSERT ((uint32_t) jerry_get_number_value (result) == 3u);
jerry_release_value (result);
TEST_ASSERT ((uint32_t) jerry_value_as_number (result) == 3u);
jerry_value_free (result);
}
{
const char *test_A = "test.hello();";
jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
TEST_ASSERT (jerry_value_is_number (result));
TEST_ASSERT ((uint32_t) jerry_get_number_value (result) == 0u);
jerry_release_value (result);
TEST_ASSERT ((uint32_t) jerry_value_as_number (result) == 0u);
jerry_value_free (result);
}
jerry_cleanup ();
@@ -163,16 +163,16 @@ test_error_setvalue (void)
jerry_init (JERRY_INIT_EMPTY);
const char *target_prop = "test_err";
jerry_value_t global_obj = jerry_get_global_object ();
jerry_value_t global_obj = jerry_current_realm ();
freeze_property (global_obj, target_prop);
jerry_value_t new_object = jerry_create_object ();
jerry_value_t new_object = jerry_object ();
jerry_value_t set_result = jerryx_set_property_str (global_obj, target_prop, new_object);
TEST_ASSERT (jerry_value_is_error (set_result));
TEST_ASSERT (jerry_value_is_exception (set_result));
jerry_release_value (set_result);
jerry_release_value (new_object);
jerry_release_value (global_obj);
jerry_value_free (set_result);
jerry_value_free (new_object);
jerry_value_free (global_obj);
jerry_cleanup ();
} /* test_error_setvalue */
@@ -189,7 +189,7 @@ test_error_single_function (void)
jerry_init (JERRY_INIT_EMPTY);
const char *target_prop = "test_err";
jerry_value_t target_object = jerry_create_object ();
jerry_value_t target_object = jerry_object ();
freeze_property (target_object, target_prop);
jerryx_property_entry methods[] = {
@@ -200,11 +200,11 @@ test_error_single_function (void)
jerryx_register_result register_result = jerryx_set_properties (target_object, methods);
TEST_ASSERT (register_result.registered == 0);
TEST_ASSERT (jerry_value_is_error (register_result.result));
TEST_ASSERT (jerry_value_is_exception (register_result.result));
jerryx_release_property_entry (methods, register_result);
jerry_release_value (register_result.result);
jerry_value_free (register_result.result);
jerry_release_value (target_object);
jerry_value_free (target_object);
jerry_cleanup ();
} /* test_error_single_function */
@@ -220,7 +220,7 @@ test_error_multiple_functions (void)
const char *prop_ok = "prop_ok";
const char *prop_err = "prop_err";
const char *prop_not = "prop_not";
jerry_value_t target_object = jerry_create_object ();
jerry_value_t target_object = jerry_object ();
freeze_property (target_object, prop_err);
jerryx_property_entry methods[] = {
@@ -233,59 +233,59 @@ test_error_multiple_functions (void)
jerryx_register_result register_result = jerryx_set_properties (target_object, methods);
TEST_ASSERT (register_result.registered == 1);
TEST_ASSERT (jerry_value_is_error (register_result.result));
TEST_ASSERT (jerry_value_is_exception (register_result.result));
jerryx_release_property_entry (methods, register_result);
jerry_release_value (register_result.result);
jerry_value_free (register_result.result);
{
// Test if property "prop_ok" is correctly registered.
jerry_value_t prop_ok_val = jerry_create_string ((const jerry_char_t *) prop_ok);
jerry_value_t prop_ok_exists = jerry_has_own_property (target_object, prop_ok_val);
jerry_value_t prop_ok_val = jerry_string_sz (prop_ok);
jerry_value_t prop_ok_exists = jerry_object_has_own (target_object, prop_ok_val);
TEST_ASSERT (jerry_value_is_true (prop_ok_exists));
jerry_release_value (prop_ok_exists);
jerry_value_free (prop_ok_exists);
// Try calling the method
jerry_value_t prop_ok_func = jerry_get_property (target_object, prop_ok_val);
jerry_value_t prop_ok_func = jerry_object_get (target_object, prop_ok_val);
TEST_ASSERT (jerry_value_is_function (prop_ok_func) == true);
jerry_value_t args[2] = {
jerry_create_number (22),
jerry_create_number (-3),
jerry_number (22),
jerry_number (-3),
};
jerry_size_t args_cnt = sizeof (args) / sizeof (jerry_value_t);
jerry_value_t func_result = jerry_call_function (prop_ok_func, jerry_create_undefined (), args, args_cnt);
jerry_value_t func_result = jerry_call (prop_ok_func, jerry_undefined (), args, args_cnt);
TEST_ASSERT (jerry_value_is_number (func_result) == true);
TEST_ASSERT ((uint32_t) jerry_get_number_value (func_result) == 2u);
jerry_release_value (func_result);
TEST_ASSERT ((uint32_t) jerry_value_as_number (func_result) == 2u);
jerry_value_free (func_result);
for (jerry_size_t idx = 0; idx < args_cnt; idx++)
{
jerry_release_value (args[idx]);
jerry_value_free (args[idx]);
}
jerry_release_value (prop_ok_func);
jerry_release_value (prop_ok_val);
jerry_value_free (prop_ok_func);
jerry_value_free (prop_ok_val);
}
{
// The "prop_err" should exist - as it was "freezed" - but it should not be a function
jerry_value_t prop_err_val = jerry_create_string ((const jerry_char_t *) prop_err);
jerry_value_t prop_err_exists = jerry_has_own_property (target_object, prop_err_val);
jerry_value_t prop_err_val = jerry_string_sz (prop_err);
jerry_value_t prop_err_exists = jerry_object_has_own (target_object, prop_err_val);
TEST_ASSERT (jerry_value_is_true (prop_err_exists));
jerry_release_value (prop_err_exists);
jerry_value_free (prop_err_exists);
jerry_value_t prop_err_func = jerry_value_is_function (prop_err_val);
TEST_ASSERT (jerry_value_is_function (prop_err_func) == false);
jerry_release_value (prop_err_val);
jerry_value_free (prop_err_val);
}
{ // The "prop_not" is not available on the target object
jerry_value_t prop_not_val = jerry_create_string ((const jerry_char_t *) prop_not);
jerry_value_t prop_not_exists = jerry_has_own_property (target_object, prop_not_val);
jerry_value_t prop_not_val = jerry_string_sz (prop_not);
jerry_value_t prop_not_exists = jerry_object_has_own (target_object, prop_not_val);
TEST_ASSERT (jerry_value_is_true (prop_not_exists) == false);
jerry_release_value (prop_not_exists);
jerry_release_value (prop_not_val);
jerry_value_free (prop_not_exists);
jerry_value_free (prop_not_val);
}
jerry_release_value (target_object);
jerry_value_free (target_object);
jerry_cleanup ();
} /* test_error_multiple_functions */
tests/unit-ext/test-ext-module-canonical.c
+22 -22
View File
@@ -26,36 +26,36 @@
static jerry_value_t
get_canonical_name (const jerry_value_t name)
{
jerry_size_t name_size = jerry_get_string_size (name);
jerry_size_t name_size = jerry_string_size (name, JERRY_ENCODING_CESU8);
JERRY_VLA (jerry_char_t, name_string, name_size + 1);
jerry_string_to_char_buffer (name, name_string, name_size);
jerry_string_to_buffer (name, JERRY_ENCODING_CESU8, name_string, name_size);
name_string[name_size] = 0;
if (!strcmp ((char *) name_string, ACTUAL_NAME))
{
return jerry_acquire_value (name);
return jerry_value_copy (name);
}
else if (!strcmp ((char *) name_string, ALIAS_NAME))
{
return jerry_create_string ((jerry_char_t *) ACTUAL_NAME);
return jerry_string_sz (ACTUAL_NAME);
}
else
{
return jerry_create_undefined ();
return jerry_undefined ();
}
} /* get_canonical_name */
static bool
resolve (const jerry_value_t canonical_name, jerry_value_t *result)
{
jerry_size_t name_size = jerry_get_string_size (canonical_name);
jerry_size_t name_size = jerry_string_size (canonical_name, JERRY_ENCODING_CESU8);
JERRY_VLA (jerry_char_t, name_string, name_size + 1);
jerry_string_to_char_buffer (canonical_name, name_string, name_size);
jerry_string_to_buffer (canonical_name, JERRY_ENCODING_CESU8, name_string, name_size);
name_string[name_size] = 0;
if (!strcmp ((char *) name_string, ACTUAL_NAME))
{
*result = jerry_create_object ();
*result = jerry_object ();
return true;
}
return false;
@@ -76,28 +76,28 @@ main (int argc, char **argv)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t actual_name = jerry_create_string ((jerry_char_t *) ACTUAL_NAME);
jerry_value_t alias_name = jerry_create_string ((jerry_char_t *) ALIAS_NAME);
jerry_value_t actual_name = jerry_string_sz (ACTUAL_NAME);
jerry_value_t alias_name = jerry_string_sz (ALIAS_NAME);
/* It's important that we resolve by the non-canonical name first. */
jerry_value_t result2 = jerryx_module_resolve (alias_name, &resolver, 1);
jerry_value_t result1 = jerryx_module_resolve (actual_name, &resolver, 1);
jerry_release_value (actual_name);
jerry_release_value (alias_name);
jerry_value_free (actual_name);
jerry_value_free (alias_name);
/* An elaborate way of doing strict equal - set a property on one object and it "magically" appears on the other. */
jerry_value_t prop_name = jerry_create_string ((jerry_char_t *) "something");
jerry_value_t prop_value = jerry_create_number (TEST_VALUE);
jerry_release_value (jerry_set_property (result1, prop_name, prop_value));
jerry_release_value (prop_value);
jerry_value_t prop_name = jerry_string_sz ("something");
jerry_value_t prop_value = jerry_number (TEST_VALUE);
jerry_value_free (jerry_object_set (result1, prop_name, prop_value));
jerry_value_free (prop_value);
prop_value = jerry_get_property (result2, prop_name);
TEST_ASSERT (jerry_get_number_value (prop_value) == TEST_VALUE);
jerry_release_value (prop_value);
prop_value = jerry_object_get (result2, prop_name);
TEST_ASSERT (jerry_value_as_number (prop_value) == TEST_VALUE);
jerry_value_free (prop_value);
jerry_release_value (prop_name);
jerry_release_value (result1);
jerry_release_value (result2);
jerry_value_free (prop_name);
jerry_value_free (result1);
jerry_value_free (result2);
jerry_cleanup ();
tests/unit-ext/test-ext-module-empty.c
+15 -15
View File
@@ -33,43 +33,43 @@ main (int argc, char **argv)
jerry_init (JERRY_INIT_EMPTY);
/* Attempt to load a non-existing module. */
module_name = jerry_create_string ((jerry_char_t *) "some-unknown-module-name");
module_name = jerry_string_sz ("some-unknown-module-name");
jerry_value_t module = jerryx_module_resolve (module_name, &resolver, 1);
jerry_release_value (module_name);
jerry_value_free (module_name);
TEST_ASSERT (jerry_value_is_error (module));
TEST_ASSERT (jerry_value_is_exception (module));
/* Retrieve the error message. */
module = jerry_get_value_from_error (module, true);
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "message");
jerry_value_t prop = jerry_get_property (module, prop_name);
module = jerry_exception_value (module, true);
jerry_value_t prop_name = jerry_string_sz ("message");
jerry_value_t prop = jerry_object_get (module, prop_name);
/* Assert that the error message is a string with specific contents. */
TEST_ASSERT (jerry_value_is_string (prop));
bytes_copied = jerry_substring_to_utf8_char_buffer (prop, 0, 254, buffer, 256);
bytes_copied = jerry_string_to_buffer (prop, JERRY_ENCODING_UTF8, buffer, sizeof (buffer));
buffer[bytes_copied] = 0;
TEST_ASSERT (!strcmp ((const char *) buffer, "Module not found"));
/* Release the error message property name and value. */
jerry_release_value (prop);
jerry_release_value (prop_name);
jerry_value_free (prop);
jerry_value_free (prop_name);
/* Retrieve the moduleName property. */
prop_name = jerry_create_string ((const jerry_char_t *) "moduleName");
prop = jerry_get_property (module, prop_name);
prop_name = jerry_string_sz ("moduleName");
prop = jerry_object_get (module, prop_name);
/* Assert that the moduleName property is a string containing the requested module name. */
TEST_ASSERT (jerry_value_is_string (prop));
bytes_copied = jerry_substring_to_utf8_char_buffer (prop, 0, 254, buffer, 256);
bytes_copied = jerry_string_to_buffer (prop, JERRY_ENCODING_UTF8, buffer, sizeof (buffer));
buffer[bytes_copied] = 0;
TEST_ASSERT (!strcmp ((const char *) buffer, "some-unknown-module-name"));
/* Release everything. */
jerry_release_value (prop);
jerry_release_value (prop_name);
jerry_release_value (module);
jerry_value_free (prop);
jerry_value_free (prop_name);
jerry_value_free (module);
return 0;
} /* main */