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

Don't use strlen for string literals (#2517)

Browse Source 
Their length (size) is known at compile time. Therefore `sizeof`
is more efficient for them.

JerryScript-DCO-1.0-Signed-off-by: Akos Kiss akiss@inf.u-szeged.hu
This commit is contained in:
Akos Kiss
2018-09-17 10:07:24 +02:00
committed by László Langó
parent 2d83d8ed17
commit 3d3a8008a8
24 changed files with 367 additions and 389 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit-core/test-abort.c
+35 -31
View File
@@ -52,20 +52,22 @@ main (void)
jerry_release_value (callback_name);
jerry_release_value (global);
const char *inf_loop_code_src_p = ("while(true) {\n"
" with ({}) {\n"
" try {\n"
" callback();\n"
" } catch (e) {\n"
" } finally {\n"
" }\n"
" }\n"
"}");
const jerry_char_t inf_loop_code_src1[] = TEST_STRING_LITERAL (
"while(true) {\n"
" with ({}) {\n"
" try {\n"
" callback();\n"
" } catch (e) {\n"
" } finally {\n"
" }\n"
" }\n"
"}"
);
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
(jerry_char_t *) inf_loop_code_src_p,
strlen (inf_loop_code_src_p),
inf_loop_code_src1,
sizeof (inf_loop_code_src1) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
@@ -76,29 +78,31 @@ main (void)
jerry_release_value (res);
jerry_release_value (parsed_code_val);
inf_loop_code_src_p = ("function f() {"
" while(true) {\n"
" with ({}) {\n"
" try {\n"
" callback();\n"
" } catch (e) {\n"
" } finally {\n"
" }\n"
" }\n"
" }"
"}\n"
"function g() {\n"
" for (a in { x:5 })\n"
" f();\n"
"}\n"
"\n"
"with({})\n"
" f();\n");
const jerry_char_t inf_loop_code_src2[] = TEST_STRING_LITERAL (
"function f() {"
" while(true) {\n"
" with ({}) {\n"
" try {\n"
" callback();\n"
" } catch (e) {\n"
" } finally {\n"
" }\n"
" }\n"
" }"
"}\n"
"function g() {\n"
" for (a in { x:5 })\n"
" f();\n"
"}\n"
"\n"
"with({})\n"
" f();\n"
);
parsed_code_val = jerry_parse (NULL,
0,
(jerry_char_t *) inf_loop_code_src_p,
strlen (inf_loop_code_src_p),
inf_loop_code_src2,
sizeof (inf_loop_code_src2) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
tests/unit-core/test-api-set-and-clear-error-flag.c
+15 -15
View File
@@ -17,7 +17,7 @@
#include "test-common.h"
static void
compare_str (jerry_value_t value, const char *str_p, size_t str_len)
compare_str (jerry_value_t value, const jerry_char_t *str_p, size_t str_len)
{
jerry_size_t size = jerry_get_string_size (value);
JERRY_ASSERT (str_len == size);
@@ -43,56 +43,56 @@ main (void)
jerry_release_value (err_val);
jerry_release_value (obj_val);
const char *pterodactylus_p = "Pterodactylus";
const size_t pterodactylus_size = strlen (pterodactylus_p);
const jerry_char_t pterodactylus[] = "Pterodactylus";
const size_t pterodactylus_size = sizeof (pterodactylus) - 1;
jerry_value_t str = jerry_create_string ((jerry_char_t *) pterodactylus_p);
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);
compare_str (str, pterodactylus_p, pterodactylus_size);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
str = jerry_create_string ((jerry_char_t *) pterodactylus_p);
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);
compare_str (str, pterodactylus_p, pterodactylus_size);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
str = jerry_create_string ((jerry_char_t *) pterodactylus_p);
str = jerry_create_string (pterodactylus);
error = jerry_create_abort_from_value (str, true);
str = jerry_get_value_from_error (error, true);
compare_str (str, pterodactylus_p, pterodactylus_size);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
str = jerry_create_string ((jerry_char_t *) pterodactylus_p);
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);
compare_str (str, pterodactylus_p, pterodactylus_size);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
str = jerry_create_string ((jerry_char_t *) pterodactylus_p);
str = jerry_create_string (pterodactylus);
error = jerry_create_error_from_value (str, true);
error = jerry_create_abort_from_value (error, true);
JERRY_ASSERT (jerry_value_is_abort (error));
str = jerry_get_value_from_error (error, true);
compare_str (str, pterodactylus_p, pterodactylus_size);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
str = jerry_create_string ((jerry_char_t *) pterodactylus_p);
str = jerry_create_string (pterodactylus);
error = jerry_create_error_from_value (str, true);
jerry_value_t error2 = jerry_create_abort_from_value (error, false);
JERRY_ASSERT (jerry_value_is_abort (error2));
jerry_release_value (error);
str = jerry_get_value_from_error (error2, true);
compare_str (str, pterodactylus_p, pterodactylus_size);
compare_str (str, pterodactylus, pterodactylus_size);
jerry_release_value (str);
double test_num = 3.1415926;
tests/unit-core/test-api-value-type.c
+2 -2
View File
@@ -46,7 +46,7 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_char_t test_eval_function[] = "function demo(a) { return a + 1; }; demo";
const jerry_char_t test_eval_function[] = "function demo(a) { return a + 1; }; demo";
test_entry_t entries[] =
{
@@ -68,7 +68,7 @@ main (void)
ENTRY (JERRY_TYPE_NULL, jerry_create_null ()),
ENTRY (JERRY_TYPE_FUNCTION, jerry_eval (test_eval_function,
strlen ((char *) test_eval_function),
sizeof (test_eval_function) - 1,
JERRY_PARSE_NO_OPTS)),
ENTRY (JERRY_TYPE_FUNCTION, jerry_create_external_function (test_ext_function)),
tests/unit-core/test-api.c
+75 -84
View File
@@ -18,46 +18,46 @@
#include "test-common.h"
const char *test_source = (
"function assert (arg) { "
" if (!arg) { "
" throw Error('Assert failed');"
" } "
"} "
"this.t = 1; "
"function f () { "
"return this.t; "
"} "
"this.foo = f; "
"this.bar = function (a) { "
"return a + t; "
"}; "
"function A () { "
"this.t = 12; "
"} "
"this.A = A; "
"this.a = new A (); "
"function call_external () { "
" return this.external ('1', true); "
"} "
"function call_throw_test() { "
" var catched = false; "
" try { "
" this.throw_test(); "
" } catch (e) { "
" catched = true; "
" assert(e.name == 'TypeError'); "
" assert(e.message == 'error'); "
" } "
" assert(catched); "
"} "
"function throw_reference_error() { "
" throw new ReferenceError ();"
"} "
"p = {'alpha':32, 'bravo':false, 'charlie':{}, 'delta':123.45, 'echo':'foobar'};"
"np = {}; Object.defineProperty (np, 'foxtrot', { "
"get: function() { throw 'error'; }, enumerable: true }) "
);
const jerry_char_t test_source[] = TEST_STRING_LITERAL (
"function assert (arg) { "
" if (!arg) { "
" throw Error('Assert failed');"
" } "
"} "
"this.t = 1; "
"function f () { "
"return this.t; "
"} "
"this.foo = f; "
"this.bar = function (a) { "
"return a + t; "
"}; "
"function A () { "
"this.t = 12; "
"} "
"this.A = A; "
"this.a = new A (); "
"function call_external () { "
" return this.external ('1', true); "
"} "
"function call_throw_test() { "
" var catched = false; "
" try { "
" this.throw_test(); "
" } catch (e) { "
" catched = true; "
" assert(e.name == 'TypeError'); "
" assert(e.message == 'error'); "
" } "
" assert(catched); "
"} "
"function throw_reference_error() { "
" throw new ReferenceError ();"
"} "
"p = {'alpha':32, 'bravo':false, 'charlie':{}, 'delta':123.45, 'echo':'foobar'};"
"np = {}; Object.defineProperty (np, 'foxtrot', { "
"get: function() { throw 'error'; }, enumerable: true }) "
);
bool test_api_is_free_callback_was_called = false;
@@ -322,21 +322,14 @@ static bool
strict_equals (jerry_value_t a,
jerry_value_t b)
{
bool is_strict_equal;
const char *is_equal_src;
jerry_value_t args[2];
jerry_value_t is_equal_fn_val;
jerry_value_t res;
is_equal_src = "var isEqual = function(a, b) { return (a === b); }; isEqual";
is_equal_fn_val = jerry_eval ((jerry_char_t *) is_equal_src, strlen (is_equal_src), JERRY_PARSE_NO_OPTS);
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));
args[0] = a;
args[1] = b;
res = jerry_call_function (is_equal_fn_val, jerry_create_undefined (), args, 2);
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));
TEST_ASSERT (jerry_value_is_boolean (res));
is_strict_equal = jerry_get_boolean_value (res);
bool is_strict_equal = jerry_get_boolean_value (res);
jerry_release_value (res);
jerry_release_value (is_equal_fn_val);
return is_strict_equal;
@@ -367,8 +360,8 @@ main (void)
parsed_code_val = jerry_parse (NULL,
0,
(jerry_char_t *) test_source,
strlen (test_source),
test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
@@ -1000,8 +993,8 @@ main (void)
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), JERRY_PARSE_STRICT_MODE);
const jerry_char_t eval_code_src1[] = "(function () { return 123; })";
val_t = jerry_eval (eval_code_src1, sizeof (eval_code_src1) - 1, JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (!jerry_value_is_error (val_t));
TEST_ASSERT (jerry_value_is_object (val_t));
TEST_ASSERT (jerry_value_is_function (val_t));
@@ -1021,8 +1014,8 @@ main (void)
jerry_gc (JERRY_GC_SEVERITY_LOW);
/* Test: spaces */
eval_code_src_p = "\x0a \x0b \x0c \xc2\xa0 \xe2\x80\xa8 \xe2\x80\xa9 \xef\xbb\xbf 4321";
val_t = jerry_eval ((jerry_char_t *) eval_code_src_p, strlen (eval_code_src_p), JERRY_PARSE_STRICT_MODE);
const jerry_char_t eval_code_src2[] = "\x0a \x0b \x0c \xc2\xa0 \xe2\x80\xa8 \xe2\x80\xa9 \xef\xbb\xbf 4321";
val_t = jerry_eval (eval_code_src2, sizeof (eval_code_src2) - 1, JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (!jerry_value_is_error (val_t));
TEST_ASSERT (jerry_value_is_number (val_t)
&& jerry_get_number_value (val_t) == 4321.0);
@@ -1045,16 +1038,16 @@ main (void)
jerry_release_value (val_t);
/* Test: create function */
const char *func_resource = "unknown";
const char *func_arg_list = "a , b,c";
const char *func_src = " return 5 + a+\nb+c";
const jerry_char_t func_resource[] = "unknown";
const jerry_char_t func_arg_list[] = "a , b,c";
const jerry_char_t func_src[] = " return 5 + a+\nb+c";
jerry_value_t func_val = jerry_parse_function ((const jerry_char_t *) func_resource,
strlen (func_resource),
(const jerry_char_t *) func_arg_list,
strlen (func_arg_list),
(const jerry_char_t *) func_src,
strlen (func_src),
jerry_value_t func_val = jerry_parse_function (func_resource,
sizeof (func_resource) - 1,
func_arg_list,
sizeof (func_arg_list) - 1,
func_src,
sizeof (func_src) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (func_val));
@@ -1101,11 +1094,11 @@ main (void)
{
jerry_init (JERRY_INIT_SHOW_OPCODES);
const char *parser_err_src_p = "b = 'hello';\nvar a = (;";
const jerry_char_t parser_err_src[] = "b = 'hello';\nvar a = (;";
parsed_code_val = jerry_parse (NULL,
0,
(jerry_char_t *) parser_err_src_p,
strlen (parser_err_src_p),
parser_err_src,
sizeof (parser_err_src) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (jerry_value_is_error (parsed_code_val));
parsed_code_val = jerry_get_value_from_error (parsed_code_val, true);
@@ -1131,11 +1124,11 @@ main (void)
num_magic_string_items,
magic_string_lengths);
const char *ms_code_src_p = "var global = {}; var console = [1]; var process = 1;";
const jerry_char_t ms_code_src[] = "var global = {}; var console = [1]; var process = 1;";
parsed_code_val = jerry_parse (NULL,
0,
(jerry_char_t *) ms_code_src_p,
strlen (ms_code_src_p),
ms_code_src,
sizeof (ms_code_src) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
@@ -1160,9 +1153,9 @@ main (void)
jerry_release_value (args[0]);
const char *test_magic_str_access_src_p = "'console'.charAt(6) == 'e'";
res = jerry_eval ((const jerry_char_t *) test_magic_str_access_src_p,
strlen (test_magic_str_access_src_p),
const jerry_char_t test_magic_str_access_src[] = "'console'.charAt(6) == 'e'";
res = jerry_eval (test_magic_str_access_src,
sizeof (test_magic_str_access_src) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (jerry_value_is_boolean (res));
TEST_ASSERT (jerry_get_boolean_value (res) == true);
@@ -1183,22 +1176,20 @@ main (void)
{
/*json parser check*/
char data_check[]="John";
const char data_check[]="John";
jerry_value_t key = jerry_create_string ((const jerry_char_t *) "name");
const char *data = "{\"name\": \"John\", \"age\": 5}";
jerry_size_t str_length = (jerry_size_t) strlen (data);
jerry_value_t parsed_json = jerry_json_parse ((jerry_char_t *) data, str_length);
const jerry_char_t data[] = "{\"name\": \"John\", \"age\": 5}";
jerry_value_t parsed_json = jerry_json_parse (data, sizeof (data) - 1);
jerry_value_t has_prop_js = jerry_has_property (parsed_json, key);
TEST_ASSERT (jerry_get_boolean_value (has_prop_js));
jerry_release_value (has_prop_js);
jerry_value_t parsed_data = jerry_get_property (parsed_json, key);
TEST_ASSERT (jerry_value_is_string (parsed_data)== true);
jerry_size_t buff_size = (jerry_size_t) jerry_get_string_length (parsed_data);
char buff[jerry_get_string_length (parsed_data)];
jerry_char_t *buff_p = (jerry_char_t *) buff;
jerry_string_to_char_buffer (parsed_data, buff_p, buff_size);
jerry_size_t buff_size = (jerry_size_t) jerry_get_string_length (parsed_data);
jerry_string_to_char_buffer (parsed_data, (jerry_char_t *) buff, buff_size);
buff[buff_size] = '\0';
TEST_ASSERT (strcmp ((const char *) data_check, (const char *) buff) == false);
TEST_ASSERT (strcmp (data_check, buff) == false);
jerry_release_value (parsed_json);
jerry_release_value (key);
jerry_release_value (parsed_data);
tests/unit-core/test-arraybuffer.c
+38 -33
View File
@@ -74,11 +74,13 @@ assert_handler (const jerry_value_t func_obj_val, /**< function object */
static void
test_read_with_offset (uint8_t offset) /**< offset for buffer read. */
{
const char *eval_arraybuffer_src_p = ("var array = new Uint8Array (15);"
"for (var i = 0; i < array.length; i++) { array[i] = i * 2; };"
"array.buffer");
jerry_value_t arraybuffer = jerry_eval ((jerry_char_t *) eval_arraybuffer_src_p,
strlen (eval_arraybuffer_src_p),
const jerry_char_t eval_arraybuffer_src[] = TEST_STRING_LITERAL (
"var array = new Uint8Array (15);"
"for (var i = 0; i < array.length; i++) { array[i] = i * 2; };"
"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));
@@ -112,9 +114,9 @@ static void test_write_with_offset (uint8_t offset) /**< offset for buffer write
jerry_release_value (offset_val);
}
const char *eval_arraybuffer_src_p = "var array = new Uint8Array (15); array.buffer";
jerry_value_t arraybuffer = jerry_eval ((jerry_char_t *) eval_arraybuffer_src_p,
strlen (eval_arraybuffer_src_p),
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));
@@ -132,19 +134,20 @@ static void test_write_with_offset (uint8_t offset) /**< offset for buffer write
jerry_length_t copied = jerry_arraybuffer_write (arraybuffer, offset, buffer, 20);
TEST_ASSERT (copied == (jerry_length_t)(15 - offset));
const char *eval_test_arraybuffer_p = (
"for (var i = 0; i < offset; i++)"
"{"
" assert (array[i] == 0, 'offset check for: ' + i + ' was: ' + array[i] + ' should be: 0');"
"};"
"for (var i = offset; i < array.length; i++)"
"{"
" var expected = (i - offset) * 3;"
" assert (array[i] == expected, 'calc check for: ' + i + ' was: ' + array[i] + ' should be: ' + expected);"
"};"
"assert (array[15] === undefined, 'ArrayBuffer out of bounds index should return undefined value');");
jerry_value_t res = jerry_eval ((jerry_char_t *) eval_test_arraybuffer_p,
strlen (eval_test_arraybuffer_p),
const jerry_char_t eval_test_arraybuffer[] = TEST_STRING_LITERAL (
"for (var i = 0; i < offset; i++)"
"{"
" assert (array[i] == 0, 'offset check for: ' + i + ' was: ' + array[i] + ' should be: 0');"
"};"
"for (var i = offset; i < array.length; i++)"
"{"
" var expected = (i - offset) * 3;"
" assert (array[i] == expected, 'calc check for: ' + i + ' was: ' + array[i] + ' should be: ' + expected);"
"};"
"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);
@@ -176,9 +179,9 @@ main (void)
/* Test array buffer queries */
{
const char *eval_arraybuffer_src_p = "new ArrayBuffer (10)";
jerry_value_t eval_arraybuffer = jerry_eval ((jerry_char_t *) eval_arraybuffer_src_p,
strlen (eval_arraybuffer_src_p),
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_arraybuffer (eval_arraybuffer));
@@ -291,16 +294,17 @@ main (void)
jerry_release_value (input_buffer);
}
const char *eval_arraybuffer_src_p = (
const jerry_char_t eval_arraybuffer_src[] = TEST_STRING_LITERAL (
"var array = new Uint8Array(input_buffer);"
"for (var i = 0; i < array.length; i++)"
"{"
" array[i] = i * 2;"
"};"
"array.buffer");
jerry_value_t buffer = jerry_eval ((jerry_char_t *) eval_arraybuffer_src_p,
strlen (eval_arraybuffer_src_p),
JERRY_PARSE_STRICT_MODE);
"array.buffer"
);
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_arraybuffer (buffer));
@@ -324,7 +328,7 @@ main (void)
jerry_release_value (buffer);
const char *eval_test_arraybuffer_p = (
const jerry_char_t eval_test_arraybuffer[] = TEST_STRING_LITERAL (
"var sum = 0;"
"for (var i = 0; i < array.length; i++)"
"{"
@@ -332,9 +336,10 @@ main (void)
" assert(array[i] == expected, 'Array at index ' + i + ' was: ' + array[i] + ' should be: ' + expected);"
" sum += array[i]"
"};"
"sum");
jerry_value_t res = jerry_eval ((jerry_char_t *) eval_test_arraybuffer_p,
strlen (eval_test_arraybuffer_p),
"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);
tests/unit-core/test-common.h
+8
View File
@@ -50,4 +50,12 @@ do \
srand ((unsigned) jerry_port_get_current_time ()); \
} while (0)
/**
* Dummy macro to enable the breaking of long string literals into multiple
* substrings on separate lines. (Style checker doesn't allow it without putting
* the whole literal into parentheses but the compiler warns about parenthesized
* string constants.)
*/
#define TEST_STRING_LITERAL(x) x
#endif /* !TEST_COMMON_H */
tests/unit-core/test-exec-stop.c
+9 -7
View File
@@ -49,11 +49,11 @@ main (void)
int countdown = 6;
jerry_set_vm_exec_stop_callback (vm_exec_stop_callback, &countdown, 16);
const char *inf_loop_code_src_p = "while(true) {}";
const jerry_char_t inf_loop_code_src1[] = "while(true) {}";
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
(jerry_char_t *) inf_loop_code_src_p,
strlen (inf_loop_code_src_p),
inf_loop_code_src1,
sizeof (inf_loop_code_src1) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
@@ -71,13 +71,15 @@ main (void)
/* We keep the callback function, only the countdown is reset. */
countdown = 6;
inf_loop_code_src_p = ("function f() { while (true) ; }\n"
"try { f(); } catch(e) {}");
const jerry_char_t inf_loop_code_src2[] = TEST_STRING_LITERAL (
"function f() { while (true) ; }\n"
"try { f(); } catch(e) {}"
);
parsed_code_val = jerry_parse (NULL,
0,
(jerry_char_t *) inf_loop_code_src_p,
strlen (inf_loop_code_src_p),
inf_loop_code_src2,
sizeof (inf_loop_code_src2) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
tests/unit-core/test-mem-stats.c
+7 -7
View File
@@ -23,17 +23,17 @@ int main (void)
{
return 0;
}
const char *test_source = (
"var a = 'hello';"
"var b = 'world';"
"var c = a + ' ' + b;"
);
const jerry_char_t test_source[] = TEST_STRING_LITERAL (
"var a = 'hello';"
"var b = 'world';"
"var c = a + ' ' + b;"
);
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
(jerry_char_t *) test_source,
strlen (test_source),
test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
tests/unit-core/test-objects-foreach.c
+3 -3
View File
@@ -28,7 +28,7 @@ static const jerry_object_native_info_t test_info =
.free_cb = free_test_data
};
static const char *strict_equal_source = "var x = function(a, b) {return a === b;}; x";
static const jerry_char_t strict_equal_source[] = "var x = function(a, b) {return a === b;}; x";
static bool
find_test_object_by_data (const jerry_value_t candidate,
@@ -72,8 +72,8 @@ main (void)
/* Render strict-equal as a function. */
jerry_value_t parse_result = jerry_parse (NULL,
0,
(jerry_char_t *) strict_equal_source,
strlen (strict_equal_source),
strict_equal_source,
sizeof (strict_equal_source) - 1,
JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (!jerry_value_is_error (parse_result));
jerry_value_t strict_equal = jerry_run (parse_result);
tests/unit-core/test-promise.c
+14 -14
View File
@@ -19,22 +19,22 @@
#include "test-common.h"
const char *test_source = (
"var p1 = create_promise1();"
"var p2 = create_promise2();"
"p1.then(function(x) { "
" assert(x==='resolved'); "
"}); "
"p2.catch(function(x) { "
" assert(x==='rejected'); "
"}); "
);
static const jerry_char_t test_source[] = TEST_STRING_LITERAL (
"var p1 = create_promise1();"
"var p2 = create_promise2();"
"p1.then(function(x) { "
" assert(x==='resolved'); "
"}); "
"p2.catch(function(x) { "
" assert(x==='rejected'); "
"}); "
);
static int count_in_assert = 0;
static jerry_value_t my_promise1;
static jerry_value_t my_promise2;
const jerry_char_t s1[] = "resolved";
const jerry_char_t s2[] = "rejected";
static const jerry_char_t s1[] = "resolved";
static const jerry_char_t s2[] = "rejected";
static jerry_value_t
create_promise1_handler (const jerry_value_t func_obj_val, /**< function object */
@@ -131,8 +131,8 @@ main (void)
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
(jerry_char_t *) test_source,
strlen (test_source),
test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
tests/unit-core/test-snapshot.c
+38 -34
View File
@@ -63,17 +63,17 @@ static void test_function_snapshot (void)
const jerry_init_flag_t flags = JERRY_INIT_EMPTY;
static uint32_t function_snapshot_buffer[SNAPSHOT_BUFFER_SIZE];
const char *args_p = "a, b";
const char *code_to_snapshot_p = "return a + b";
const jerry_char_t func_args[] = "a, b";
const jerry_char_t code_to_snapshot[] = "return a + b";
jerry_init (flags);
jerry_value_t generate_result;
generate_result = jerry_generate_function_snapshot (NULL,
0,
(const jerry_char_t *) code_to_snapshot_p,
strlen (code_to_snapshot_p),
(jerry_char_t *) args_p,
strlen (args_p),
code_to_snapshot,
sizeof (code_to_snapshot) - 1,
func_args,
sizeof (func_args) - 1,
0,
function_snapshot_buffer,
SNAPSHOT_BUFFER_SIZE);
@@ -135,20 +135,22 @@ static void test_function_arguments_snapshot (void)
{
static uint32_t arguments_snapshot_buffer[SNAPSHOT_BUFFER_SIZE];
const char *code_to_snapshot_p = ("function f(a,b,c) {"
" arguments[0]++;"
" arguments[1]++;"
" arguments[2]++;"
" return a + b + c;"
"}"
"f(3,4,5);");
const jerry_char_t code_to_snapshot[] = TEST_STRING_LITERAL (
"function f(a,b,c) {"
" arguments[0]++;"
" arguments[1]++;"
" arguments[2]++;"
" return a + b + c;"
"}"
"f(3,4,5);"
);
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
(jerry_char_t *) code_to_snapshot_p,
strlen (code_to_snapshot_p),
code_to_snapshot,
sizeof (code_to_snapshot) - 1,
0,
arguments_snapshot_buffer,
SNAPSHOT_BUFFER_SIZE);
@@ -201,14 +203,14 @@ main (void)
if (jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE)
&& jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
{
const char *code_to_snapshot_p = "(function () { return 'string from snapshot'; }) ();";
const jerry_char_t code_to_snapshot[] = "(function () { return 'string from snapshot'; }) ();";
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
(const jerry_char_t *) code_to_snapshot_p,
strlen (code_to_snapshot_p),
code_to_snapshot,
sizeof (code_to_snapshot) - 1,
0,
snapshot_buffer,
SNAPSHOT_BUFFER_SIZE);
@@ -247,11 +249,13 @@ main (void)
if (jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_SAVE)
&& jerry_is_feature_enabled (JERRY_FEATURE_SNAPSHOT_EXEC))
{
const char *code_to_snapshot_p = ("function func(a, b, c) {"
" c = 'snapshot';"
" return arguments[0] + ' ' + b + ' ' + arguments[2];"
"};"
"func('string', 'from');");
const jerry_char_t code_to_snapshot[] = TEST_STRING_LITERAL (
"function func(a, b, c) {"
" c = 'snapshot';"
" return arguments[0] + ' ' + b + ' ' + arguments[2];"
"};"
"func('string', 'from');"
);
jerry_init (JERRY_INIT_EMPTY);
jerry_register_magic_strings (magic_strings,
@@ -261,8 +265,8 @@ main (void)
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
(jerry_char_t *) code_to_snapshot_p,
strlen (code_to_snapshot_p),
code_to_snapshot,
sizeof (code_to_snapshot) - 1,
JERRY_SNAPSHOT_SAVE_STATIC,
snapshot_buffer,
SNAPSHOT_BUFFER_SIZE);
@@ -291,14 +295,14 @@ main (void)
size_t snapshot_sizes[2];
static uint32_t merged_snapshot_buffer[SNAPSHOT_BUFFER_SIZE];
const char *code_to_snapshot_p = "var a = 'hello'; 123";
const jerry_char_t code_to_snapshot1[] = "var a = 'hello'; 123";
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
(const jerry_char_t *) code_to_snapshot_p,
strlen (code_to_snapshot_p),
code_to_snapshot1,
sizeof (code_to_snapshot1) - 1,
0,
snapshot_buffer_0,
SNAPSHOT_BUFFER_SIZE);
@@ -310,13 +314,13 @@ main (void)
jerry_cleanup ();
code_to_snapshot_p = "var b = 'hello'; 456";
const jerry_char_t code_to_snapshot2[] = "var b = 'hello'; 456";
jerry_init (JERRY_INIT_EMPTY);
generate_result = jerry_generate_snapshot (NULL,
0,
(const jerry_char_t *) code_to_snapshot_p,
strlen (code_to_snapshot_p),
code_to_snapshot2,
sizeof (code_to_snapshot2) - 1,
0,
snapshot_buffer_1,
SNAPSHOT_BUFFER_SIZE);
@@ -377,13 +381,13 @@ main (void)
static jerry_char_t literal_buffer_c[LITERAL_BUFFER_SIZE];
static uint32_t literal_snapshot_buffer[SNAPSHOT_BUFFER_SIZE];
static const char *code_for_c_format_p = "var object = { aa:'fo o', Bb:'max', aaa:'xzy0' };";
static const jerry_char_t code_for_c_format[] = "var object = { aa:'fo o', Bb:'max', aaa:'xzy0' };";
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
(const jerry_char_t *) code_for_c_format_p,
strlen (code_for_c_format_p),
code_for_c_format,
sizeof (code_for_c_format) - 1,
0,
literal_snapshot_buffer,
SNAPSHOT_BUFFER_SIZE);
tests/unit-core/test-typedarray.c
+10 -8
View File
@@ -246,13 +246,14 @@ test_typedarray_complex_creation (test_entry_t test_entries[], /**< test cases *
register_js_value ("array", typedarray);
const char *eval_src_p = (
const jerry_char_t eval_src[] = TEST_STRING_LITERAL (
"assert (array.length == expected_length,"
" 'expected length: ' + expected_length + ' got: ' + array.length);"
"assert (array.byteOffset == expected_offset);"
"array[0] = 0x11223344;");
jerry_value_t result = jerry_eval ((jerry_char_t *) eval_src_p,
strlen (eval_src_p),
"array[0] = 0x11223344;"
);
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);
@@ -470,15 +471,16 @@ main (void)
}
/* Check read and to write */
const char *eval_src_p = (
const jerry_char_t eval_src[] = TEST_STRING_LITERAL (
"assert (array.length == expected_length, 'expected length: ' + expected_length + ' got: ' + array.length);"
"for (var i = 0; i < array.length; i++)"
"{"
" assert (array[i] == expected_value);"
" array[i] = i;"
"};");
jerry_value_t result = jerry_eval ((jerry_char_t *) eval_src_p,
strlen (eval_src_p),
"};"
);
jerry_value_t result = jerry_eval (eval_src,
sizeof (eval_src) - 1,
JERRY_PARSE_STRICT_MODE);
TEST_ASSERT (!jerry_value_is_error (result));
tests/unit-ext/test-common.h
+2
View File
@@ -35,4 +35,6 @@
} \
} while (0)
#define TEST_STRING_LITERAL(x) x
#endif /* !TEST_COMMON_H */
tests/unit-ext/test-ext-arg.c
+40 -42
View File
@@ -17,49 +17,47 @@
* Unit test for jerry-ext/args.
*/
#include <string.h>
#include "jerryscript.h"
#include "jerryscript-ext/arg.h"
#include "test-common.h"
#include <string.h>
#include <jerryscript-ext/arg.h>
const char *test_source = (
"var arg1 = true;"
"var arg2 = 10.5;"
"var arg3 = 'abc';"
"var arg4 = function foo() {};"
"test_validator1(arg1, arg2, arg3, arg4);"
"arg1 = new Boolean(true);"
"arg3 = new String('abc');"
"test_validator1(arg1, arg2, arg3);"
"test_validator1(arg1, arg2, '');"
"arg2 = new Number(10.5);"
"test_validator1(arg1, arg2, arg3);"
"test_validator1(arg1, 10.5, 'abcdef');"
"var obj_a = new MyObjectA();"
"var obj_b = new MyObjectB();"
"test_validator2.call(obj_a, 5);"
"test_validator2.call(obj_b, 5);"
"test_validator2.call(obj_a, 1);"
"var obj1 = {prop1:true, prop2:'1.5'};"
"test_validator_prop1(obj1);"
"test_validator_prop2(obj1);"
"test_validator_prop2();"
"var obj2 = {prop1:true};"
"Object.defineProperty(obj2, 'prop2', {"
" get: function() { throw new TypeError('prop2 error') }"
"});"
"test_validator_prop3(obj2);"
"test_validator_int1(-1000, 1000, 128, -1000, 1000, -127,"
" -1000, 4294967297, 65536, -2200000000, 4294967297, -2147483647);"
"test_validator_int2(-1.5, -1.5, -1.5, 1.5, 1.5, 1.5, Infinity, -Infinity, 300.5, 300.5);"
"test_validator_int3(NaN);"
"var arr = [1, 2];"
"test_validator_array1(arr);"
"test_validator_array1();"
"test_validator_array2(arr);"
);
static const jerry_char_t test_source[] = TEST_STRING_LITERAL (
"var arg1 = true;"
"var arg2 = 10.5;"
"var arg3 = 'abc';"
"var arg4 = function foo() {};"
"test_validator1(arg1, arg2, arg3, arg4);"
"arg1 = new Boolean(true);"
"arg3 = new String('abc');"
"test_validator1(arg1, arg2, arg3);"
"test_validator1(arg1, arg2, '');"
"arg2 = new Number(10.5);"
"test_validator1(arg1, arg2, arg3);"
"test_validator1(arg1, 10.5, 'abcdef');"
"var obj_a = new MyObjectA();"
"var obj_b = new MyObjectB();"
"test_validator2.call(obj_a, 5);"
"test_validator2.call(obj_b, 5);"
"test_validator2.call(obj_a, 1);"
"var obj1 = {prop1:true, prop2:'1.5'};"
"test_validator_prop1(obj1);"
"test_validator_prop2(obj1);"
"test_validator_prop2();"
"var obj2 = {prop1:true};"
"Object.defineProperty(obj2, 'prop2', {"
" get: function() { throw new TypeError('prop2 error') }"
"});"
"test_validator_prop3(obj2);"
"test_validator_int1(-1000, 1000, 128, -1000, 1000, -127,"
" -1000, 4294967297, 65536, -2200000000, 4294967297, -2147483647);"
"test_validator_int2(-1.5, -1.5, -1.5, 1.5, 1.5, 1.5, Infinity, -Infinity, 300.5, 300.5);"
"test_validator_int3(NaN);"
"var arr = [1, 2];"
"test_validator_array1(arr);"
"test_validator_array1();"
"test_validator_array2(arr);"
);
static const jerry_object_native_info_t thing_a_info =
{
@@ -569,7 +567,7 @@ 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");
char expect_utf8_buf[] = "\x73\x74\x72\x3a \xf0\x90\x90\x80";
size_t buf_len = strlen (expect_utf8_buf);
size_t buf_len = sizeof (expect_utf8_buf) - 1;
char buf[buf_len+1];
jerryx_arg_t mapping[] =
@@ -662,8 +660,8 @@ main (void)
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
(jerry_char_t *) test_source,
strlen (test_source),
test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));