iotjs_jval_t iotjs_jval_create_number(double v) {
iotjs_jval_t jval;
IOTJS_VALIDATED_STRUCT_CONSTRUCTOR(iotjs_jval_t, &jval);
_this->value = jerry_create_number(v);
return jval;
}
/**
* DigitalOut#is_connected (native JavaScript method)
*
* @returns 0 if the DigitalOut is set to NC, or 1 if it is connected to an
* actual pin
*/
DECLARE_CLASS_FUNCTION(DigitalOut, is_connected) {
CHECK_ARGUMENT_COUNT(DigitalOut, is_connected, (args_count == 0));
// Extract native DigitalOut pointer
uintptr_t ptr_val;
jerry_get_object_native_handle(this_obj, &ptr_val);
DigitalOut* native_ptr = reinterpret_cast<DigitalOut*>(ptr_val);
int result = native_ptr->is_connected();
return jerry_create_number(result);
}
static void AfterAsync(uv_fs_t* req) {
const jerry_value_t cb = *IOTJS_UV_REQUEST_JSCALLBACK(req);
IOTJS_ASSERT(jerry_value_is_function(cb));
jerry_value_t jargs[2] = { 0 };
size_t jargc = 0;
if (req->result < 0) {
jerry_value_t jerror = iotjs_create_uv_exception(req->result, "open");
jargs[jargc++] = jerror;
} else {
jargs[jargc++] = jerry_create_null();
switch (req->fs_type) {
case UV_FS_CLOSE: {
break;
}
case UV_FS_OPEN:
case UV_FS_READ:
case UV_FS_WRITE: {
jargs[jargc++] = jerry_create_number((double)req->result);
break;
}
case UV_FS_SCANDIR: {
int r;
uv_dirent_t ent;
uint32_t idx = 0;
jargs[jargc++] = jerry_create_array(0);
while ((r = uv_fs_scandir_next(req, &ent)) != UV_EOF) {
jerry_value_t name =
jerry_create_string((const jerry_char_t*)ent.name);
iotjs_jval_set_property_by_index(jargs[1], idx, name);
jerry_release_value(name);
idx++;
}
break;
}
case UV_FS_FSTAT:
case UV_FS_STAT: {
uv_stat_t s = (req->statbuf);
jargs[jargc++] = MakeStatObject(&s);
break;
}
default: { break; }
}
}
iotjs_invoke_callback(cb, jerry_create_undefined(), jargs, jargc);
jerry_release_value(jargs[0]);
jerry_release_value(jargs[1]);
uv_fs_req_cleanup(req);
iotjs_uv_request_destroy((uv_req_t*)req);
}
jerry_value_t init_$MODULE_NAME$(void) {
jerry_value_t object = jerry_create_object();
jerry_value_t prop_name = jerry_create_string((const jerry_char_t*)"demokey");
jerry_value_t prop_value = jerry_create_number(3.4);
jerry_set_property(object, prop_name, prop_value);
jerry_release_value(prop_name);
jerry_release_value(prop_value);
return object;
}
iotjs_jval_t iotjs_jval_create_byte_array(uint32_t len, const char* data) {
iotjs_jval_t jval;
IOTJS_VALIDATED_STRUCT_CONSTRUCTOR(iotjs_jval_t, &jval);
IOTJS_ASSERT(data != NULL);
_this->value = jerry_create_array(len);
for (uint32_t i = 0; i < len; i++) {
jerry_value_t val = jerry_create_number((double)data[i]);
jerry_set_property_by_index(_this->value, i, val);
jerry_release_value(val);
}
return jval;
}
static jerry_value_t AfterSync(uv_fs_t* req, int err,
const char* syscall_name) {
if (err < 0) {
jerry_value_t jvalue = iotjs_create_uv_exception(err, syscall_name);
jerry_value_t jerror = jerry_create_error_from_value(jvalue, true);
return jerror;
}
switch (req->fs_type) {
case UV_FS_CLOSE:
break;
case UV_FS_OPEN:
case UV_FS_READ:
case UV_FS_WRITE:
return jerry_create_number(err);
case UV_FS_FSTAT:
case UV_FS_STAT: {
uv_stat_t* s = &(req->statbuf);
return MakeStatObject(s);
}
case UV_FS_MKDIR:
case UV_FS_RMDIR:
case UV_FS_UNLINK:
case UV_FS_RENAME:
return jerry_create_undefined();
case UV_FS_SCANDIR: {
int r;
uv_dirent_t ent;
uint32_t idx = 0;
jerry_value_t ret = jerry_create_array(0);
while ((r = uv_fs_scandir_next(req, &ent)) != UV_EOF) {
jerry_value_t name = jerry_create_string((const jerry_char_t*)ent.name);
iotjs_jval_set_property_by_index(ret, idx, name);
jerry_release_value(name);
idx++;
}
return ret;
}
default: {
IOTJS_ASSERT(false);
break;
}
}
return jerry_create_undefined();
}
/**
* Test ArrayBuffer 'write' api call with various offset values.
*/
static void test_write_with_offset (uint8_t offset) /**< offset for buffer write. */
{
{
jerry_value_t offset_val = jerry_create_number (offset);
register_js_value ("offset", offset_val);
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),
true);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == 15);
uint8_t buffer[20];
for (uint8_t i = 0; i < 20; i++)
{
buffer[i] = (uint8_t) (i * 3);
}
/* Intentionally copy more than the allowed space. */
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),
true);
jerry_release_value (res);
jerry_release_value (arraybuffer);
} /* test_write_with_offset */
int
main (void)
{
jerry_init (JERRY_INIT_EMPTY);
/* Render strict-equal as a function. */
jerry_value_t parse_result = jerry_parse (NULL,
0,
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);
TEST_ASSERT (!jerry_value_is_error (strict_equal));
jerry_release_value (parse_result);
/* Create an object and associate some native data with it. */
jerry_value_t object = jerry_create_object ();
jerry_set_object_native_pointer (object, &test_data, &test_info);
/* Retrieve the object by its native pointer. */
jerry_value_t found_object;
TEST_ASSERT (jerry_objects_foreach_by_native_info (&test_info, find_test_object_by_data, &found_object));
jerry_value_t args[2] = {object, found_object};
/* Assert that the correct object was retrieved. */
jerry_value_t undefined = jerry_create_undefined ();
jerry_value_t strict_equal_result = jerry_call_function (strict_equal, undefined, args, 2);
TEST_ASSERT (jerry_value_is_boolean (strict_equal_result) && jerry_get_boolean_value (strict_equal_result));
jerry_release_value (strict_equal_result);
jerry_release_value (found_object);
jerry_release_value (object);
/* Collect garbage. */
jerry_gc (JERRY_GC_SEVERITY_LOW);
/* Attempt to retrieve the object by its native pointer again. */
TEST_ASSERT (!jerry_objects_foreach_by_native_info (&test_info, find_test_object_by_data, &found_object));
/* Create an object and set a property on it. */
object = jerry_create_object ();
jerry_value_t property_name = jerry_create_string ((jerry_char_t *) "xyzzy");
jerry_value_t property_value = jerry_create_number (42);
jerry_release_value (jerry_set_property (object, property_name, property_value));
jerry_release_value (property_value);
/* Retrieve the object by the presence of its property, placing it at args[1]. */
args[0] = property_name;
TEST_ASSERT (jerry_objects_foreach (find_test_object_by_property, args));
/* Assert that the right object was retrieved and release both the original reference to it and the retrieved one. */
args[0] = object;
strict_equal_result = jerry_call_function (strict_equal, undefined, args, 2);
TEST_ASSERT (jerry_value_is_boolean (strict_equal_result) && jerry_get_boolean_value (strict_equal_result));
jerry_release_value (strict_equal_result);
jerry_release_value (args[0]);
jerry_release_value (args[1]);
/* Collect garbage. */
jerry_gc (JERRY_GC_SEVERITY_LOW);
/* Attempt to retrieve the object by the presence of its property again. */
args[0] = property_name;
TEST_ASSERT (!jerry_objects_foreach (find_test_object_by_property, args));
jerry_release_value (property_name);
jerry_release_value (undefined);
jerry_release_value (strict_equal);
jerry_cleanup ();
} /* main */
int
main (void)
{
TEST_INIT ();
bool is_ok;
jerry_size_t sz;
jerry_value_t val_t, val_foo, val_bar, val_A, val_A_prototype, val_a, val_a_foo, val_value_field, val_p, val_np;
jerry_value_t val_call_external;
jerry_value_t global_obj_val, obj_val;
jerry_value_t external_func_val, external_construct_val;
jerry_value_t throw_test_handler_val;
jerry_value_t parsed_code_val, proto_val, prim_val;
jerry_value_t res, args[2];
char buffer[32];
is_ok = test_run_simple ("print ('Hello, World!');");
JERRY_ASSERT (is_ok);
is_ok = test_run_simple ("throw 'Hello World';");
JERRY_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));
res = jerry_run (parsed_code_val);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
global_obj_val = jerry_get_global_object ();
// 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);
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));
// 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)
&& 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));
// 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)
&& 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));
// 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)
&& jerry_get_number_value (res) == 5.0);
jerry_release_value (res);
jerry_release_value (val_bar);
// Set global.t = "abcd"
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));
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));
sz = jerry_get_string_size (res);
JERRY_ASSERT (sz == 4);
sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 4);
jerry_release_value (res);
JERRY_ASSERT (!strncmp (buffer, "abcd", (size_t) sz));
jerry_release_value (args[0]);
jerry_release_value (args[1]);
// 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));
// Get A.prototype
is_ok = jerry_value_is_constructor (val_A);
JERRY_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));
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));
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));
// Get a.t
res = get_property (val_a, "t");
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_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);
// 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);
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);
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));
// 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)
&& jerry_get_number_value (res) == 12.0);
jerry_release_value (res);
jerry_release_value (val_a_foo);
jerry_release_value (val_a);
// 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)
&& 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));
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));
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));
sz = jerry_get_string_size (res);
JERRY_ASSERT (sz == 19);
sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 19);
jerry_release_value (res);
JERRY_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)
&& 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));
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));
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)
&& jerry_get_boolean_value (val_value_field));
jerry_release_value (val_value_field);
jerry_release_value (external_construct_val);
uintptr_t ptr;
is_ok = jerry_get_object_native_handle (res, &ptr);
JERRY_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));
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));
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));
res = jerry_call_function (val_t, global_obj_val, NULL, 0);
JERRY_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));
res = jerry_call_function (val_t, global_obj_val, NULL, 0);
JERRY_ASSERT (jerry_value_has_error_flag (res));
jerry_release_value (val_t);
// 'res' should contain exception object
JERRY_ASSERT (jerry_value_is_object (res));
jerry_release_value (res);
// 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));
// 'res' should contain exception object
JERRY_ASSERT (jerry_value_is_object (res));
jerry_release_value (res);
jerry_release_value (obj_val);
// 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));
res = jerry_construct_object (val_t, NULL, 0);
JERRY_ASSERT (jerry_value_has_error_flag (res));
jerry_release_value (val_t);
// 'res' should contain exception object
JERRY_ASSERT (jerry_value_is_object (res));
jerry_release_value (res);
// 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));
// 'res' should contain exception object
JERRY_ASSERT (jerry_value_is_object (res));
jerry_release_value (res);
jerry_release_value (obj_val);
// 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);
jerry_value_t v_in = jerry_create_number (10.5);
jerry_set_property_by_index (array_obj_val, 5, v_in);
jerry_value_t v_out = jerry_get_property_by_index (array_obj_val, 5);
JERRY_ASSERT (jerry_value_is_number (v_out)
&& jerry_get_number_value (v_out) == 10.5);
jerry_release_value (v_in);
jerry_release_value (v_out);
jerry_release_value (array_obj_val);
// 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: 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));
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));
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));
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));
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));
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));
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));
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));
proto_val = jerry_get_prototype (obj_val);
JERRY_ASSERT (!jerry_value_has_error_flag (proto_val));
JERRY_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));
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)
&& jerry_get_number_value (res) == 123.0);
jerry_release_value (res);
jerry_release_value (val_t);
// cleanup.
jerry_release_value (global_obj_val);
// TEST: run gc.
jerry_gc ();
jerry_cleanup ();
JERRY_ASSERT (test_api_is_free_callback_was_called);
// External Magic String
jerry_init (JERRY_INIT_SHOW_OPCODES);
uint32_t num_magic_string_items = (uint32_t) (sizeof (magic_string_items) / sizeof (jerry_char_ptr_t));
jerry_register_magic_strings (magic_string_items,
num_magic_string_items,
magic_string_lengths);
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));
res = jerry_run (parsed_code_val);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_cleanup ();
// Dump / execute snapshot
// FIXME: support save/load snapshot for optimized parser
if (false)
{
static uint8_t global_mode_snapshot_buffer[1024];
static uint8_t eval_mode_snapshot_buffer[1024];
const char *code_to_snapshot_p = "(function () { return 'string from snapshot'; }) ();";
jerry_init (JERRY_INIT_SHOW_OPCODES);
size_t global_mode_snapshot_size = jerry_parse_and_save_snapshot ((jerry_char_t *) code_to_snapshot_p,
strlen (code_to_snapshot_p),
true,
false,
global_mode_snapshot_buffer,
sizeof (global_mode_snapshot_buffer));
JERRY_ASSERT (global_mode_snapshot_size != 0);
jerry_cleanup ();
jerry_init (JERRY_INIT_SHOW_OPCODES);
size_t eval_mode_snapshot_size = jerry_parse_and_save_snapshot ((jerry_char_t *) code_to_snapshot_p,
strlen (code_to_snapshot_p),
false,
false,
eval_mode_snapshot_buffer,
sizeof (eval_mode_snapshot_buffer));
JERRY_ASSERT (eval_mode_snapshot_size != 0);
jerry_cleanup ();
jerry_init (JERRY_INIT_SHOW_OPCODES);
res = jerry_exec_snapshot (global_mode_snapshot_buffer,
global_mode_snapshot_size,
false);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_undefined (res));
jerry_release_value (res);
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));
sz = jerry_get_string_size (res);
JERRY_ASSERT (sz == 20);
sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 20);
jerry_release_value (res);
JERRY_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz));
jerry_cleanup ();
}
return 0;
} /* main */
int
main (void)
{
TEST_INIT ();
jerry_init (JERRY_INIT_EMPTY);
const jerry_char_t test_eval_function[] = "function demo(a) { return a + 1; }; demo";
test_entry_t entries[] =
{
ENTRY (JERRY_TYPE_NUMBER, jerry_create_number (-33.0)),
ENTRY (JERRY_TYPE_NUMBER, jerry_create_number (3)),
ENTRY (JERRY_TYPE_NUMBER, jerry_create_number_nan ()),
ENTRY (JERRY_TYPE_NUMBER, jerry_create_number_infinity (false)),
ENTRY (JERRY_TYPE_NUMBER, jerry_create_number_infinity (true)),
ENTRY (JERRY_TYPE_BOOLEAN, jerry_create_boolean (true)),
ENTRY (JERRY_TYPE_BOOLEAN, jerry_create_boolean (false)),
ENTRY (JERRY_TYPE_UNDEFINED, jerry_create_undefined ()),
ENTRY (JERRY_TYPE_OBJECT, jerry_create_object ()),
ENTRY (JERRY_TYPE_OBJECT, jerry_create_array (10)),
ENTRY (JERRY_TYPE_ERROR, jerry_create_error (JERRY_ERROR_TYPE, (const jerry_char_t *) "error")),
ENTRY (JERRY_TYPE_NULL, jerry_create_null ()),
ENTRY (JERRY_TYPE_FUNCTION, jerry_eval (test_eval_function,
sizeof (test_eval_function) - 1,
JERRY_PARSE_NO_OPTS)),
ENTRY (JERRY_TYPE_FUNCTION, jerry_create_external_function (test_ext_function)),
ENTRY (JERRY_TYPE_STRING, jerry_create_string (test_eval_function)),
ENTRY (JERRY_TYPE_STRING, jerry_create_string ((jerry_char_t *) "")),
};
for (size_t idx = 0; idx < sizeof (entries) / sizeof (entries[0]); idx++)
{
jerry_type_t type_info = jerry_value_get_type (entries[idx].value);
TEST_ASSERT (type_info != JERRY_TYPE_NONE);
TEST_ASSERT (type_info == entries[idx].type_info);
jerry_release_value (entries[idx].value);
}
if (jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
{
jerry_value_t symbol_desc_value = jerry_create_string ((jerry_char_t *) "foo");
jerry_value_t symbol_value = jerry_create_symbol (symbol_desc_value);
jerry_type_t type_info = jerry_value_get_type (symbol_value);
TEST_ASSERT (type_info != JERRY_TYPE_NONE);
TEST_ASSERT (type_info == JERRY_TYPE_SYMBOL);
jerry_release_value (symbol_value);
jerry_release_value (symbol_desc_value);
}
jerry_cleanup ();
return 0;
} /* main */
