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
docs/02.API-REFERENCE.md
+41 -58
View File
@@ -783,15 +783,14 @@ jerry_run_simple (const jerry_char_t *script_source_p,
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
int
main (void)
{
const jerry_char_t *script = (const jerry_char_t *) "print ('Hello, World!');";
const jerry_char_t script[] = "print ('Hello, World!');";
jerry_run_simple (script, strlen ((const char *) script), JERRY_INIT_EMPTY);
jerry_run_simple (script, sizeof (script) - 1, JERRY_INIT_EMPTY);
}
```
@@ -839,7 +838,6 @@ jerry_parse (const jerry_char_t *resource_name_p, /**< resource name (usually a
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
int
@@ -848,9 +846,8 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
const jerry_char_t script[] = "print ('Hello, World!');";
size_t script_size = strlen ((const char *) script);
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
jerry_release_value (parsed_code);
jerry_cleanup ();
@@ -924,20 +921,18 @@ jerry_run (const jerry_value_t func_val);
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
int
main (void)
{
const jerry_char_t script[] = "print ('Hello, World!');";
size_t script_size = strlen ((const char *) script);
/* Initialize engine */
jerry_init (JERRY_INIT_EMPTY);
/* Setup Global scope code */
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
if (!jerry_value_is_error (parsed_code))
{
@@ -1016,7 +1011,6 @@ jerry_run_all_enqueued_jobs (void)
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
int
@@ -1025,9 +1019,8 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
const jerry_char_t script[] = "new Promise(function(f,r) { f('Hello, World!'); }).then(function(x) { print(x); });";
size_t script_size = strlen ((const char *) script);
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
jerry_value_t script_value = jerry_run (parsed_code);
jerry_value_t job_value = jerry_run_all_enqueued_jobs ();
@@ -2989,10 +2982,10 @@ jerry_create_error_sz (jerry_error_t error_type,
```c
{
const jerry_char_t *message = "error";
const jerry_char_t message[] = "error";
jerry_value_t error_obj = jerry_create_error_sz (JERRY_ERROR_COMMON,
message,
strlen ((const char *) message));
sizeof (message) - 1);
... // usage of error_obj
@@ -3320,7 +3313,7 @@ jerry_create_string_sz (const jerry_char_t *str_p,
{
const jerry_char_t char_array[] = "a string";
jerry_value_t string_value = jerry_create_string_sz (char_array,
strlen ((const char *) char_array));
sizeof (char_array) - 1);
... // usage of string_value
@@ -3398,7 +3391,7 @@ jerry_create_string_sz (const jerry_char_t *str_p,
{
const jerry_char_t char_array[] = "a string";
jerry_value_t string_value = jerry_create_string_sz_from_utf8 (char_array,
strlen ((const char *) char_array));
sizeof (char_array) - 1);
... // usage of string_value
@@ -4792,16 +4785,15 @@ jerry_is_valid_utf8_string (const jerry_char_t *utf8_buf_p, /**< UTF-8 string */
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
int
main (void)
{
const jerry_char_t script[] = "print ('Hello, World!');";
size_t script_size = strlen ((const char *) script);
const jerry_size_t script_size = sizeof (script) - 1;
if (jerry_is_valid_utf8_string (script, (jerry_size_t) script_size))
if (jerry_is_valid_utf8_string (script, script_size))
{
jerry_run_simple (script, script_size, JERRY_INIT_EMPTY);
}
@@ -4840,7 +4832,6 @@ jerry_is_valid_cesu8_string (const jerry_char_t *cesu8_buf_p, /**< CESU-8 string
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
int
@@ -4849,12 +4840,12 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
const jerry_char_t script[] = "Hello, World!";
size_t script_size = strlen ((const char *) script);
const jerry_size_t script_size = sizeof (script) - 1;
if (jerry_is_valid_cesu8_string (script, (jerry_size_t) script_size))
if (jerry_is_valid_cesu8_string (script, script_size))
{
jerry_value_t string_value = jerry_create_string_sz (script,
(jerry_size_t) script_size);
script_size);
// usage of string_value
@@ -5059,7 +5050,6 @@ jerry_generate_snapshot (const jerry_char_t *resource_name_p,
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
int
@@ -5068,13 +5058,13 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
static uint32_t global_mode_snapshot_buffer[256];
const jerry_char_t *code_to_snapshot_p = (const jerry_char_t *) "(function () { return 'string from snapshot'; }) ();";
const jerry_char_t script_to_snapshot[] = "(function () { return 'string from snapshot'; }) ();";
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
code_to_snapshot_p,
strlen ((const char *) code_to_snapshot_p),
script_to_snapshot,
sizeof (script_to_snapshot) - 1,
0,
global_mode_snapshot_buffer,
sizeof (global_mode_snapshot_buffer) / sizeof (uint32_t));
@@ -5139,7 +5129,6 @@ jerry_generate_function_snapshot (const jerry_char_t *resource_name_p,
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
int
@@ -5148,16 +5137,16 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
static uint32_t func_snapshot_buffer[256];
const jerry_char_t *args_p = (const jerry_char_t *) "a, b";
const jerry_char_t *src_p = (const jerry_char_t *) "return a + b;";
const jerry_char_t args[] = "a, b";
const jerry_char_t src[] = "return a + b;";
jerry_value_t generate_result;
generate_result = jerry_generate_function_snapshot (NULL,
0,
src_p,
strlen ((const char *) src_p),
args_p,
strlen ((const char *) args_p),
src,
sizeof (src) - 1,
args,
sizeof (args) - 1,
0,
func_snapshot_buffer,
sizeof (func_snapshot_buffer) / sizeof (uint32_t));
@@ -5209,22 +5198,21 @@ jerry_exec_snapshot (const uint32_t *snapshot_p,
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
int
main (void)
{
static uint32_t global_mode_snapshot_buffer[256];
const jerry_char_t *code_to_snapshot_p = (const jerry_char_t *) "(function () { return 'string from snapshot'; }) ();";
const jerry_char_t script_to_snapshot[] = "(function () { return 'string from snapshot'; }) ();";
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
code_to_snapshot_p,
strlen ((const char *) code_to_snapshot_p),
script_to_snapshot,
sizeof (script_to_snapshot) - 1,
0,
global_mode_snapshot_buffer,
sizeof (global_mode_snapshot_buffer) / sizeof (uint32_t));
@@ -5287,25 +5275,24 @@ jerry_load_function_snapshot (const uint32_t *snapshot_p,
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
int
main (void)
{
static uint32_t snapshot_buffer[256];
const jerry_char_t *args_p = (const jerry_char_t *)"a, b";
const jerry_char_t *src_p = (const jerry_char_t *) "return a + b;";
const jerry_char_t func_args[] = "a, b";
const jerry_char_t func_src[] = "return a + b;";
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t generate_result;
generate_result = jerry_generate_function_snapshot (NULL,
0,
src_p,
strlen ((const char *) src_p),
args_p,
strlen ((const char *) args_p),
func_src,
sizeof (func_src) - 1,
func_args,
sizeof (func_args) - 1,
false,
snapshot_buffer,
sizeof (snapshot_buffer) / sizeof (uint32_t));
@@ -5383,7 +5370,6 @@ jerry_get_literals_from_snapshot (const uint32_t *snapshot_p,
```c
#include <stdio.h>
#include <string.h>
#include "jerryscript.h"
int
@@ -5393,13 +5379,12 @@ main (void)
static jerry_char_t literal_buffer[256];
static uint32_t snapshot_buffer[256];
const jerry_char_t *code_for_literal_save_p = (const jerry_char_t *) "var obj = { a:'aa', bb:'Bb' }";
size_t code_for_literal_save_size = strlen ((const char *) code_for_literal_save_p);
const jerry_char_t script_for_literal_save[] = "var obj = { a:'aa', bb:'Bb' }";
jerry_value_t generate_result = jerry_generate_snapshot (NULL,
0,
code_for_literal_save_p,
code_for_literal_save_size,
script_for_literal_save,
sizeof (script_for_literal_save) - 1,
0,
snapshot_buffer,
256);
@@ -5471,7 +5456,6 @@ jerry_set_vm_exec_stop_callback (jerry_vm_exec_stop_callback_t stop_cb,
[doctest]: # (test="link")
```c
#include <string.h>
#include "jerryscript.h"
static int countdown = 10;
@@ -5497,11 +5481,11 @@ main (void)
jerry_set_vm_exec_stop_callback (vm_exec_stop_callback, &countdown, 16);
// Inifinte loop.
const char *src_p = "while(true) {}";
const jerry_char_t script[] = "while(true) {}";
jerry_value_t src = jerry_parse (NULL, 0, (jerry_char_t *) src_p, strlen (src_p), JERRY_PARSE_NO_OPTS);
jerry_release_value (jerry_run (src));
jerry_release_value (src);
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
jerry_release_value (jerry_run (parsed_code));
jerry_release_value (parsed_code);
jerry_cleanup ();
}
```
@@ -5920,9 +5904,8 @@ jerry_value_t jerry_json_parse (const jerry_char_t *string_p, jerry_size_t strin
```c
{
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);
// parsed_json now conatins all data stored in data_in_json
docs/03.API-EXAMPLE.md
+10 -23
View File
@@ -7,16 +7,14 @@ This guide is intended to introduce you to JerryScript embedding API through cre
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
int
main (void)
{
const jerry_char_t script[] = "var str = 'Hello, World!';";
size_t script_size = strlen ((const char *) script);
bool ret_value = jerry_run_simple (script, script_size, JERRY_INIT_EMPTY);
bool ret_value = jerry_run_simple (script, sizeof (script) - 1, JERRY_INIT_EMPTY);
return (ret_value ? 0 : 1);
}
@@ -37,7 +35,6 @@ Here we perform the same actions, as `jerry_run_simple`, while splitting into se
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
#include "jerryscript-ext/handler.h"
@@ -45,7 +42,6 @@ int
main (void)
{
const jerry_char_t script[] = "print ('Hello, World!');";
size_t script_size = strlen ((const char *) script);
/* Initialize engine */
jerry_init (JERRY_INIT_EMPTY);
@@ -55,7 +51,7 @@ main (void)
jerryx_handler_print);
/* Setup Global scope code */
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
if (!jerry_value_is_error (parsed_code))
{
@@ -83,7 +79,6 @@ Our code is more complex now, but it introduces possibilities to interact with J
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
#include "jerryscript-ext/handler.h"
@@ -104,7 +99,7 @@ main (void)
/* Evaluate script1 */
eval_ret = jerry_eval (script_1,
strlen ((const char *) script_1),
sizeof (script_1) - 1,
JERRY_PARSE_NO_OPTS);
/* Free JavaScript value, returned by eval */
@@ -112,7 +107,7 @@ main (void)
/* Evaluate script2 */
eval_ret = jerry_eval (script_2,
strlen ((const char *) script_2),
sizeof (script_2) - 1,
JERRY_PARSE_NO_OPTS);
/* Free JavaScript value, returned by eval */
@@ -132,7 +127,6 @@ This way, we execute two independent script parts in one execution environment.
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
#include "jerryscript-ext/handler.h"
@@ -168,7 +162,7 @@ main (void)
/* Now starting script that would output value of just initialized field */
jerry_value_t eval_ret = jerry_eval (script,
strlen ((const char *) script),
sizeof (script) - 1,
JERRY_PARSE_NO_OPTS);
/* Free JavaScript value, returned by eval */
@@ -197,7 +191,6 @@ The following example function will output a JavaScript value:
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "jerryscript.h"
static void
@@ -312,7 +305,7 @@ main (void)
}
/* If the command is "quit", break the loop */
if (!strncmp (cmd, "quit\n", strlen ("quit\n")))
if (!strncmp (cmd, "quit\n", sizeof ("quit\n") - 1))
{
break;
}
@@ -352,7 +345,6 @@ In this example we demonstrate how to use native function and structures in Java
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
#include "jerryscript-ext/handler.h"
@@ -417,10 +409,9 @@ main (void)
var str = MyObject.myFunc (); \
print (str); \
";
size_t script_size = strlen ((const char *) script);
/* Evaluate script */
jerry_value_t eval_ret = jerry_eval (script, script_size, JERRY_PARSE_NO_OPTS);
jerry_value_t eval_ret = jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
@@ -445,7 +436,6 @@ Here we create a JS Object with `jerry_eval`, then extend it with a native funct
[doctest]: # ()
```c
#include <string.h>
#include "jerryscript.h"
#include "jerryscript-ext/handler.h"
@@ -508,7 +498,7 @@ main (void)
/* Evaluate script */
my_js_obj_val = jerry_eval (my_js_object,
strlen ((const char *) my_js_object),
sizeof (my_js_object) - 1,
JERRY_PARSE_NO_OPTS);
/* Create a JS function object and wrap into a jerry value */
@@ -529,10 +519,9 @@ main (void)
MyObject.add2x (5); \
print (MyObject.foo ()); \
";
size_t script_size = strlen ((const char *) script);
/* Evaluate script */
jerry_value_t eval_ret = jerry_eval (script, script_size, JERRY_PARSE_NO_OPTS);
jerry_value_t eval_ret = jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
@@ -559,7 +548,6 @@ A recommended method is using `jerry_port_get_current_time()` or something based
[doctest]: # ()
```c
#include <string.h>
#include <stdlib.h>
#include "jerryscript.h"
#include "jerryscript-port.h"
@@ -573,7 +561,6 @@ main (void)
/* Generate a random number, and print it */
const jerry_char_t script[] = "var a = Math.random (); print(a)";
size_t script_size = strlen ((const char *) script);
/* Initialize the engine */
jerry_init (JERRY_INIT_EMPTY);
@@ -583,7 +570,7 @@ main (void)
jerryx_handler_print);
/* Evaluate the script */
jerry_value_t eval_ret = jerry_eval (script, script_size, JERRY_PARSE_NO_OPTS);
jerry_value_t eval_ret = jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
/* Free the JavaScript value returned by eval */
jerry_release_value (eval_ret);
docs/07.DEBUGGER.md
+1 -3
View File
@@ -251,7 +251,6 @@ jerry_debugger_stop_at_breakpoint (bool enable_stop_at_breakpoint)
[doctest]: # (test="link")
```c
#include <string.h>
#include "jerryscript.h"
#include "jerryscript-ext/debugger.h"
@@ -266,8 +265,7 @@ main (void)
// Protected execution of JavaScript code.
const jerry_char_t script[] = "42";
size_t script_size = strlen ((const char *) script);
jerry_eval (script, script_size, JERRY_PARSE_NO_OPTS);
jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
jerry_debugger_stop_at_breakpoint (false);
jerry-core/api/jerry-snapshot.c
+2 -3
View File
@@ -291,10 +291,9 @@ static void
static_snapshot_error_unsupported_literal (snapshot_globals_t *globals_p, /**< snapshot globals */
ecma_value_t literal) /**< literal form the literal pool */
{
const char * const error_prefix_p = "Unsupported static snapshot literal: ";
const lit_utf8_byte_t error_prefix[] = "Unsupported static snapshot literal: ";
ecma_string_t *error_message_p = ecma_new_ecma_string_from_utf8 ((const lit_utf8_byte_t *) error_prefix_p,
(lit_utf8_size_t) strlen (error_prefix_p));
ecma_string_t *error_message_p = ecma_new_ecma_string_from_utf8 (error_prefix, sizeof (error_prefix) - 1);
literal = ecma_op_to_string (literal);
JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (literal));
jerry-core/vm/vm-utils.c
+2 -3
View File
@@ -84,9 +84,8 @@ vm_get_backtrace (uint32_t max_depth) /**< maximum backtrace depth, 0 = unlimite
if (ecma_string_is_empty (str_p))
{
const char * const unknown_str_p = "<unknown>:";
str_p = ecma_new_ecma_string_from_utf8 ((const lit_utf8_byte_t *) unknown_str_p,
(lit_utf8_size_t) strlen (unknown_str_p));
const lit_utf8_byte_t unknown_str[] = "<unknown>:";
str_p = ecma_new_ecma_string_from_utf8 (unknown_str, sizeof (unknown_str) - 1);
}
else
{
jerry-ext/debugger/debugger-ws.c
+11 -10
View File
@@ -189,11 +189,11 @@ jerryx_process_handshake (uint8_t *request_buffer_p) /**< temporary buffer */
}
/* Check protocol. */
const char *text_p = "GET /jerry-debugger";
size_t text_len = strlen (text_p);
const char get_text[] = "GET /jerry-debugger";
size_t text_len = sizeof (get_text) - 1;
if ((size_t) (request_end_p - request_buffer_p) < text_len
|| memcmp (request_buffer_p, text_p, text_len) != 0)
|| memcmp (request_buffer_p, get_text, text_len) != 0)
{
JERRYX_ERROR_MSG ("Invalid handshake format.\n");
return false;
@@ -201,8 +201,8 @@ jerryx_process_handshake (uint8_t *request_buffer_p) /**< temporary buffer */
uint8_t *websocket_key_p = request_buffer_p + text_len;
text_p = "Sec-WebSocket-Key:";
text_len = strlen (text_p);
const char key_text[] = "Sec-WebSocket-Key:";
text_len = sizeof (key_text) - 1;
while (true)
{
@@ -215,7 +215,7 @@ jerryx_process_handshake (uint8_t *request_buffer_p) /**< temporary buffer */
if (websocket_key_p[0] == 'S'
&& websocket_key_p[-1] == '\n'
&& websocket_key_p[-2] == '\r'
&& memcmp (websocket_key_p, text_p, text_len) == 0)
&& memcmp (websocket_key_p, key_text, text_len) == 0)
{
websocket_key_p += text_len;
break;
@@ -257,16 +257,17 @@ jerryx_process_handshake (uint8_t *request_buffer_p) /**< temporary buffer */
/* Last value must be replaced by equal sign. */
text_p = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ";
const uint8_t response_prefix[] =
"HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ";
if (!jerry_debugger_transport_send ((const uint8_t *) text_p, strlen (text_p))
if (!jerry_debugger_transport_send (response_prefix, sizeof (response_prefix) - 1)
|| !jerry_debugger_transport_send (request_buffer_p + sha1_length + 1, 27))
{
return false;
}
text_p = "=\r\n\r\n";
return jerry_debugger_transport_send ((const uint8_t *) text_p, strlen (text_p));
const uint8_t response_suffix[] = "=\r\n\r\n";
return jerry_debugger_transport_send (response_suffix, sizeof (response_suffix) - 1);
} /* jerryx_process_handshake */
/**
targets/nuttx-stm32f4/jerry_main.c
+1 -2
View File
@@ -395,9 +395,8 @@ int jerry_main (int argc, char *argv[])
{
printf ("No input files, running a hello world demo:\n");
const jerry_char_t script[] = "var str = 'Hello World'; print(str + ' from JerryScript')";
size_t script_size = strlen ((const char *) script);
ret_value = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
ret_value = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
if (!jerry_value_is_error (ret_value))
{
targets/particle/source/main.cpp
+1 -3
View File
@@ -114,9 +114,7 @@ test_jerry ()
test.delay(250); \
";
size_t script_size = strlen ((const char *) script);
jerry_value_t eval_ret = jerry_eval (script, script_size, JERRY_PARSE_NO_OPTS);
jerry_value_t eval_ret = jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
targets/riot-stm32f4/source/main-riotos.c
+1 -2
View File
@@ -56,7 +56,6 @@ int test_jerry (int argc, char **argv)
jerry_value_t ret_value = jerry_create_undefined ();
const jerry_char_t script[] = "print ('Hello, World!');";
size_t script_size = strlen ((const char *) script);
printf ("This test run the following script code: [%s]\n\n", script);
/* Initialize engine */
@@ -66,7 +65,7 @@ int test_jerry (int argc, char **argv)
register_js_function ("print", jerryx_handler_print);
/* Setup Global scope code */
ret_value = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
ret_value = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
if (!jerry_value_is_error (ret_value))
{
targets/tizenrt-artik053/apps/jerryscript/jerry_main.c
+1 -2
View File
@@ -371,9 +371,8 @@ jerry_cmd_main (int argc, char *argv[])
{
printf ("No input files, running a hello world demo:\n");
const jerry_char_t script[] = "var str = 'Hello World'; print(str + ' from JerryScript')";
size_t script_size = strlen ((const char *) script);
ret_value = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
ret_value = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
if (!jerry_value_is_error (ret_value))
{
tests/unit-core/test-abort.c
+12 -8
View File
@@ -52,7 +52,8 @@ main (void)
jerry_release_value (callback_name);
jerry_release_value (global);
const char *inf_loop_code_src_p = ("while(true) {\n"
const jerry_char_t inf_loop_code_src1[] = TEST_STRING_LITERAL (
"while(true) {\n"
" with ({}) {\n"
" try {\n"
" callback();\n"
@@ -60,12 +61,13 @@ main (void)
" } 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,7 +78,8 @@ main (void)
jerry_release_value (res);
jerry_release_value (parsed_code_val);
inf_loop_code_src_p = ("function f() {"
const jerry_char_t inf_loop_code_src2[] = TEST_STRING_LITERAL (
"function f() {"
" while(true) {\n"
" with ({}) {\n"
" try {\n"
@@ -93,12 +96,13 @@ main (void)
"}\n"
"\n"
"with({})\n"
" f();\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
+36 -45
View File
@@ -18,7 +18,7 @@
#include "test-common.h"
const char *test_source = (
const jerry_char_t test_source[] = TEST_STRING_LITERAL (
"function assert (arg) { "
" if (!arg) { "
" throw Error('Assert failed');"
@@ -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
+27 -22
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);"
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 ((jerry_char_t *) eval_arraybuffer_src_p,
strlen (eval_arraybuffer_src_p),
"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,7 +134,7 @@ 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 = (
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');"
@@ -142,9 +144,10 @@ static void test_write_with_offset (uint8_t offset) /**< offset for buffer write
" 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),
"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,15 +294,16 @@ 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),
"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));
@@ -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
+3 -3
View File
@@ -23,7 +23,7 @@ int main (void)
{
return 0;
}
const char *test_source = (
const jerry_char_t test_source[] = TEST_STRING_LITERAL (
"var a = 'hello';"
"var b = 'world';"
"var c = a + ' ' + b;"
@@ -32,8 +32,8 @@ int main (void)
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
+5 -5
View File
@@ -19,7 +19,7 @@
#include "test-common.h"
const char *test_source = (
static const jerry_char_t test_source[] = TEST_STRING_LITERAL (
"var p1 = create_promise1();"
"var p2 = create_promise2();"
"p1.then(function(x) { "
@@ -33,8 +33,8 @@ const char *test_source = (
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
+30 -26
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) {"
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);");
"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) {"
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');");
"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
+5 -7
View File
@@ -17,14 +17,12 @@
* 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 = (
static const jerry_char_t test_source[] = TEST_STRING_LITERAL (
"var arg1 = true;"
"var arg2 = 10.5;"
"var arg3 = 'abc';"
@@ -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));