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

Rework the public API (#4829)

Browse Source 
Related to #4186.

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

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

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

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

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

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

JerryScript-DCO-1.0-Signed-off-by: Dániel Bátyai dbatyai@inf.u-szeged.hu
This commit is contained in:
Dániel Bátyai
2021-12-06 10:20:09 +01:00
committed by GitHub
parent 81d2319144
commit 9860d66a56
180 changed files with 10738 additions and 11025 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit-core/test-objects-foreach.c
+61 -61
View File
@@ -32,14 +32,14 @@ count_objects (jerry_value_t object, void *user_arg)
static void
test_container (void)
{
jerry_value_t global = jerry_get_global_object ();
jerry_value_t map_str = jerry_create_string ((const jerry_char_t *) "Map");
jerry_value_t map_result = jerry_get_property (global, map_str);
jerry_type_t type = jerry_value_get_type (map_result);
jerry_value_t global = jerry_current_realm ();
jerry_value_t map_str = jerry_string_sz ("Map");
jerry_value_t map_result = jerry_object_get (global, map_str);
jerry_type_t type = jerry_value_type (map_result);
jerry_release_value (map_result);
jerry_release_value (map_str);
jerry_release_value (global);
jerry_value_free (map_result);
jerry_value_free (map_str);
jerry_value_free (global);
/* If there is no Map function this is not an es.next profile build, skip this test case. */
if (type != JERRY_TYPE_FUNCTION)
@@ -53,8 +53,8 @@ test_container (void)
const char array_str[] = "var DEMO = [[1, 2], [3, 4]]; DEMO";
jerry_value_t array = jerry_eval ((const jerry_char_t *) array_str, sizeof (array_str) - 1, 0);
TEST_ASSERT (jerry_value_is_object (array));
TEST_ASSERT (!jerry_value_is_error (array));
jerry_release_value (array);
TEST_ASSERT (!jerry_value_is_exception (array));
jerry_value_free (array);
}
const char eval_str[] = "new Map (DEMO)";
@@ -62,73 +62,73 @@ test_container (void)
/* Make sure that the Map and it's prototype object/function is initialized. */
jerry_value_t result = jerry_eval ((const jerry_char_t *) eval_str, sizeof (eval_str) - 1, 0);
TEST_ASSERT (jerry_value_is_object (result));
TEST_ASSERT (!jerry_value_is_error (result));
jerry_release_value (result);
TEST_ASSERT (!jerry_value_is_exception (result));
jerry_value_free (result);
}
/* Do a bit of cleaning to clear up old objects. */
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
/* Get the number of iterable objects. */
int start_count = 0;
jerry_objects_foreach (count_objects, &start_count);
jerry_foreach_live_object (count_objects, &start_count);
/* Create another map. */
jerry_value_t result = jerry_eval ((const jerry_char_t *) eval_str, sizeof (eval_str) - 1, 0);
/* Remove any old/unused objects. */
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
/* Get the current number of objects. */
int end_count = 0;
jerry_objects_foreach (count_objects, &end_count);
jerry_foreach_live_object (count_objects, &end_count);
/* As only one Map was created the number of available iterable objects should be incremented only by one. */
TEST_ASSERT (end_count > start_count);
TEST_ASSERT ((end_count - start_count) == 1);
jerry_release_value (result);
jerry_value_free (result);
} /* test_container */
static void
test_internal_prop (void)
{
/* Make sure that the object is initialized in the engine. */
jerry_value_t object_dummy = jerry_create_object ();
jerry_value_t object_dummy = jerry_object ();
/* Get the number of iterable objects. */
int before_object_count = 0;
jerry_objects_foreach (count_objects, &before_object_count);
jerry_foreach_live_object (count_objects, &before_object_count);
jerry_value_t object = jerry_create_object ();
jerry_value_t object = jerry_object ();
/* After creating the object, the number of objects is incremented by one. */
int after_object_count = 0;
{
jerry_objects_foreach (count_objects, &after_object_count);
jerry_foreach_live_object (count_objects, &after_object_count);
TEST_ASSERT (after_object_count > before_object_count);
TEST_ASSERT ((after_object_count - before_object_count) == 1);
}
jerry_value_t internal_prop_name = jerry_create_string ((const jerry_char_t *) "hidden_foo");
jerry_value_t internal_prop_object = jerry_create_object ();
bool internal_result = jerry_set_internal_property (object, internal_prop_name, internal_prop_object);
jerry_value_t internal_prop_name = jerry_string_sz ("hidden_foo");
jerry_value_t internal_prop_object = jerry_object ();
bool internal_result = jerry_object_set_internal (object, internal_prop_name, internal_prop_object);
TEST_ASSERT (internal_result == true);
jerry_release_value (internal_prop_name);
jerry_release_value (internal_prop_object);
jerry_value_free (internal_prop_name);
jerry_value_free (internal_prop_object);
/* After adding an internal property object, the number of object is incremented by one. */
{
int after_internal_count = 0;
jerry_objects_foreach (count_objects, &after_internal_count);
jerry_foreach_live_object (count_objects, &after_internal_count);
TEST_ASSERT (after_internal_count > after_object_count);
TEST_ASSERT ((after_internal_count - after_object_count) == 1);
}
jerry_release_value (object);
jerry_release_value (object_dummy);
jerry_value_free (object);
jerry_value_free (object_dummy);
} /* test_internal_prop */
static int test_data = 1;
@@ -154,7 +154,7 @@ find_test_object_by_data (const jerry_value_t candidate, void *object_data_p, vo
{
if (object_data_p == &test_data)
{
*((jerry_value_t *) context_p) = jerry_acquire_value (candidate);
*((jerry_value_t *) context_p) = jerry_value_copy (candidate);
return false;
}
return true;
@@ -164,17 +164,17 @@ static bool
find_test_object_by_property (const jerry_value_t candidate, void *context_p)
{
jerry_value_t *args_p = (jerry_value_t *) context_p;
jerry_value_t result = jerry_has_property (candidate, args_p[0]);
jerry_value_t result = jerry_object_has (candidate, args_p[0]);
bool has_property = (!jerry_value_is_error (result) && jerry_value_is_true (result));
bool has_property = (!jerry_value_is_exception (result) && jerry_value_is_true (result));
/* If the object has the desired property, store a new reference to it in args_p[1]. */
if (has_property)
{
args_p[1] = jerry_acquire_value (candidate);
args_p[1] = jerry_value_copy (candidate);
}
jerry_release_value (result);
jerry_value_free (result);
/* Stop iterating if we've found our object. */
return !has_property;
@@ -190,64 +190,64 @@ main (void)
/* Render strict-equal as a function. */
jerry_value_t parse_result = jerry_parse (strict_equal_source, sizeof (strict_equal_source) - 1, &parse_options);
TEST_ASSERT (!jerry_value_is_error (parse_result));
TEST_ASSERT (!jerry_value_is_exception (parse_result));
jerry_value_t strict_equal = jerry_run (parse_result);
TEST_ASSERT (!jerry_value_is_error (strict_equal));
jerry_release_value (parse_result);
TEST_ASSERT (!jerry_value_is_exception (strict_equal));
jerry_value_free (parse_result);
/* Create an object and associate some native data with it. */
jerry_value_t object = jerry_create_object ();
jerry_set_object_native_pointer (object, &test_data, &test_info);
jerry_value_t object = jerry_object ();
jerry_object_set_native_ptr (object, &test_info, &test_data);
/* Retrieve the object by its native pointer. */
jerry_value_t found_object;
TEST_ASSERT (jerry_objects_foreach_by_native_info (&test_info, find_test_object_by_data, &found_object));
TEST_ASSERT (jerry_foreach_live_object_with_info (&test_info, find_test_object_by_data, &found_object));
jerry_value_t args[2] = { object, found_object };
/* Assert that the correct object was retrieved. */
jerry_value_t undefined = jerry_create_undefined ();
jerry_value_t strict_equal_result = jerry_call_function (strict_equal, undefined, args, 2);
jerry_value_t undefined = jerry_undefined ();
jerry_value_t strict_equal_result = jerry_call (strict_equal, undefined, args, 2);
TEST_ASSERT (jerry_value_is_boolean (strict_equal_result) && jerry_value_is_true (strict_equal_result));
jerry_release_value (strict_equal_result);
jerry_release_value (found_object);
jerry_release_value (object);
jerry_value_free (strict_equal_result);
jerry_value_free (found_object);
jerry_value_free (object);
/* Collect garbage. */
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
/* Attempt to retrieve the object by its native pointer again. */
TEST_ASSERT (!jerry_objects_foreach_by_native_info (&test_info, find_test_object_by_data, &found_object));
TEST_ASSERT (!jerry_foreach_live_object_with_info (&test_info, find_test_object_by_data, &found_object));
/* Create an object and set a property on it. */
object = jerry_create_object ();
jerry_value_t property_name = jerry_create_string ((jerry_char_t *) "xyzzy");
jerry_value_t property_value = jerry_create_number (42);
jerry_release_value (jerry_set_property (object, property_name, property_value));
jerry_release_value (property_value);
object = jerry_object ();
jerry_value_t property_name = jerry_string_sz ("xyzzy");
jerry_value_t property_value = jerry_number (42);
jerry_value_free (jerry_object_set (object, property_name, property_value));
jerry_value_free (property_value);
/* Retrieve the object by the presence of its property, placing it at args[1]. */
args[0] = property_name;
TEST_ASSERT (jerry_objects_foreach (find_test_object_by_property, args));
TEST_ASSERT (jerry_foreach_live_object (find_test_object_by_property, args));
/* Assert that the right object was retrieved and release both the original reference to it and the retrieved one. */
args[0] = object;
strict_equal_result = jerry_call_function (strict_equal, undefined, args, 2);
strict_equal_result = jerry_call (strict_equal, undefined, args, 2);
TEST_ASSERT (jerry_value_is_boolean (strict_equal_result) && jerry_value_is_true (strict_equal_result));
jerry_release_value (strict_equal_result);
jerry_release_value (args[0]);
jerry_release_value (args[1]);
jerry_value_free (strict_equal_result);
jerry_value_free (args[0]);
jerry_value_free (args[1]);
/* Collect garbage. */
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
/* Attempt to retrieve the object by the presence of its property again. */
args[0] = property_name;
TEST_ASSERT (!jerry_objects_foreach (find_test_object_by_property, args));
TEST_ASSERT (!jerry_foreach_live_object (find_test_object_by_property, args));
jerry_release_value (property_name);
jerry_release_value (undefined);
jerry_release_value (strict_equal);
jerry_value_free (property_name);
jerry_value_free (undefined);
jerry_value_free (strict_equal);
test_container ();
test_internal_prop ();