From cf94a25753c0c4478bebf4e7b2347e408a98dbad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A1szl=C3=B3=20Lang=C3=B3?= Date: Wed, 7 Sep 2016 09:49:49 +0200 Subject: [PATCH] Change JERRY_ASSERT to TEST_ASSERT in unittests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit JERRY_ASSERT does not check the condition in release builds. JerryScript-DCO-1.0-Signed-off-by: László Langó llango.u-szeged@partner.samsung.com --- tests/unit/test-api.c | 296 +++++++++++++++++++++--------------------- 1 file changed, 148 insertions(+), 148 deletions(-) diff --git a/tests/unit/test-api.c b/tests/unit/test-api.c index 412fee784..a6a86eaa5 100644 --- a/tests/unit/test-api.c +++ b/tests/unit/test-api.c @@ -75,9 +75,9 @@ handler (const jerry_value_t func_obj_val, /**< function object */ TEST_ASSERT (args_cnt == 2); - JERRY_ASSERT (jerry_value_is_string (args_p[0])); + TEST_ASSERT (jerry_value_is_string (args_p[0])); sz = jerry_get_string_size (args_p[0]); - JERRY_ASSERT (sz == 1); + TEST_ASSERT (sz == 1); sz = jerry_string_to_char_buffer (args_p[0], (jerry_char_t *) buffer, sz); @@ -133,7 +133,7 @@ handler_construct (const jerry_value_t func_obj_val, /**< function object */ uintptr_t ptr = (uintptr_t) NULL; bool is_ok = jerry_get_object_native_handle (this_val, &ptr); - JERRY_ASSERT (is_ok && ptr == (uintptr_t) 0x0000000000000000ull); + TEST_ASSERT (is_ok && ptr == (uintptr_t) 0x0000000000000000ull); /* check if setting handle for second time is handled correctly */ jerry_set_object_native_handle (this_val, @@ -187,44 +187,44 @@ foreach (const jerry_value_t name, /**< field name */ jerry_size_t sz = jerry_string_to_char_buffer (name, (jerry_char_t *) str_buf_p, 128); str_buf_p[sz] = '\0'; - JERRY_ASSERT (!strncmp ((const char *) user_data, "user_data", 9)); - JERRY_ASSERT (sz > 0); + TEST_ASSERT (!strncmp ((const char *) user_data, "user_data", 9)); + TEST_ASSERT (sz > 0); if (!strncmp (str_buf_p, "alpha", (size_t) sz)) { - JERRY_ASSERT (jerry_value_is_number (value)); - JERRY_ASSERT (jerry_get_number_value (value) == 32.0); + TEST_ASSERT (jerry_value_is_number (value)); + TEST_ASSERT (jerry_get_number_value (value) == 32.0); return true; } else if (!strncmp (str_buf_p, "bravo", (size_t) sz)) { - JERRY_ASSERT (jerry_value_is_boolean (value)); - JERRY_ASSERT (jerry_get_boolean_value (value) == false); + TEST_ASSERT (jerry_value_is_boolean (value)); + TEST_ASSERT (jerry_get_boolean_value (value) == false); return true; } else if (!strncmp (str_buf_p, "charlie", (size_t) sz)) { - JERRY_ASSERT (jerry_value_is_object (value)); + TEST_ASSERT (jerry_value_is_object (value)); return true; } else if (!strncmp (str_buf_p, "delta", (size_t) sz)) { - JERRY_ASSERT (jerry_value_is_number (value)); - JERRY_ASSERT (jerry_get_number_value (value) == 123.45); + TEST_ASSERT (jerry_value_is_number (value)); + TEST_ASSERT (jerry_get_number_value (value) == 123.45); return true; } else if (!strncmp (str_buf_p, "echo", (size_t) sz)) { - JERRY_ASSERT (jerry_value_is_string (value)); + TEST_ASSERT (jerry_value_is_string (value)); jerry_size_t echo_sz = jerry_string_to_char_buffer (value, (jerry_char_t *) str_buf_p, 128); str_buf_p[echo_sz] = '\0'; - JERRY_ASSERT (!strncmp (str_buf_p, "foobar", (size_t) echo_sz)); + TEST_ASSERT (!strncmp (str_buf_p, "foobar", (size_t) echo_sz)); return true; } - JERRY_ASSERT (false); + TEST_ASSERT (false); return false; @@ -313,18 +313,18 @@ main (void) char buffer[32]; is_ok = test_run_simple ("print ('Hello, World!');"); - JERRY_ASSERT (is_ok); + TEST_ASSERT (is_ok); is_ok = test_run_simple ("throw 'Hello World';"); - JERRY_ASSERT (!is_ok); + TEST_ASSERT (!is_ok); jerry_init (JERRY_INIT_EMPTY); parsed_code_val = jerry_parse ((jerry_char_t *) test_source, strlen (test_source), false); - JERRY_ASSERT (!jerry_value_has_error_flag (parsed_code_val)); + TEST_ASSERT (!jerry_value_has_error_flag (parsed_code_val)); res = jerry_run (parsed_code_val); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); jerry_release_value (res); jerry_release_value (parsed_code_val); @@ -333,44 +333,44 @@ main (void) // Test corner case for jerry_string_to_char_buffer args[0] = jerry_create_string ((jerry_char_t *) ""); sz = jerry_get_string_size (args[0]); - JERRY_ASSERT (sz == 0); + TEST_ASSERT (sz == 0); jerry_release_value (args[0]); // Get global.boo (non-existing field) val_t = get_property (global_obj_val, "boo"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); - JERRY_ASSERT (jerry_value_is_undefined (val_t)); + TEST_ASSERT (!jerry_value_has_error_flag (val_t)); + TEST_ASSERT (jerry_value_is_undefined (val_t)); // Get global.t val_t = get_property (global_obj_val, "t"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); - JERRY_ASSERT (jerry_value_is_number (val_t) + TEST_ASSERT (!jerry_value_has_error_flag (val_t)); + TEST_ASSERT (jerry_value_is_number (val_t) && jerry_get_number_value (val_t) == 1.0); jerry_release_value (val_t); // Get global.foo val_foo = get_property (global_obj_val, "foo"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_foo)); - JERRY_ASSERT (jerry_value_is_object (val_foo)); + TEST_ASSERT (!jerry_value_has_error_flag (val_foo)); + TEST_ASSERT (jerry_value_is_object (val_foo)); // Call foo (4, 2) args[0] = jerry_create_number (4); args[1] = jerry_create_number (2); res = jerry_call_function (val_foo, jerry_create_undefined (), args, 2); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_number (res) + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_number (res) && jerry_get_number_value (res) == 1.0); jerry_release_value (res); // Get global.bar val_bar = get_property (global_obj_val, "bar"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_bar)); - JERRY_ASSERT (jerry_value_is_object (val_bar)); + TEST_ASSERT (!jerry_value_has_error_flag (val_bar)); + TEST_ASSERT (jerry_value_is_object (val_bar)); // Call bar (4, 2) res = jerry_call_function (val_bar, jerry_create_undefined (), args, 2); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_number (res) + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_number (res) && jerry_get_number_value (res) == 5.0); jerry_release_value (res); jerry_release_value (val_bar); @@ -379,18 +379,18 @@ main (void) jerry_release_value (args[0]); args[0] = jerry_create_string ((jerry_char_t *) "abcd"); res = set_property (global_obj_val, "t", args[0]); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_get_boolean_value (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (res); // Call foo (4, 2) res = jerry_call_function (val_foo, jerry_create_undefined (), args, 2); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_string (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_string (res)); sz = jerry_get_string_size (res); - JERRY_ASSERT (sz == 4); + TEST_ASSERT (sz == 4); sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz); - JERRY_ASSERT (sz == 4); + TEST_ASSERT (sz == 4); jerry_release_value (res); TEST_ASSERT (!strncmp (buffer, "abcd", (size_t) sz)); jerry_release_value (args[0]); @@ -398,64 +398,64 @@ main (void) // Get global.A val_A = get_property (global_obj_val, "A"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_A)); - JERRY_ASSERT (jerry_value_is_object (val_A)); + TEST_ASSERT (!jerry_value_has_error_flag (val_A)); + TEST_ASSERT (jerry_value_is_object (val_A)); // Get A.prototype is_ok = jerry_value_is_constructor (val_A); - JERRY_ASSERT (is_ok); + TEST_ASSERT (is_ok); val_A_prototype = get_property (val_A, "prototype"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_A_prototype)); - JERRY_ASSERT (jerry_value_is_object (val_A_prototype)); + TEST_ASSERT (!jerry_value_has_error_flag (val_A_prototype)); + TEST_ASSERT (jerry_value_is_object (val_A_prototype)); jerry_release_value (val_A); // Set A.prototype.foo = global.foo res = set_property (val_A_prototype, "foo", val_foo); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_get_boolean_value (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (res); jerry_release_value (val_A_prototype); jerry_release_value (val_foo); // Get global.a val_a = get_property (global_obj_val, "a"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_a)); - JERRY_ASSERT (jerry_value_is_object (val_a)); + TEST_ASSERT (!jerry_value_has_error_flag (val_a)); + TEST_ASSERT (jerry_value_is_object (val_a)); // Get a.t res = get_property (val_a, "t"); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_number (res) + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_number (res) && jerry_get_number_value (res) == 12.0); jerry_release_value (res); // foreach properties val_p = get_property (global_obj_val, "p"); is_ok = jerry_foreach_object_property (val_p, foreach, (void *) "user_data"); - JERRY_ASSERT (is_ok); + TEST_ASSERT (is_ok); // break foreach at third element int count = 0; is_ok = jerry_foreach_object_property (val_p, foreach_subset, &count); - JERRY_ASSERT (is_ok); - JERRY_ASSERT (count == 3); + TEST_ASSERT (is_ok); + TEST_ASSERT (count == 3); jerry_release_value (val_p); // foreach with throw test val_np = get_property (global_obj_val, "np"); is_ok = !jerry_foreach_object_property (val_np, foreach_exception, NULL); - JERRY_ASSERT (is_ok); + TEST_ASSERT (is_ok); jerry_release_value (val_np); // Get a.foo val_a_foo = get_property (val_a, "foo"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_a_foo)); - JERRY_ASSERT (jerry_value_is_object (val_a_foo)); + TEST_ASSERT (!jerry_value_has_error_flag (val_a_foo)); + TEST_ASSERT (jerry_value_is_object (val_a_foo)); // Call a.foo () res = jerry_call_function (val_a_foo, val_a, NULL, 0); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_number (res) + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_number (res) && jerry_get_number_value (res) == 12.0); jerry_release_value (res); jerry_release_value (val_a_foo); @@ -464,87 +464,87 @@ main (void) // Create native handler bound function object and set it to 'external' variable external_func_val = jerry_create_external_function (handler); - JERRY_ASSERT (jerry_value_is_function (external_func_val) + TEST_ASSERT (jerry_value_is_function (external_func_val) && jerry_value_is_constructor (external_func_val)); res = set_property (global_obj_val, "external", external_func_val); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_get_boolean_value (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (external_func_val); // Call 'call_external' function that should call external function created above val_call_external = get_property (global_obj_val, "call_external"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_call_external)); - JERRY_ASSERT (jerry_value_is_object (val_call_external)); + TEST_ASSERT (!jerry_value_has_error_flag (val_call_external)); + TEST_ASSERT (jerry_value_is_object (val_call_external)); res = jerry_call_function (val_call_external, global_obj_val, NULL, 0); jerry_release_value (val_call_external); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_string (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_string (res)); sz = jerry_get_string_size (res); - JERRY_ASSERT (sz == 19); + TEST_ASSERT (sz == 19); sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz); - JERRY_ASSERT (sz == 19); + TEST_ASSERT (sz == 19); jerry_release_value (res); TEST_ASSERT (!strncmp (buffer, "string from handler", (size_t) sz)); // Create native handler bound function object and set it to 'external_construct' variable external_construct_val = jerry_create_external_function (handler_construct); - JERRY_ASSERT (jerry_value_is_function (external_construct_val) + TEST_ASSERT (jerry_value_is_function (external_construct_val) && jerry_value_is_constructor (external_construct_val)); res = set_property (global_obj_val, "external_construct", external_construct_val); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_get_boolean_value (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (res); // Call external function created above, as constructor args[0] = jerry_create_boolean (true); res = jerry_construct_object (external_construct_val, args, 1); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_object (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_object (res)); val_value_field = get_property (res, "value_field"); // Get 'value_field' of constructed object - JERRY_ASSERT (!jerry_value_has_error_flag (val_value_field)); - JERRY_ASSERT (jerry_value_is_boolean (val_value_field) + TEST_ASSERT (!jerry_value_has_error_flag (val_value_field)); + TEST_ASSERT (jerry_value_is_boolean (val_value_field) && jerry_get_boolean_value (val_value_field)); jerry_release_value (val_value_field); jerry_release_value (external_construct_val); uintptr_t ptr = (uintptr_t) NULL; is_ok = jerry_get_object_native_handle (res, &ptr); - JERRY_ASSERT (is_ok + TEST_ASSERT (is_ok && ptr == (uintptr_t) 0x0012345678abcdefull); jerry_release_value (res); // Test: Throwing exception from native handler. throw_test_handler_val = jerry_create_external_function (handler_throw_test); - JERRY_ASSERT (jerry_value_is_function (throw_test_handler_val)); + TEST_ASSERT (jerry_value_is_function (throw_test_handler_val)); res = set_property (global_obj_val, "throw_test", throw_test_handler_val); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_get_boolean_value (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (res); jerry_release_value (throw_test_handler_val); val_t = get_property (global_obj_val, "call_throw_test"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); - JERRY_ASSERT (jerry_value_is_object (val_t)); + TEST_ASSERT (!jerry_value_has_error_flag (val_t)); + TEST_ASSERT (jerry_value_is_object (val_t)); res = jerry_call_function (val_t, global_obj_val, NULL, 0); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); jerry_release_value (val_t); jerry_release_value (res); // Test: Unhandled exception in called function val_t = get_property (global_obj_val, "throw_reference_error"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); - JERRY_ASSERT (jerry_value_is_object (val_t)); + TEST_ASSERT (!jerry_value_has_error_flag (val_t)); + TEST_ASSERT (jerry_value_is_object (val_t)); res = jerry_call_function (val_t, global_obj_val, NULL, 0); - JERRY_ASSERT (jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_has_error_flag (res)); jerry_release_value (val_t); // 'res' should contain exception object @@ -554,7 +554,7 @@ main (void) // Test: Call of non-function obj_val = jerry_create_object (); res = jerry_call_function (obj_val, global_obj_val, NULL, 0); - JERRY_ASSERT (jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_has_error_flag (res)); // 'res' should contain exception object TEST_ASSERT (jerry_value_is_object (res)); @@ -564,11 +564,11 @@ main (void) // Test: Unhandled exception in function called, as constructor val_t = get_property (global_obj_val, "throw_reference_error"); - JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); - JERRY_ASSERT (jerry_value_is_object (val_t)); + TEST_ASSERT (!jerry_value_has_error_flag (val_t)); + TEST_ASSERT (jerry_value_is_object (val_t)); res = jerry_construct_object (val_t, NULL, 0); - JERRY_ASSERT (jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_has_error_flag (res)); jerry_release_value (val_t); // 'res' should contain exception object @@ -578,7 +578,7 @@ main (void) // Test: Call of non-function as constructor obj_val = jerry_create_object (); res = jerry_construct_object (obj_val, NULL, 0); - JERRY_ASSERT (jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_has_error_flag (res)); // 'res' should contain exception object TEST_ASSERT (jerry_value_is_object (res)); @@ -588,8 +588,8 @@ main (void) // Test: Array Object API jerry_value_t array_obj_val = jerry_create_array (10); - JERRY_ASSERT (jerry_value_is_array (array_obj_val)); - JERRY_ASSERT (jerry_get_array_length (array_obj_val) == 10); + TEST_ASSERT (jerry_value_is_array (array_obj_val)); + TEST_ASSERT (jerry_get_array_length (array_obj_val) == 10); jerry_value_t v_in = jerry_create_number (10.5); jerry_set_property_by_index (array_obj_val, 5, v_in); @@ -605,94 +605,94 @@ main (void) // Test: init property descriptor jerry_property_descriptor_t prop_desc; jerry_init_property_descriptor_fields (&prop_desc); - JERRY_ASSERT (prop_desc.is_value_defined == false); - JERRY_ASSERT (jerry_value_is_undefined (prop_desc.value)); - JERRY_ASSERT (prop_desc.is_writable_defined == false); - JERRY_ASSERT (prop_desc.is_writable == false); - JERRY_ASSERT (prop_desc.is_enumerable_defined == false); - JERRY_ASSERT (prop_desc.is_enumerable == false); - JERRY_ASSERT (prop_desc.is_configurable_defined == false); - JERRY_ASSERT (prop_desc.is_configurable == false); - JERRY_ASSERT (prop_desc.is_get_defined == false); - JERRY_ASSERT (jerry_value_is_undefined (prop_desc.getter)); - JERRY_ASSERT (prop_desc.is_set_defined == false); - JERRY_ASSERT (jerry_value_is_undefined (prop_desc.setter)); + TEST_ASSERT (prop_desc.is_value_defined == false); + TEST_ASSERT (jerry_value_is_undefined (prop_desc.value)); + TEST_ASSERT (prop_desc.is_writable_defined == false); + TEST_ASSERT (prop_desc.is_writable == false); + TEST_ASSERT (prop_desc.is_enumerable_defined == false); + TEST_ASSERT (prop_desc.is_enumerable == false); + TEST_ASSERT (prop_desc.is_configurable_defined == false); + TEST_ASSERT (prop_desc.is_configurable == false); + TEST_ASSERT (prop_desc.is_get_defined == false); + TEST_ASSERT (jerry_value_is_undefined (prop_desc.getter)); + TEST_ASSERT (prop_desc.is_set_defined == false); + TEST_ASSERT (jerry_value_is_undefined (prop_desc.setter)); // Test: define own properties jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "my_defined_property"); prop_desc.is_value_defined = true; prop_desc.value = jerry_acquire_value (prop_name); res = jerry_define_own_property (global_obj_val, prop_name, &prop_desc); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_boolean (res)); - JERRY_ASSERT (jerry_get_boolean_value (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_boolean (res)); + TEST_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (res); jerry_free_property_descriptor_fields (&prop_desc); // Test: get own property descriptor is_ok = jerry_get_own_property_descriptor (global_obj_val, prop_name, &prop_desc); - JERRY_ASSERT (is_ok); - JERRY_ASSERT (prop_desc.is_value_defined == true); - JERRY_ASSERT (jerry_value_is_string (prop_desc.value)); - JERRY_ASSERT (prop_desc.is_writable == false); - JERRY_ASSERT (prop_desc.is_enumerable == false); - JERRY_ASSERT (prop_desc.is_configurable == false); - JERRY_ASSERT (prop_desc.is_get_defined == false); - JERRY_ASSERT (jerry_value_is_undefined (prop_desc.getter)); - JERRY_ASSERT (prop_desc.is_set_defined == false); - JERRY_ASSERT (jerry_value_is_undefined (prop_desc.setter)); + TEST_ASSERT (is_ok); + TEST_ASSERT (prop_desc.is_value_defined == true); + TEST_ASSERT (jerry_value_is_string (prop_desc.value)); + TEST_ASSERT (prop_desc.is_writable == false); + TEST_ASSERT (prop_desc.is_enumerable == false); + TEST_ASSERT (prop_desc.is_configurable == false); + TEST_ASSERT (prop_desc.is_get_defined == false); + TEST_ASSERT (jerry_value_is_undefined (prop_desc.getter)); + TEST_ASSERT (prop_desc.is_set_defined == false); + TEST_ASSERT (jerry_value_is_undefined (prop_desc.setter)); jerry_release_value (prop_name); jerry_free_property_descriptor_fields (&prop_desc); // Test: object keys res = jerry_get_object_keys (global_obj_val); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_array (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_array (res)); jerry_release_value (res); // Test: jerry_value_to_primitive obj_val = jerry_eval ((jerry_char_t *) "new String ('hello')", 20, false); - JERRY_ASSERT (!jerry_value_has_error_flag (obj_val)); - JERRY_ASSERT (jerry_value_is_object (obj_val)); - JERRY_ASSERT (!jerry_value_is_string (obj_val)); + TEST_ASSERT (!jerry_value_has_error_flag (obj_val)); + TEST_ASSERT (jerry_value_is_object (obj_val)); + TEST_ASSERT (!jerry_value_is_string (obj_val)); prim_val = jerry_value_to_primitive (obj_val); - JERRY_ASSERT (!jerry_value_has_error_flag (prim_val)); - JERRY_ASSERT (jerry_value_is_string (prim_val)); + TEST_ASSERT (!jerry_value_has_error_flag (prim_val)); + TEST_ASSERT (jerry_value_is_string (prim_val)); jerry_release_value (prim_val); // Test: jerry_get_prototype proto_val = jerry_get_prototype (obj_val); - JERRY_ASSERT (!jerry_value_has_error_flag (proto_val)); - JERRY_ASSERT (jerry_value_is_object (proto_val)); + TEST_ASSERT (!jerry_value_has_error_flag (proto_val)); + TEST_ASSERT (jerry_value_is_object (proto_val)); jerry_release_value (obj_val); // Test: jerry_set_prototype obj_val = jerry_create_object (); res = jerry_set_prototype (obj_val, jerry_create_null ()); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_boolean (res)); - JERRY_ASSERT (jerry_get_boolean_value (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_boolean (res)); + TEST_ASSERT (jerry_get_boolean_value (res)); res = jerry_set_prototype (obj_val, jerry_create_object ()); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_boolean (res)); - JERRY_ASSERT (jerry_get_boolean_value (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_boolean (res)); + TEST_ASSERT (jerry_get_boolean_value (res)); proto_val = jerry_get_prototype (obj_val); - JERRY_ASSERT (!jerry_value_has_error_flag (proto_val)); - JERRY_ASSERT (jerry_value_is_object (proto_val)); + TEST_ASSERT (!jerry_value_has_error_flag (proto_val)); + TEST_ASSERT (jerry_value_is_object (proto_val)); jerry_release_value (proto_val); jerry_release_value (obj_val); // Test: eval const char *eval_code_src_p = "(function () { return 123; })"; val_t = jerry_eval ((jerry_char_t *) eval_code_src_p, strlen (eval_code_src_p), true); - JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); - JERRY_ASSERT (jerry_value_is_object (val_t)); - JERRY_ASSERT (jerry_value_is_function (val_t)); + TEST_ASSERT (!jerry_value_has_error_flag (val_t)); + TEST_ASSERT (jerry_value_is_object (val_t)); + TEST_ASSERT (jerry_value_is_function (val_t)); res = jerry_call_function (val_t, jerry_create_undefined (), NULL, 0); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_number (res) + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_number (res) && jerry_get_number_value (res) == 123.0); jerry_release_value (res); @@ -734,10 +734,10 @@ main (void) const char *ms_code_src_p = "var global = {}; var console = [1]; var process = 1;"; parsed_code_val = jerry_parse ((jerry_char_t *) ms_code_src_p, strlen (ms_code_src_p), false); - JERRY_ASSERT (!jerry_value_has_error_flag (parsed_code_val)); + TEST_ASSERT (!jerry_value_has_error_flag (parsed_code_val)); res = jerry_run (parsed_code_val); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); jerry_release_value (res); jerry_release_value (parsed_code_val); @@ -777,25 +777,25 @@ main (void) global_mode_snapshot_size, false); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_string (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_string (res)); sz = jerry_get_string_size (res); - JERRY_ASSERT (sz == 20); + TEST_ASSERT (sz == 20); sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz); - JERRY_ASSERT (sz == 20); + TEST_ASSERT (sz == 20); jerry_release_value (res); - JERRY_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz)); + TEST_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz)); res = jerry_exec_snapshot (eval_mode_snapshot_buffer, eval_mode_snapshot_size, false); - JERRY_ASSERT (!jerry_value_has_error_flag (res)); - JERRY_ASSERT (jerry_value_is_string (res)); + TEST_ASSERT (!jerry_value_has_error_flag (res)); + TEST_ASSERT (jerry_value_is_string (res)); sz = jerry_get_string_size (res); - JERRY_ASSERT (sz == 20); + TEST_ASSERT (sz == 20); sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz); - JERRY_ASSERT (sz == 20); + TEST_ASSERT (sz == 20); jerry_release_value (res); TEST_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz));