Rename the jerry_value_has_error_flag function. (#2290)

Rename the function to represent it's real functionality.

JerryScript-DCO-1.0-Signed-off-by: Istvan Miklos imiklos2@inf.u-szeged.hu

docs/02.API-REFERENCE.md

@@ -947,7 +947,7 @@ main (void)
   /* Setup Global scope code */
   jerry_value_t parsed_code = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
 
-  if (!jerry_value_has_error_flag (parsed_code))
+  if (!jerry_value_is_error (parsed_code))
   {
     /* Execute the parsed source code in the Global scope */
     jerry_value_t ret_value = jerry_run (parsed_code);
@@ -1244,6 +1244,44 @@ jerry_value_is_constructor (const jerry_value_t value)
 
 - [jerry_release_value](#jerry_release_value)
 
+## jerry_value_is_error
+
+**Summary**
+
+Returns whether the given `jerry_value_t` is error value.
+
+**Prototype**
+
+```c
+bool
+jerry_value_is_error (const jerry_value_t value);
+```
+
+- `value` - api value
+- return value
+  - true, if the given `jerry_value_t` is error value.
+  - false, otherwise
+
+**Example**
+
+```c
+{
+  jerry_value_t value;
+  ... // create or acquire value
+
+  if (jerry_value_is_error (value))
+  {
+    ...
+  }
+
+  jerry_release_value (value);
+}
+```
+
+**See also**
+
+- [jerry_value_t](#jerry_value_t)
+- [jerry_value_has_abort_flag](#jerry_value_has_abort_flag)
 
 ## jerry_value_is_function
 
@@ -1641,7 +1679,7 @@ If a non-error object is used as the input for the function the method
 will return `JERRY_ERROR_NONE` indicating that the value was not
 an Error object. However it is still possible that the value contains
 error semantics. To correctly detect if a value have error use the
-[jerry_value_has_error_flag](#jerry_value_has_error_flag) method.
+[jerry_value_is_error](#jerry_value_is_error) method.
 
 **Prototype**
 
@@ -1672,47 +1710,7 @@ jerry_get_error_type (const jerry_value_t value);
 **See also**
 
 - [jerry_create_error](#jerry_create_error)
-- [jerry_value_has_error_flag](#jerry_value_has_error_flag)
+- [jerry_value_is_error](#jerry_value_is_error)
-
-## jerry_value_has_error_flag
-
-**Summary**
-
-Returns whether the given `jerry_value_t` has the error flag set.
-
-**Prototype**
-
-```c
-bool
-jerry_value_has_error_flag (const jerry_value_t value);
-```
-
-- `value` - api value
-- return value
-  - true, if the given `jerry_value_t` has the error flag set
-  - false, otherwise
-
-**Example**
-
-```c
-{
-  jerry_value_t value;
-  ... // create or acquire value
-
-  if (jerry_value_has_error_flag (value))
-  {
-    ...
-  }
-
-  jerry_release_value (value);
-}
-```
-
-**See also**
-
-- [jerry_value_t](#jerry_value_t)
-- [jerry_value_has_abort_flag](#jerry_value_has_abort_flag)
-
 
 ## jerry_value_has_abort_flag
 
@@ -1751,7 +1749,7 @@ jerry_value_has_abort_flag (const jerry_value_t value);
 **See also**
 
 - [jerry_value_t](#jerry_value_t)
-- [jerry_value_has_error_flag](#jerry_value_has_error_flag)
+- [jerry_value_is_error](#jerry_value_is_error)
 
 
 ## jerry_value_clear_error_flag
@@ -2647,7 +2645,7 @@ jerry_resolve_or_reject_promise (jerry_value_t promise,
                                                          argument,
                                                          is_resolve);
 
-  if (jerry_value_has_error_flag (is_ok))
+  if (jerry_value_is_error (is_ok))
   {
     // handle the error.
   }
@@ -2661,7 +2659,7 @@ jerry_resolve_or_reject_promise (jerry_value_t promise,
 **See also**
 
 - [jerry_release_value](#jerry_release_value)
-- [jerry_value_has_error_flag](#jerry_value_has_error_flag)
+- [jerry_value_is_error](#jerry_value_is_error)
 
 
 # Acquire and release API values
@@ -2935,7 +2933,7 @@ jerry_create_error (jerry_error_t error_type,
 
 **See also**
 
-- [jerry_value_has_error_flag](#jerry_value_has_error_flag)
+- [jerry_value_is_error](#jerry_value_is_error)
 - [jerry_value_clear_error_flag](#jerry_value_clear_error_flag)
 - [jerry_value_set_error_flag](#jerry_value_set_error_flag)
 
@@ -4174,7 +4172,7 @@ jerry_call_function (const jerry_value_t func_obj_val,
     jerry_value_t this_val = jerry_create_undefined ();
     jerry_value_t ret_val = jerry_call_function (val, this_val, NULL, 0);
 
-    if (!jerry_value_has_error_flag (ret_val))
+    if (!jerry_value_is_error (ret_val))
     {
       ... // handle return value
     }
@@ -4229,7 +4227,7 @@ jerry_construct_object (const jerry_value_t func_obj_val,
   {
     jerry_value_t ret_val = jerry_construct_object (val, NULL, 0);
 
-    if (!jerry_value_has_error_flag (ret_val))
+    if (!jerry_value_is_error (ret_val))
     {
       ... // handle return value
     }
@@ -4700,7 +4698,7 @@ find_my_object(const jerry_value_t candidate,
 {
   find_my_object_info_t *info_p = (find_my_object_info_t *) user_data_p;
   jerry_value_t has_property = jerry_object_has_property (candidate, info_p->property_name);
-  bool keep_searching = (jerry_value_has_error_flag (has_property) || !jerry_get_boolean_value ());
+  bool keep_searching = (jerry_value_is_error (has_property) || !jerry_get_boolean_value ());
   if (!keep_searching)
   {
     /* We found it, so we acquire the value and record it. */
@@ -5885,4 +5883,4 @@ jerry_value_t jerry_json_stringfy (const jerry_value_t object_to_stringify)
   jerry_release_value (value);
   jerry_release_value (stringified);
 }
-```
+```

docs/03.API-EXAMPLE.md

@@ -57,7 +57,7 @@ main (void)
   /* Setup Global scope code */
   jerry_value_t parsed_code = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
 
-  if (!jerry_value_has_error_flag (parsed_code))
+  if (!jerry_value_is_error (parsed_code))
   {
     /* Execute the parsed source code in the Global scope */
     jerry_value_t ret_value = jerry_run (parsed_code);
@@ -325,7 +325,7 @@ main (void)
                           false);
 
     /* If command evaluated successfully, print value, returned by eval */
-    if (jerry_value_has_error_flag (ret_val))
+    if (jerry_value_is_error (ret_val))
     {
       /* Evaluated JS code thrown an exception
        *  and didn't handle it with try-catch-finally */
@@ -462,7 +462,7 @@ add_handler (const jerry_value_t func_value, /**< function object */
   jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "x");
   jerry_value_t x_val = jerry_get_property (this_val, prop_name);
 
-  if (!jerry_value_has_error_flag (x_val))
+  if (!jerry_value_is_error (x_val))
   {
     /* Convert Jerry API values to double */
     double x = jerry_get_number_value (x_val);

docs/06.REFERENCE-COUNTING.md

@@ -61,7 +61,7 @@ behaviour through property getting and setting.
    * prop_value contains a live reference to an error object.
    * This reference must be released as well. */
 
-  if (jerry_value_has_error_flag (prop_value))
+  if (jerry_value_is_error (prop_value))
   {
     /* Errors can be handled here. */
   }
@@ -93,7 +93,7 @@ behaviour through property getting and setting.
   /* The reference stored in the 'result' variable is live whether
    * the operation is successful or not, and must also be freed. */
 
-  if (jerry_value_has_error_flag (result))
+  if (jerry_value_is_error (result))
   {
     /* Errors can be handled here. */
   }

docs/07.DEBUGGER.md

@@ -305,7 +305,7 @@ wait_for_source_callback (const jerry_char_t *resource_name_p, /**< resource nam
                                        source_size,
                                        JERRY_PARSE_NO_OPTS);
 
-  if (!jerry_value_has_error_flag (ret_val))
+  if (!jerry_value_is_error (ret_val))
   {
     jerry_value_t func_val = ret_val;
     ret_val = jerry_run (func_val);

docs/09.EXT-REFERENCE-ARG.md

@@ -244,7 +244,7 @@ my_external_handler (const jerry_value_t function_obj,
                                                                mapping,
                                                                4);
 
-  if (jerry_value_has_error_flag (rv))
+  if (jerry_value_is_error (rv))
   {
     /* Handle error. */
     return rv;
@@ -640,7 +640,7 @@ my_external_handler (const jerry_value_t function_obj,
                                                       mapping,
                                                       1);
 
-  if (jerry_value_has_error_flag (rv))
+  if (jerry_value_is_error (rv))
   {
     /* Handle error. */
     return rv;
@@ -731,7 +731,7 @@ my_external_handler (const jerry_value_t function_obj,
                                                       mapping,
                                                       1);
 
-  if (jerry_value_has_error_flag (rv))
+  if (jerry_value_is_error (rv))
   {
     /* Handle error. */
     return rv;

docs/10.EXT-REFERENCE-HANDLER.md

@@ -136,7 +136,7 @@ register_common_functions (void)
 {
   jerry_value_t ret = jerry_create_undefined ();
 
-  for (int i = 0; common_functions[i].name_p != NULL && !jerry_value_has_error_flag (ret); i++)
+  for (int i = 0; common_functions[i].name_p != NULL && !jerry_value_is_error (ret); i++)
   {
     ret = jerryx_handler_register_global ((const jerry_char_t *) common_functions[i].name_p,
                                           common_functions[i].handler_p);

jerry-core/api/jerry.c

@@ -670,6 +670,20 @@ jerry_value_is_constructor (const jerry_value_t value) /**< jerry api value */
   return ecma_is_constructor (jerry_get_arg_value (value));
 } /* jerry_value_is_constructor */
 
+/**
+ * Check if the specified value is an error or abort value.
+ *
+ * @return true  - if the specified value is an error value,
+ *         false - otherwise
+ */
+bool
+jerry_value_is_error (const jerry_value_t value) /**< api value */
+{
+  jerry_assert_api_available ();
+
+  return ecma_is_value_error_reference (value);
+} /* jerry_value_is_error */
+
 /**
  * Check if the specified value is a function object value.
  *
@@ -890,20 +904,6 @@ bool jerry_is_feature_enabled (const jerry_feature_t feature)
           );
 } /* jerry_is_feature_enabled */
 
-/**
- * Check if the specified value is an error or abort value.
- *
- * @return true  - if the error flag of the specified value is true,
- *         false - otherwise
- */
-bool
-jerry_value_has_error_flag (const jerry_value_t value) /**< api value */
-{
-  jerry_assert_api_available ();
-
-  return ecma_is_value_error_reference (value);
-} /* jerry_value_has_error_flag */
-
 /**
  * Check if the specified value is an abort value.
  *

jerry-core/include/jerryscript-core.h

@@ -339,6 +339,7 @@ jerry_value_t jerry_get_global_object (void);
 bool jerry_value_is_array (const jerry_value_t value);
 bool jerry_value_is_boolean (const jerry_value_t value);
 bool jerry_value_is_constructor (const jerry_value_t value);
+bool jerry_value_is_error (const jerry_value_t value);
 bool jerry_value_is_function (const jerry_value_t value);
 bool jerry_value_is_number (const jerry_value_t value);
 bool jerry_value_is_null (const jerry_value_t value);
@@ -370,9 +371,8 @@ jerry_type_t jerry_value_get_type (const jerry_value_t value);
 bool jerry_is_feature_enabled (const jerry_feature_t feature);
 
 /**
- * Error flag manipulation functions.
+ * Error manipulation functions.
  */
-bool jerry_value_has_error_flag (const jerry_value_t value);
 bool jerry_value_has_abort_flag (const jerry_value_t value);
 void jerry_value_clear_error_flag (jerry_value_t *value_p);
 void jerry_value_set_error_flag (jerry_value_t *value_p);

jerry-ext/arg/arg-transform-functions.c

@@ -79,7 +79,7 @@ jerryx_arg_transform_number_common (jerryx_arg_js_iterator_t *js_arg_iter_p, /**
 
   jerry_value_t to_number = jerry_value_to_number (js_arg);
 
-  if (jerry_value_has_error_flag (to_number))
+  if (jerry_value_is_error (to_number))
   {
     jerry_release_value (to_number);
 
@@ -177,14 +177,14 @@ jerryx_arg_helper_process_double (double *d, /**< [in, out] the number to be pro
   { \
     double tmp = 0.0; \
     jerry_value_t rv = jerryx_arg_transform_number ## suffix ## _common (js_arg_iter_p, &tmp); \
-    if (jerry_value_has_error_flag (rv)) \
+    if (jerry_value_is_error (rv)) \
     { \
       return rv; \
     } \
     jerry_release_value (rv); \
     jerryx_arg_int_option_t *options_p = (jerryx_arg_int_option_t *) &c_arg_p->extra_info; \
     rv = jerryx_arg_helper_process_double (&tmp, min, max, *options_p); \
-    if (jerry_value_has_error_flag (rv)) \
+    if (jerry_value_is_error (rv)) \
     { \
       return rv; \
     } \
@@ -329,7 +329,7 @@ jerryx_arg_transform_string_common (jerryx_arg_js_iterator_t *js_arg_iter_p, /**
 
   jerry_value_t to_string = jerry_value_to_string (js_arg);
 
-  if (jerry_value_has_error_flag (to_string))
+  if (jerry_value_is_error (to_string))
   {
     jerry_release_value (to_string);
 

jerry-ext/arg/arg.c

@@ -47,7 +47,7 @@ jerryx_arg_transform_args (const jerry_value_t *js_arg_p, /**< points to the arr
     .js_arg_idx = 0
   };
 
-  for (; c_arg_cnt != 0 && !jerry_value_has_error_flag (ret); c_arg_cnt--, c_arg_p++)
+  for (; c_arg_cnt != 0 && !jerry_value_is_error (ret); c_arg_cnt--, c_arg_p++)
   {
     ret = c_arg_p->func (&iterator, c_arg_p);
   }
@@ -86,7 +86,7 @@ jerryx_arg_transform_this_and_args (const jerry_value_t this_val, /**< the this_
 
   jerry_value_t ret = c_arg_p->func (&iterator, c_arg_p);
 
-  if (jerry_value_has_error_flag (ret))
+  if (jerry_value_is_error (ret))
   {
     jerry_release_value (ret);
 
@@ -123,7 +123,7 @@ jerryx_arg_transform_object_properties (const jerry_value_t obj_val,/**< the JS
     prop[i] = jerry_get_property (obj_val, name_str);
     jerry_release_value (name_str);
 
-    if (jerry_value_has_error_flag (prop[i]))
+    if (jerry_value_is_error (prop[i]))
     {
       for (jerry_length_t j = 0; j < i; j++)
       {
@@ -166,7 +166,7 @@ jerryx_arg_transform_array (const jerry_value_t array_val, /**< points to the JS
   {
     arr[i] = jerry_get_property_by_index (array_val, i);
 
-    if (jerry_value_has_error_flag (arr[i]))
+    if (jerry_value_is_error (arr[i]))
     {
       for (jerry_length_t j = 0; j < i; j++)
       {

jerry-ext/handler/handler-print.c

@@ -54,7 +54,7 @@ jerryx_handler_print (const jerry_value_t func_obj_val, /**< function object */
   {
     jerry_value_t str_val = jerry_value_to_string (args_p[arg_index]);
 
-    if (!jerry_value_has_error_flag (str_val))
+    if (!jerry_value_is_error (str_val))
     {
       if (arg_index != 0)
       {

jerry-ext/module/module.c

@@ -116,7 +116,7 @@ jerryx_module_check_cache (jerry_value_t cache, /**< cache from which to attempt
   jerry_value_t js_has_property = jerry_has_property (cache, module_name);
 
   /* If we succeed in getting an answer, we examine the answer. */
-  if (!jerry_value_has_error_flag (js_has_property))
+  if (!jerry_value_is_error (js_has_property))
   {
     bool has_property = jerry_get_boolean_value (js_has_property);
 
@@ -146,7 +146,7 @@ jerryx_module_add_to_cache (jerry_value_t cache, /**< cache to which to add the
 {
   jerry_value_t ret = jerry_set_property (cache, module_name, module);
 
-  if (jerry_value_has_error_flag (ret))
+  if (jerry_value_is_error (ret))
   {
     jerry_release_value (module);
   }
@@ -258,7 +258,7 @@ jerryx_module_resolve (const jerry_value_t name, /**< name of the module to load
     resolve_p = (resolvers_p[index] == NULL ? NULL : resolvers_p[index]->resolve_p);
     if (resolve_p != NULL && resolve_p (canonical_names[index], &ret))
     {
-      if (!jerry_value_has_error_flag (ret))
+      if (!jerry_value_is_error (ret))
       {
         ret = jerryx_module_add_to_cache (instances, canonical_names[index], ret);
       }

jerry-main/main-unix-snapshot.c

@@ -127,11 +127,11 @@ read_file (uint8_t *input_pos_p, /**< next position in the input buffer */
 static void
 print_unhandled_exception (jerry_value_t error_value) /**< error value */
 {
-  assert (!jerry_value_has_error_flag (error_value));
+  assert (!jerry_value_is_error (error_value));
 
   jerry_value_t err_str_val = jerry_value_to_string (error_value);
 
-  if (jerry_value_has_error_flag (err_str_val))
+  if (jerry_value_is_error (err_str_val))
   {
     /* Avoid recursive error throws. */
     jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Snapshot error: [value cannot be converted to string]\n");
@@ -316,7 +316,7 @@ process_generate (cli_state_t *cli_state_p, /**< cli state */
                                              output_buffer,
                                              sizeof (output_buffer) / sizeof (uint32_t));
 
-  if (jerry_value_has_error_flag (snapshot_result))
+  if (jerry_value_is_error (snapshot_result))
   {
     jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Generating snapshot failed!\n");
 

jerry-main/main-unix-test.c

@@ -98,7 +98,7 @@ main (int argc,
     {
       ret_value = jerry_parse (NULL, 0, source_p, source_size, JERRY_PARSE_NO_OPTS);
 
-      if (!jerry_value_has_error_flag (ret_value))
+      if (!jerry_value_is_error (ret_value))
       {
         jerry_value_t func_val = ret_value;
         ret_value = jerry_run (func_val);
@@ -106,7 +106,7 @@ main (int argc,
       }
     }
 
-    if (jerry_value_has_error_flag (ret_value))
+    if (jerry_value_is_error (ret_value))
     {
       break;
     }
@@ -117,7 +117,7 @@ main (int argc,
 
   int ret_code = JERRY_STANDALONE_EXIT_CODE_OK;
 
-  if (jerry_value_has_error_flag (ret_value))
+  if (jerry_value_is_error (ret_value))
   {
     jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Unhandled exception: Script Error!\n");
     ret_code = JERRY_STANDALONE_EXIT_CODE_FAIL;

jerry-main/main-unix.c

@@ -87,7 +87,7 @@ read_file (const char *file_name,
 static void
 print_unhandled_exception (jerry_value_t error_value) /**< error value */
 {
-  assert (!jerry_value_has_error_flag (error_value));
+  assert (!jerry_value_is_error (error_value));
 
   jerry_char_t err_str_buf[256];
 
@@ -97,7 +97,7 @@ print_unhandled_exception (jerry_value_t error_value) /**< error value */
     jerry_value_t backtrace_val = jerry_get_property (error_value, stack_str);
     jerry_release_value (stack_str);
 
-    if (!jerry_value_has_error_flag (backtrace_val)
+    if (!jerry_value_is_error (backtrace_val)
         && jerry_value_is_array (backtrace_val))
     {
       printf ("Exception backtrace:\n");
@@ -114,7 +114,7 @@ print_unhandled_exception (jerry_value_t error_value) /**< error value */
       {
         jerry_value_t item_val = jerry_get_property_by_index (backtrace_val, i);
 
-        if (!jerry_value_has_error_flag (item_val)
+        if (!jerry_value_is_error (item_val)
             && jerry_value_is_string (item_val))
         {
           jerry_size_t str_size = jerry_get_string_size (item_val);
@@ -262,7 +262,7 @@ register_js_function (const char *name_p, /**< name of the function */
 {
   jerry_value_t result_val = jerryx_handler_register_global ((const jerry_char_t *) name_p, handler_p);
 
-  if (jerry_value_has_error_flag (result_val))
+  if (jerry_value_is_error (result_val))
   {
     jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Warning: failed to register '%s' method.", name_p);
     jerry_value_clear_error_flag (&result_val);
@@ -291,7 +291,7 @@ wait_for_source_callback (const jerry_char_t *resource_name_p, /**< resource nam
                                        source_size,
                                        JERRY_PARSE_NO_OPTS);
 
-  if (!jerry_value_has_error_flag (ret_val))
+  if (!jerry_value_is_error (ret_val))
   {
     jerry_value_t func_val = ret_val;
     ret_val = jerry_run (func_val);
@@ -620,14 +620,14 @@ main (int argc,
                                          JERRY_SNAPSHOT_EXEC_COPY_DATA);
       }
 
-      if (jerry_value_has_error_flag (ret_value))
+      if (jerry_value_is_error (ret_value))
       {
         break;
       }
     }
   }
 
-  if (!jerry_value_has_error_flag (ret_value))
+  if (!jerry_value_is_error (ret_value))
   {
     for (int i = 0; i < files_counter; i++)
     {
@@ -652,14 +652,14 @@ main (int argc,
                                source_size,
                                JERRY_PARSE_NO_OPTS);
 
-      if (!jerry_value_has_error_flag (ret_value) && !is_parse_only)
+      if (!jerry_value_is_error (ret_value) && !is_parse_only)
       {
         jerry_value_t func_val = ret_value;
         ret_value = jerry_run (func_val);
         jerry_release_value (func_val);
       }
 
-      if (jerry_value_has_error_flag (ret_value))
+      if (jerry_value_is_error (ret_value))
       {
         break;
       }
@@ -756,7 +756,7 @@ main (int argc,
         /* Evaluate the line */
         jerry_value_t ret_val_eval = jerry_eval (buffer, len, false);
 
-        if (!jerry_value_has_error_flag (ret_val_eval))
+        if (!jerry_value_is_error (ret_val_eval))
         {
           /* Print return value */
           const jerry_value_t args[] = { ret_val_eval };
@@ -768,7 +768,7 @@ main (int argc,
           jerry_release_value (ret_val_eval);
           ret_val_eval = jerry_run_all_enqueued_jobs ();
 
-          if (jerry_value_has_error_flag (ret_val_eval))
+          if (jerry_value_is_error (ret_val_eval))
           {
             jerry_value_clear_error_flag (&ret_val_eval);
             print_unhandled_exception (ret_val_eval);
@@ -787,7 +787,7 @@ main (int argc,
 
   int ret_code = JERRY_STANDALONE_EXIT_CODE_OK;
 
-  if (jerry_value_has_error_flag (ret_value))
+  if (jerry_value_is_error (ret_value))
   {
     jerry_value_clear_error_flag (&ret_value);
     print_unhandled_exception (ret_value);
@@ -799,7 +799,7 @@ main (int argc,
 
   ret_value = jerry_run_all_enqueued_jobs ();
 
-  if (jerry_value_has_error_flag (ret_value))
+  if (jerry_value_is_error (ret_value))
   {
     jerry_value_clear_error_flag (&ret_value);
     print_unhandled_exception (ret_value);

targets/curie_bsp/jerry_app/quark/main.c

@@ -44,7 +44,7 @@ jerry_value_t print_function;
 
 void jerry_resolve_error (jerry_value_t ret_value)
 {
-  if (jerry_value_has_error_flag (ret_value))
+  if (jerry_value_is_error (ret_value))
   {
     jerry_value_clear_error_flag (&ret_value);
     jerry_value_t err_str_val = jerry_value_to_string (ret_value);
@@ -113,7 +113,7 @@ void eval_jerry_script (int argc, char *argv[], struct tcmd_handler_ctx *ctx)
 
     jerry_value_t eval_ret = jerry_eval (buffer, str_total_length - 1, false);
 
-    if (jerry_value_has_error_flag (eval_ret))
+    if (jerry_value_is_error (eval_ret))
     {
       jerry_resolve_error (eval_ret);
       TCMD_RSP_ERROR (ctx, NULL);

targets/esp8266/user/jerry_extapi.c

@@ -166,7 +166,7 @@ register_native_function (const char* name,
   jerry_release_value (global_obj_val);
   jerry_release_value (prop_name_val);
 
-  if (jerry_value_has_error_flag (res))
+  if (jerry_value_is_error (res))
   {
     printf ("!!! register_native_function failed: [%s]\r\n", name);
     jerry_release_value (res);

targets/esp8266/user/jerry_run.c

@@ -37,7 +37,7 @@ int js_eval (const char *source_p, const size_t source_size)
   jerry_value_t res = jerry_eval ((jerry_char_t *) source_p,
                                   source_size,
                                   false);
-  if (jerry_value_has_error_flag (res)) {
+  if (jerry_value_is_error (res)) {
     jerry_release_value (res);
     return -1;
   }
@@ -54,7 +54,7 @@ int js_loop (uint32_t ticknow)
   jerry_value_t sysloop_func = jerry_get_property (global_obj_val, prop_name_val);
   jerry_release_value (prop_name_val);
 
-  if (jerry_value_has_error_flag (sysloop_func)) {
+  if (jerry_value_is_error (sysloop_func)) {
     printf ("Error: '%s' not defined!!!\r\n", fn_sys_loop_name);
     jerry_release_value (sysloop_func);
     jerry_release_value (global_obj_val);
@@ -83,7 +83,7 @@ int js_loop (uint32_t ticknow)
   jerry_release_value (sysloop_func);
   jerry_release_value (global_obj_val);
 
-  if (jerry_value_has_error_flag (res)) {
+  if (jerry_value_is_error (res)) {
     jerry_release_value (res);
     return -3;
   }

targets/mbed/source/jerry_extapi.cpp

@@ -111,7 +111,7 @@ register_native_function (const char* name,
     return is_ok;
   }
 
-  if (jerry_value_has_error_flag (reg_function))
+  if (jerry_value_is_error (reg_function))
   {
     is_ok = false;
     printf ("Error: create_external_function has error flag! \n\r");
@@ -127,7 +127,7 @@ register_native_function (const char* name,
                                                  reg_function);
 
 
-  if (jerry_value_has_error_flag (set_result))
+  if (jerry_value_is_error (set_result))
   {
     is_ok = false;
     printf ("Error: register_native_function failed: [%s]\r\n", name);

targets/mbed/source/jerry_run.cpp

@@ -32,11 +32,11 @@ int js_entry (const char *source_p, const size_t source_size)
 
   jerry_value_t parsed_code = jerry_parse (NULL, 0, jerry_src, source_size, JERRY_PARSE_NO_OPTS);
 
-  if (!jerry_value_has_error_flag (parsed_code))
+  if (!jerry_value_is_error (parsed_code))
   {
     jerry_value_t ret_value = jerry_run (parsed_code);
 
-    if (jerry_value_has_error_flag (ret_value))
+    if (jerry_value_is_error (ret_value))
       {
       printf ("Error: ret_value has an error flag!\r\n");
       return ret_code = -1;
@@ -63,7 +63,7 @@ int js_eval (const char *source_p, const size_t source_size)
                                       source_size,
                                       false);
 
-  if (jerry_value_has_error_flag (ret_val))
+  if (jerry_value_is_error (ret_val))
   {
     printf ("Error: jerry_eval failed!\r\n");
     status = -1;
@@ -83,7 +83,7 @@ int js_loop (uint32_t ticknow)
 
   jerry_release_value (sys_name);
 
-  if (jerry_value_has_error_flag (sysloop_func))
+  if (jerry_value_is_error (sysloop_func))
   {
     printf ("Error: '%s' not defined!!!\r\n", fn_sys_loop_name);
     jerry_release_value (global_obj);
@@ -108,7 +108,7 @@ int js_loop (uint32_t ticknow)
                                                        global_obj,
                                                        val_args,
                                                        val_argv);
-  if (jerry_value_has_error_flag (ret_val_sysloop))
+  if (jerry_value_is_error (ret_val_sysloop))
   {
     status = -3;
   }

targets/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/setInterval-js.cpp

@@ -34,7 +34,7 @@ DECLARE_GLOBAL_FUNCTION(setInterval) {
 
     jerry_value_t result = jerry_set_property_by_index(function_obj_p, id, args[0]);
 
-    if (jerry_value_has_error_flag(result)) {
+    if (jerry_value_is_error(result)) {
         jerry_release_value(result);
         mbed::js::EventLoop::getInstance().getQueue().cancel(id);
 

targets/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/setTimeout-js.cpp

@@ -34,7 +34,7 @@ DECLARE_GLOBAL_FUNCTION(setTimeout) {
 
     jerry_value_t result = jerry_set_property_by_index(function_obj_p, id, args[0]);
 
-    if (jerry_value_has_error_flag(result)) {
+    if (jerry_value_is_error(result)) {
         jerry_release_value(result);
         mbed::js::EventLoop::getInstance().getQueue().cancel(id);
 

targets/mbedos5/jerryscript-mbed/jerryscript-mbed-launcher/source/launcher.cpp

@@ -44,7 +44,7 @@ static int load_javascript() {
 
         jerry_value_t parsed_code = jerry_parse(NULL, 0, code, length, JERRY_PARSE_NO_OPTS);
 
-        if (jerry_value_has_error_flag(parsed_code)) {
+        if (jerry_value_is_error(parsed_code)) {
             LOG_PRINT_ALWAYS("jerry_parse failed [%s]\r\n", js_codes[src].name);
             jerry_release_value(parsed_code);
             jsmbed_js_exit();
@@ -54,7 +54,7 @@ static int load_javascript() {
         jerry_value_t returned_value = jerry_run(parsed_code);
         jerry_release_value(parsed_code);
 
-        if (jerry_value_has_error_flag(returned_value)) {
+        if (jerry_value_is_error(returned_value)) {
             LOG_PRINT_ALWAYS("jerry_run failed [%s]\r\n", js_codes[src].name);
             jerry_release_value(returned_value);
             jsmbed_js_exit();

targets/mbedos5/jerryscript-mbed/jerryscript-mbed-library-registry/source/wrap_tools.cpp

@@ -32,7 +32,7 @@ bool jsmbed_wrap_register_global_function(const char* name, jerry_external_handl
         return is_ok;
     }
 
-    if (jerry_value_has_error_flag(reg_function)) {
+    if (jerry_value_is_error(reg_function)) {
         is_ok = false;
         LOG_PRINT_ALWAYS("Error: jerry_create_external_function has error flag! \r\n");
         jerry_release_value(global_object_val);
@@ -45,7 +45,7 @@ bool jsmbed_wrap_register_global_function(const char* name, jerry_external_handl
     jerry_value_t set_result = jerry_set_property(global_object_val, jerry_name, reg_function);
 
 
-    if (jerry_value_has_error_flag(set_result)) {
+    if (jerry_value_is_error(set_result)) {
         is_ok = false;
         LOG_PRINT_ALWAYS("Error: jerry_create_external_function failed: [%s]\r\n", name);
     }

targets/nuttx-stm32f4/jerry_main.c

@@ -150,7 +150,7 @@ static void
 print_unhandled_exception (jerry_value_t error_value, /**< error value */
                            const jerry_char_t *source_p) /**< source_p */
 {
-  assert (jerry_value_has_error_flag (error_value));
+  assert (jerry_value_is_error (error_value));
 
   error_value = jerry_get_value_without_error_flag (error_value);
   jerry_value_t err_str_val = jerry_value_to_string (error_value);
@@ -279,7 +279,7 @@ register_js_function (const char *name_p, /**< name of the function */
 {
   jerry_value_t result_val = jerryx_handler_register_global ((const jerry_char_t *) name_p, handler_p);
 
-  if (jerry_value_has_error_flag (result_val))
+  if (jerry_value_is_error (result_val))
   {
     jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Warning: failed to register '%s' method.", name_p);
   }
@@ -397,7 +397,7 @@ int jerry_main (int argc, char *argv[])
 
     ret_value = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
 
-    if (!jerry_value_has_error_flag (ret_value))
+    if (!jerry_value_is_error (ret_value))
     {
       ret_value = jerry_run (ret_value);
     }
@@ -421,14 +421,14 @@ int jerry_main (int argc, char *argv[])
                                source_size,
                                JERRY_PARSE_NO_OPTS);
 
-      if (!jerry_value_has_error_flag (ret_value))
+      if (!jerry_value_is_error (ret_value))
       {
         jerry_value_t func_val = ret_value;
         ret_value = jerry_run (func_val);
         jerry_release_value (func_val);
       }
 
-      if (jerry_value_has_error_flag (ret_value))
+      if (jerry_value_is_error (ret_value))
       {
         print_unhandled_exception (ret_value, source_p);
         free ((void*) source_p);
@@ -445,7 +445,7 @@ int jerry_main (int argc, char *argv[])
 
   int ret_code = JERRY_STANDALONE_EXIT_CODE_OK;
 
-  if (jerry_value_has_error_flag (ret_value))
+  if (jerry_value_is_error (ret_value))
   {
     ret_code = JERRY_STANDALONE_EXIT_CODE_FAIL;
   }
@@ -454,7 +454,7 @@ int jerry_main (int argc, char *argv[])
 
   ret_value = jerry_run_all_enqueued_jobs ();
 
-  if (jerry_value_has_error_flag (ret_value))
+  if (jerry_value_is_error (ret_value))
   {
     ret_code = JERRY_STANDALONE_EXIT_CODE_FAIL;
   }

targets/riot-stm32f4/source/main-riotos.c

@@ -36,7 +36,7 @@ register_js_function (const char *name_p, /**< name of the function */
 {
   jerry_value_t result_val = jerryx_handler_register_global ((const jerry_char_t *) name_p, handler_p);
 
-  if (jerry_value_has_error_flag (result_val))
+  if (jerry_value_is_error (result_val))
   {
     printf ("Warning: failed to register '%s' method.", name_p);
   }
@@ -68,7 +68,7 @@ int test_jerry (int argc, char **argv)
   /* Setup Global scope code */
   ret_value = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
 
-  if (!jerry_value_has_error_flag (ret_value))
+  if (!jerry_value_is_error (ret_value))
   {
     /* Execute the parsed source code in the Global scope */
     ret_value = jerry_run (ret_value);
@@ -76,7 +76,7 @@ int test_jerry (int argc, char **argv)
 
   int ret_code = JERRY_STANDALONE_EXIT_CODE_OK;
 
-  if (jerry_value_has_error_flag (ret_value))
+  if (jerry_value_is_error (ret_value))
   {
     printf ("Script Error!");
 

targets/tizenrt-artik053/apps/jerryscript/jerry_main.c

@@ -128,7 +128,7 @@ static void
 print_unhandled_exception (jerry_value_t error_value, /**< error value */
                            const jerry_char_t *source_p) /**< source_p */
 {
-  assert (jerry_value_has_error_flag (error_value));
+  assert (jerry_value_is_error (error_value));
 
   error_value = jerry_get_value_without_error_flag (error_value);
   jerry_value_t err_str_val = jerry_value_to_string (error_value);
@@ -257,7 +257,7 @@ register_js_function (const char *name_p, /**< name of the function */
 {
   jerry_value_t result_val = jerryx_handler_register_global ((const jerry_char_t *) name_p, handler_p);
 
-  if (jerry_value_has_error_flag (result_val))
+  if (jerry_value_is_error (result_val))
   {
     jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Warning: failed to register '%s' method.", name_p);
   }
@@ -373,7 +373,7 @@ jerry_cmd_main (int argc, char *argv[])
 
     ret_value = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
 
-    if (!jerry_value_has_error_flag (ret_value))
+    if (!jerry_value_is_error (ret_value))
     {
       ret_value = jerry_run (ret_value);
     }
@@ -397,14 +397,14 @@ jerry_cmd_main (int argc, char *argv[])
                                source_size,
                                JERRY_PARSE_NO_OPTS);
 
-      if (!jerry_value_has_error_flag (ret_value))
+      if (!jerry_value_is_error (ret_value))
       {
         jerry_value_t func_val = ret_value;
         ret_value = jerry_run (func_val);
         jerry_release_value (func_val);
       }
 
-      if (jerry_value_has_error_flag (ret_value))
+      if (jerry_value_is_error (ret_value))
       {
         print_unhandled_exception (ret_value, source_p);
         free ((void*) source_p);
@@ -421,7 +421,7 @@ jerry_cmd_main (int argc, char *argv[])
 
   int ret_code = JERRY_STANDALONE_EXIT_CODE_OK;
 
-  if (jerry_value_has_error_flag (ret_value))
+  if (jerry_value_is_error (ret_value))
   {
     ret_code = JERRY_STANDALONE_EXIT_CODE_FAIL;
   }

targets/zephyr/src/main-zephyr.c

@@ -36,7 +36,7 @@ register_js_function (const char *name_p, /**< name of the function */
 {
   jerry_value_t result_val = jerryx_handler_register_global ((const jerry_char_t *) name_p, handler_p);
 
-  if (jerry_value_has_error_flag (result_val))
+  if (jerry_value_is_error (result_val))
   {
     jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Warning: failed to register '%s' method.", name_p);
   }
@@ -52,7 +52,7 @@ static int shell_cmd_handler (char *source_buffer)
     strlen (source_buffer),
     false);
 
-  if (jerry_value_has_error_flag (ret_val))
+  if (jerry_value_is_error (ret_val))
   {
     /* User-friendly error messages require at least "cp" JerryScript
        profile. Include a message prefix in case "cp_minimal" profile
@@ -63,7 +63,7 @@ static int shell_cmd_handler (char *source_buffer)
     jerry_value_clear_error_flag (&ret_val);
   }
 
-  if (!jerry_value_has_error_flag (print_function))
+  if (!jerry_value_is_error (print_function))
   {
     jerry_value_t ret_val_print = jerry_call_function (print_function,
       jerry_create_undefined (),
@@ -96,7 +96,7 @@ void main (void)
   print_function = jerry_get_property (global_obj_val, print_func_name_val);
   jerry_release_value (print_func_name_val);
   jerry_release_value (global_obj_val);
-  if (jerry_value_has_error_flag (print_function))
+  if (jerry_value_is_error (print_function))
   {
     printf ("Error: could not look up print function, expression results won't be printed\n");
   }

tests/unit-core/test-abort.c

@@ -45,7 +45,7 @@ main (void)
   jerry_value_t callback_name = jerry_create_string ((jerry_char_t *) "callback");
   jerry_value_t func = jerry_create_external_function (callback_func);
   jerry_value_t res = jerry_set_property (global, callback_name, func);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
 
   jerry_release_value (res);
   jerry_release_value (func);
@@ -68,7 +68,7 @@ main (void)
                                                strlen (inf_loop_code_src_p),
                                                JERRY_PARSE_NO_OPTS);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (parsed_code_val));
+  TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
   res = jerry_run (parsed_code_val);
 
   TEST_ASSERT (jerry_value_has_abort_flag (res));
@@ -101,7 +101,7 @@ main (void)
                                  strlen (inf_loop_code_src_p),
                                  JERRY_PARSE_NO_OPTS);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (parsed_code_val));
+  TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
   res = jerry_run (parsed_code_val);
 
   TEST_ASSERT (jerry_value_has_abort_flag (res));
@@ -112,19 +112,19 @@ main (void)
   /* Test flag overwrites. */
   jerry_value_t value = jerry_create_string ((jerry_char_t *) "Error description");
   TEST_ASSERT (!jerry_value_has_abort_flag (value));
-  TEST_ASSERT (!jerry_value_has_error_flag (value));
+  TEST_ASSERT (!jerry_value_is_error (value));
 
   jerry_value_set_abort_flag (&value);
   TEST_ASSERT (jerry_value_has_abort_flag (value));
-  TEST_ASSERT (jerry_value_has_error_flag (value));
+  TEST_ASSERT (jerry_value_is_error (value));
 
   jerry_value_set_error_flag (&value);
   TEST_ASSERT (!jerry_value_has_abort_flag (value));
-  TEST_ASSERT (jerry_value_has_error_flag (value));
+  TEST_ASSERT (jerry_value_is_error (value));
 
   jerry_value_set_abort_flag (&value);
   TEST_ASSERT (jerry_value_has_abort_flag (value));
-  TEST_ASSERT (jerry_value_has_error_flag (value));
+  TEST_ASSERT (jerry_value_is_error (value));
 
   jerry_release_value (value);
 

tests/unit-core/test-api-errortype.c

@@ -37,7 +37,7 @@ main (void)
   for (size_t idx = 0; idx < sizeof (errors) / sizeof (errors[0]); idx++)
   {
     jerry_value_t error_obj = jerry_create_error (errors[idx], (const jerry_char_t *)"test");
-    TEST_ASSERT (jerry_value_has_error_flag (error_obj));
+    TEST_ASSERT (jerry_value_is_error (error_obj));
     TEST_ASSERT (jerry_get_error_type (error_obj) == errors[idx]);
 
     jerry_value_clear_error_flag (&error_obj);

tests/unit-core/test-api.c

@@ -330,11 +330,11 @@ strict_equals (jerry_value_t a,
 
   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), false);
-  TEST_ASSERT (!jerry_value_has_error_flag (is_equal_fn_val));
+  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);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_boolean (res));
   is_strict_equal = jerry_get_boolean_value (res);
   jerry_release_value (res);
@@ -370,10 +370,10 @@ main (void)
                                  (jerry_char_t *) test_source,
                                  strlen (test_source),
                                  JERRY_PARSE_NO_OPTS);
-  TEST_ASSERT (!jerry_value_has_error_flag (parsed_code_val));
+  TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
 
   res = jerry_run (parsed_code_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   jerry_release_value (res);
   jerry_release_value (parsed_code_val);
 
@@ -605,38 +605,38 @@ main (void)
 
   /* Get global.boo (non-existing field) */
   val_t = get_property (global_obj_val, "boo");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_t));
+  TEST_ASSERT (!jerry_value_is_error (val_t));
   TEST_ASSERT (jerry_value_is_undefined (val_t));
 
   /* Get global.t */
   val_t = get_property (global_obj_val, "t");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_t));
+  TEST_ASSERT (!jerry_value_is_error (val_t));
   TEST_ASSERT (jerry_value_is_number (val_t)
                && jerry_get_number_value (val_t) == 1.0);
   jerry_release_value (val_t);
 
   /* Get global.foo */
   val_foo = get_property (global_obj_val, "foo");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_foo));
+  TEST_ASSERT (!jerry_value_is_error (val_foo));
   TEST_ASSERT (jerry_value_is_object (val_foo));
 
   /* Call foo (4, 2) */
   args[0] = jerry_create_number (4);
   args[1] = jerry_create_number (2);
   res = jerry_call_function (val_foo, jerry_create_undefined (), args, 2);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_number (res)
                && jerry_get_number_value (res) == 1.0);
   jerry_release_value (res);
 
   /* Get global.bar */
   val_bar = get_property (global_obj_val, "bar");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_bar));
+  TEST_ASSERT (!jerry_value_is_error (val_bar));
   TEST_ASSERT (jerry_value_is_object (val_bar));
 
   /* Call bar (4, 2) */
   res = jerry_call_function (val_bar, jerry_create_undefined (), args, 2);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_number (res)
                && jerry_get_number_value (res) == 5.0);
   jerry_release_value (res);
@@ -646,13 +646,13 @@ main (void)
   jerry_release_value (args[0]);
   args[0] = jerry_create_string ((jerry_char_t *) "abcd");
   res = set_property (global_obj_val, "t", args[0]);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_get_boolean_value (res));
   jerry_release_value (res);
 
   /* Call foo (4, 2) */
   res = jerry_call_function (val_foo, jerry_create_undefined (), args, 2);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_string (res));
   sz = jerry_get_string_size (res);
   TEST_ASSERT (sz == 4);
@@ -665,20 +665,20 @@ main (void)
 
   /* Get global.A */
   val_A = get_property (global_obj_val, "A");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_A));
+  TEST_ASSERT (!jerry_value_is_error (val_A));
   TEST_ASSERT (jerry_value_is_object (val_A));
 
   /* Get A.prototype */
   is_ok = jerry_value_is_constructor (val_A);
   TEST_ASSERT (is_ok);
   val_A_prototype = get_property (val_A, "prototype");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_A_prototype));
+  TEST_ASSERT (!jerry_value_is_error (val_A_prototype));
   TEST_ASSERT (jerry_value_is_object (val_A_prototype));
   jerry_release_value (val_A);
 
   /* Set A.prototype.foo = global.foo */
   res = set_property (val_A_prototype, "foo", val_foo);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_get_boolean_value (res));
   jerry_release_value (res);
   jerry_release_value (val_A_prototype);
@@ -686,12 +686,12 @@ main (void)
 
   /* Get global.a */
   val_a = get_property (global_obj_val, "a");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_a));
+  TEST_ASSERT (!jerry_value_is_error (val_a));
   TEST_ASSERT (jerry_value_is_object (val_a));
 
   /* Get a.t */
   res = get_property (val_a, "t");
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_number (res)
                && jerry_get_number_value (res) == 12.0);
   jerry_release_value (res);
@@ -716,12 +716,12 @@ main (void)
 
   /* Get a.foo */
   val_a_foo = get_property (val_a, "foo");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_a_foo));
+  TEST_ASSERT (!jerry_value_is_error (val_a_foo));
   TEST_ASSERT (jerry_value_is_object (val_a_foo));
 
   /* Call a.foo () */
   res = jerry_call_function (val_a_foo, val_a, NULL, 0);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_number (res)
                && jerry_get_number_value (res) == 12.0);
   jerry_release_value (res);
@@ -735,17 +735,17 @@ main (void)
                && jerry_value_is_constructor (external_func_val));
 
   res = set_property (global_obj_val, "external", external_func_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_get_boolean_value (res));
   jerry_release_value (external_func_val);
 
   /* Call 'call_external' function that should call external function created above */
   val_call_external = get_property (global_obj_val, "call_external");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_call_external));
+  TEST_ASSERT (!jerry_value_is_error (val_call_external));
   TEST_ASSERT (jerry_value_is_object (val_call_external));
   res = jerry_call_function (val_call_external, global_obj_val, NULL, 0);
   jerry_release_value (val_call_external);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_string (res));
   sz = jerry_get_string_size (res);
   TEST_ASSERT (sz == 19);
@@ -760,19 +760,19 @@ main (void)
                && jerry_value_is_constructor (external_construct_val));
 
   res = set_property (global_obj_val, "external_construct", external_construct_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_get_boolean_value (res));
   jerry_release_value (res);
 
   /* Call external function created above, as constructor */
   args[0] = jerry_create_boolean (true);
   res = jerry_construct_object (external_construct_val, args, 1);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_object (res));
   val_value_field = get_property (res, "value_field");
 
   /* Get 'value_field' of constructed object */
-  TEST_ASSERT (!jerry_value_has_error_flag (val_value_field));
+  TEST_ASSERT (!jerry_value_is_error (val_value_field));
   TEST_ASSERT (jerry_value_is_boolean (val_value_field)
                && jerry_get_boolean_value (val_value_field));
   jerry_release_value (val_value_field);
@@ -805,28 +805,28 @@ main (void)
   TEST_ASSERT (jerry_value_is_function (throw_test_handler_val));
 
   res = set_property (global_obj_val, "throw_test", throw_test_handler_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_get_boolean_value (res));
   jerry_release_value (res);
   jerry_release_value (throw_test_handler_val);
 
   val_t = get_property (global_obj_val, "call_throw_test");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_t));
+  TEST_ASSERT (!jerry_value_is_error (val_t));
   TEST_ASSERT (jerry_value_is_object (val_t));
 
   res = jerry_call_function (val_t, global_obj_val, NULL, 0);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (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");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_t));
+  TEST_ASSERT (!jerry_value_is_error (val_t));
   TEST_ASSERT (jerry_value_is_object (val_t));
 
   res = jerry_call_function (val_t, global_obj_val, NULL, 0);
 
-  TEST_ASSERT (jerry_value_has_error_flag (res));
+  TEST_ASSERT (jerry_value_is_error (res));
   jerry_release_value (val_t);
 
   /* 'res' should contain exception object */
@@ -836,7 +836,7 @@ main (void)
   /* Test: Call of non-function */
   obj_val = jerry_create_object ();
   res = jerry_call_function (obj_val, global_obj_val, NULL, 0);
-  TEST_ASSERT (jerry_value_has_error_flag (res));
+  TEST_ASSERT (jerry_value_is_error (res));
 
   /* 'res' should contain exception object */
   TEST_ASSERT (jerry_value_is_object (res));
@@ -846,11 +846,11 @@ main (void)
 
   /* Test: Unhandled exception in function called, as constructor */
   val_t = get_property (global_obj_val, "throw_reference_error");
-  TEST_ASSERT (!jerry_value_has_error_flag (val_t));
+  TEST_ASSERT (!jerry_value_is_error (val_t));
   TEST_ASSERT (jerry_value_is_object (val_t));
 
   res = jerry_construct_object (val_t, NULL, 0);
-  TEST_ASSERT (jerry_value_has_error_flag (res));
+  TEST_ASSERT (jerry_value_is_error (res));
   jerry_release_value (val_t);
 
   /* 'res' should contain exception object */
@@ -860,7 +860,7 @@ main (void)
   /* Test: Call of non-function as constructor */
   obj_val = jerry_create_object ();
   res = jerry_construct_object (obj_val, NULL, 0);
-  TEST_ASSERT (jerry_value_has_error_flag (res));
+  TEST_ASSERT (jerry_value_is_error (res));
 
   /* 'res' should contain exception object */
   TEST_ASSERT (jerry_value_is_object (res));
@@ -911,7 +911,7 @@ main (void)
   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);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_boolean (res));
   TEST_ASSERT (jerry_get_boolean_value (res));
   jerry_release_value (res);
@@ -934,39 +934,39 @@ main (void)
 
   /* Test: object keys */
   res = jerry_get_object_keys (global_obj_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_array (res));
   jerry_release_value (res);
 
   /* Test: jerry_value_to_primitive */
   obj_val = jerry_eval ((jerry_char_t *) "new String ('hello')", 20, false);
-  TEST_ASSERT (!jerry_value_has_error_flag (obj_val));
+  TEST_ASSERT (!jerry_value_is_error (obj_val));
   TEST_ASSERT (jerry_value_is_object (obj_val));
   TEST_ASSERT (!jerry_value_is_string (obj_val));
   prim_val = jerry_value_to_primitive (obj_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (prim_val));
+  TEST_ASSERT (!jerry_value_is_error (prim_val));
   TEST_ASSERT (jerry_value_is_string (prim_val));
   jerry_release_value (prim_val);
 
   /* Test: jerry_get_prototype */
   proto_val = jerry_get_prototype (obj_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (proto_val));
+  TEST_ASSERT (!jerry_value_is_error (proto_val));
   TEST_ASSERT (jerry_value_is_object (proto_val));
   jerry_release_value (obj_val);
 
   /* Test: jerry_set_prototype */
   obj_val = jerry_create_object ();
   res = jerry_set_prototype (obj_val, jerry_create_null ());
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_boolean (res));
   TEST_ASSERT (jerry_get_boolean_value (res));
 
   res = jerry_set_prototype (obj_val, jerry_create_object ());
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_boolean (res));
   TEST_ASSERT (jerry_get_boolean_value (res));
   proto_val = jerry_get_prototype (obj_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (proto_val));
+  TEST_ASSERT (!jerry_value_is_error (proto_val));
   TEST_ASSERT (jerry_value_is_object (proto_val));
   jerry_release_value (proto_val);
   jerry_release_value (obj_val);
@@ -974,12 +974,12 @@ main (void)
   /* 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);
-  TEST_ASSERT (!jerry_value_has_error_flag (val_t));
+  TEST_ASSERT (!jerry_value_is_error (val_t));
   TEST_ASSERT (jerry_value_is_object (val_t));
   TEST_ASSERT (jerry_value_is_function (val_t));
 
   res = jerry_call_function (val_t, jerry_create_undefined (), NULL, 0);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_number (res)
                && jerry_get_number_value (res) == 123.0);
   jerry_release_value (res);
@@ -995,7 +995,7 @@ main (void)
   /* 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), true);
-  TEST_ASSERT (!jerry_value_has_error_flag (val_t));
+  TEST_ASSERT (!jerry_value_is_error (val_t));
   TEST_ASSERT (jerry_value_is_number (val_t)
                && jerry_get_number_value (val_t) == 4321.0);
   jerry_release_value (val_t);
@@ -1029,7 +1029,7 @@ main (void)
                                                  strlen (func_src),
                                                  JERRY_PARSE_NO_OPTS);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (func_val));
+  TEST_ASSERT (!jerry_value_is_error (func_val));
 
   jerry_value_t func_args[3] =
   {
@@ -1054,9 +1054,9 @@ main (void)
     jerry_init (JERRY_INIT_EMPTY);
     jerry_value_t num_val = jerry_create_number (123);
     jerry_value_set_error_flag (&num_val);
-    TEST_ASSERT (jerry_value_has_error_flag (num_val));
+    TEST_ASSERT (jerry_value_is_error (num_val));
     jerry_value_t num2_val = jerry_get_value_without_error_flag (num_val);
-    TEST_ASSERT (!jerry_value_has_error_flag (num2_val));
+    TEST_ASSERT (!jerry_value_is_error (num2_val));
     double num = jerry_get_number_value (num2_val);
     TEST_ASSERT (num == 123);
     jerry_release_value (num_val);
@@ -1075,7 +1075,7 @@ main (void)
                                    (jerry_char_t *) parser_err_src_p,
                                    strlen (parser_err_src_p),
                                    JERRY_PARSE_NO_OPTS);
-    TEST_ASSERT (jerry_value_has_error_flag (parsed_code_val));
+    TEST_ASSERT (jerry_value_is_error (parsed_code_val));
     jerry_value_clear_error_flag (&parsed_code_val);
     jerry_value_t err_str_val = jerry_value_to_string (parsed_code_val);
     jerry_size_t err_str_size = jerry_get_string_size (err_str_val);
@@ -1105,10 +1105,10 @@ main (void)
                                  (jerry_char_t *) ms_code_src_p,
                                  strlen (ms_code_src_p),
                                  JERRY_PARSE_NO_OPTS);
-  TEST_ASSERT (!jerry_value_has_error_flag (parsed_code_val));
+  TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
 
   res = jerry_run (parsed_code_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   jerry_release_value (res);
   jerry_release_value (parsed_code_val);
 

tests/unit-core/test-arraybuffer.c

@@ -100,7 +100,7 @@ test_read_with_offset (uint8_t offset) /**< offset for buffer read. */
                                           strlen (eval_arraybuffer_src_p),
                                           true);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (arraybuffer));
+  TEST_ASSERT (!jerry_value_is_error (arraybuffer));
   TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
   TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == 15);
 
@@ -136,7 +136,7 @@ static void test_write_with_offset (uint8_t offset) /**< offset for buffer write
                                           strlen (eval_arraybuffer_src_p),
                                           true);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (arraybuffer));
+  TEST_ASSERT (!jerry_value_is_error (arraybuffer));
   TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
   TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == 15);
 
@@ -199,7 +199,7 @@ main (void)
     jerry_value_t eval_arraybuffer = jerry_eval ((jerry_char_t *) eval_arraybuffer_src_p,
                                                  strlen (eval_arraybuffer_src_p),
                                                  true);
-    TEST_ASSERT (!jerry_value_has_error_flag (eval_arraybuffer));
+    TEST_ASSERT (!jerry_value_is_error (eval_arraybuffer));
     TEST_ASSERT (jerry_value_is_arraybuffer (eval_arraybuffer));
     TEST_ASSERT (jerry_get_arraybuffer_byte_length (eval_arraybuffer) == 10);
     jerry_release_value (eval_arraybuffer);
@@ -209,7 +209,7 @@ main (void)
   {
     const uint32_t length = 15;
     jerry_value_t arraybuffer = jerry_create_arraybuffer (length);
-    TEST_ASSERT (!jerry_value_has_error_flag (arraybuffer));
+    TEST_ASSERT (!jerry_value_is_error (arraybuffer));
     TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
     TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
     jerry_release_value (arraybuffer);
@@ -225,7 +225,7 @@ main (void)
   {
     const uint32_t length = 0;
     jerry_value_t arraybuffer = jerry_create_arraybuffer (length);
-    TEST_ASSERT (!jerry_value_has_error_flag (arraybuffer));
+    TEST_ASSERT (!jerry_value_is_error (arraybuffer));
     TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
     TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
 
@@ -253,7 +253,7 @@ main (void)
   {
     const uint32_t length = 0;
     jerry_value_t arraybuffer = jerry_create_arraybuffer (length);
-    TEST_ASSERT (!jerry_value_has_error_flag (arraybuffer));
+    TEST_ASSERT (!jerry_value_is_error (arraybuffer));
     TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
     TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
 
@@ -321,7 +321,7 @@ main (void)
                                         strlen (eval_arraybuffer_src_p),
                                         true);
 
-    TEST_ASSERT (!jerry_value_has_error_flag (buffer));
+    TEST_ASSERT (!jerry_value_is_error (buffer));
     TEST_ASSERT (jerry_value_is_arraybuffer (buffer));
     TEST_ASSERT (jerry_get_arraybuffer_byte_length (buffer) == 20);
 
@@ -365,7 +365,7 @@ main (void)
   /* Test ArrayBuffer external with invalid arguments */
   {
     jerry_value_t input_buffer = jerry_create_arraybuffer_external (0, NULL, NULL);
-    TEST_ASSERT (jerry_value_has_error_flag (input_buffer));
+    TEST_ASSERT (jerry_value_is_error (input_buffer));
     TEST_ASSERT (jerry_get_error_type (input_buffer) == JERRY_ERROR_RANGE);
     jerry_release_value (input_buffer);
   }

tests/unit-core/test-backtrace.c

@@ -45,7 +45,7 @@ run (const char *resource_name_p, /**< resource name */
                                     (const jerry_char_t *) source_p,
                                     strlen (source_p),
                                     JERRY_PARSE_NO_OPTS);
-  TEST_ASSERT (!jerry_value_has_error_flag (code));
+  TEST_ASSERT (!jerry_value_is_error (code));
 
   jerry_value_t result = jerry_run (code);
   jerry_release_value (code);
@@ -66,7 +66,7 @@ compare (jerry_value_t array, /**< array */
 
   jerry_value_t value = jerry_get_property_by_index (array, index);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (value)
+  TEST_ASSERT (!jerry_value_is_error (value)
                && jerry_value_is_string (value));
 
   TEST_ASSERT (jerry_get_string_size (value) == len);
@@ -93,7 +93,7 @@ main (void)
   jerry_value_t func = jerry_create_external_function (backtrace_handler);
   jerry_value_t name = jerry_create_string ((const jerry_char_t *) "backtrace");
   jerry_value_t result = jerry_set_property (global, name, func);
-  TEST_ASSERT (!jerry_value_has_error_flag (result));
+  TEST_ASSERT (!jerry_value_is_error (result));
 
   jerry_release_value (result);
   jerry_release_value (name);
@@ -117,7 +117,7 @@ main (void)
 
   jerry_value_t backtrace = run ("something.js", source);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (backtrace)
+  TEST_ASSERT (!jerry_value_is_error (backtrace)
                && jerry_value_is_array (backtrace));
 
   TEST_ASSERT (jerry_get_array_length (backtrace) == 4);
@@ -147,7 +147,7 @@ main (void)
 
   backtrace = run ("something_else.js", source);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (backtrace)
+  TEST_ASSERT (!jerry_value_is_error (backtrace)
                && jerry_value_is_array (backtrace));
 
   TEST_ASSERT (jerry_get_array_length (backtrace) == 2);
@@ -173,7 +173,7 @@ main (void)
 
   jerry_value_t error = run ("bad.js", source);
 
-  TEST_ASSERT (jerry_value_has_error_flag (error));
+  TEST_ASSERT (jerry_value_is_error (error));
 
   jerry_value_clear_error_flag (&error);
 
@@ -185,7 +185,7 @@ main (void)
   jerry_release_value (name);
   jerry_release_value (error);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (backtrace)
+  TEST_ASSERT (!jerry_value_is_error (backtrace)
                && jerry_value_is_array (backtrace));
 
   TEST_ASSERT (jerry_get_array_length (backtrace) == 3);

tests/unit-core/test-exec-stop.c

@@ -56,11 +56,11 @@ main (void)
                                                strlen (inf_loop_code_src_p),
                                                JERRY_PARSE_NO_OPTS);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (parsed_code_val));
+  TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
   jerry_value_t res = jerry_run (parsed_code_val);
   TEST_ASSERT (countdown == 0);
 
-  TEST_ASSERT (jerry_value_has_error_flag (res));
+  TEST_ASSERT (jerry_value_is_error (res));
 
   jerry_release_value (res);
   jerry_release_value (parsed_code_val);
@@ -80,13 +80,13 @@ main (void)
                                  strlen (inf_loop_code_src_p),
                                  JERRY_PARSE_NO_OPTS);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (parsed_code_val));
+  TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
   res = jerry_run (parsed_code_val);
   TEST_ASSERT (countdown == 0);
 
   /* The result must have an error flag which proves that
    * the error is thrown again inside the catch block. */
-  TEST_ASSERT (jerry_value_has_error_flag (res));
+  TEST_ASSERT (jerry_value_is_error (res));
 
   jerry_release_value (res);
   jerry_release_value (parsed_code_val);

tests/unit-core/test-mem-stats.c

@@ -35,10 +35,10 @@ int main (void)
                                                (jerry_char_t *) test_source,
                                                strlen (test_source),
                                                JERRY_PARSE_NO_OPTS);
-  TEST_ASSERT (!jerry_value_has_error_flag (parsed_code_val));
+  TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
 
   jerry_value_t res = jerry_run (parsed_code_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
 
   jerry_heap_stats_t stats;
   memset (&stats, 0, sizeof (stats));

tests/unit-core/test-objects-foreach.c

@@ -50,7 +50,7 @@ find_test_object_by_property (const jerry_value_t candidate,
   jerry_value_t *args_p = (jerry_value_t *) context_p;
   jerry_value_t result = jerry_has_property (candidate, args_p[0]);
 
-  bool has_property = (!jerry_value_has_error_flag (result) && jerry_get_boolean_value (result));
+  bool has_property = (!jerry_value_is_error (result) && jerry_get_boolean_value (result));
 
   /* If the object has the desired property, store a new reference to it in args_p[1]. */
   if (has_property)
@@ -75,9 +75,9 @@ main (void)
                                             (jerry_char_t *) strict_equal_source,
                                             strlen (strict_equal_source),
                                             JERRY_PARSE_STRICT_MODE);
-  TEST_ASSERT (!jerry_value_has_error_flag (parse_result));
+  TEST_ASSERT (!jerry_value_is_error (parse_result));
   jerry_value_t strict_equal = jerry_run (parse_result);
-  TEST_ASSERT (!jerry_value_has_error_flag (strict_equal));
+  TEST_ASSERT (!jerry_value_is_error (strict_equal));
   jerry_release_value (parse_result);
 
   /* Create an object and associate some native data with it. */

tests/unit-core/test-promise.c

@@ -153,10 +153,10 @@ main (void)
                                                (jerry_char_t *) test_source,
                                                strlen (test_source),
                                                JERRY_PARSE_NO_OPTS);
-  TEST_ASSERT (!jerry_value_has_error_flag (parsed_code_val));
+  TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
 
   jerry_value_t res = jerry_run (parsed_code_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
 
   jerry_release_value (res);
   jerry_release_value (parsed_code_val);
@@ -181,7 +181,7 @@ main (void)
   /* Run the jobqueue. */
   res = jerry_run_all_enqueued_jobs ();
 
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (count_in_assert == 2);
 
   jerry_release_value (my_promise1);

tests/unit-core/test-snapshot.c

@@ -72,7 +72,7 @@ static void test_function_snapshot (void)
                                                       0,
                                                       function_snapshot_buffer,
                                                       SNAPSHOT_BUFFER_SIZE);
-  TEST_ASSERT (!jerry_value_has_error_flag (generate_result)
+  TEST_ASSERT (!jerry_value_is_error (generate_result)
                && jerry_value_is_number (generate_result));
 
   size_t function_snapshot_size = (size_t) jerry_get_number_value (generate_result);
@@ -87,7 +87,7 @@ static void test_function_snapshot (void)
                                                              0,
                                                              0);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (function_obj));
+  TEST_ASSERT (!jerry_value_is_error (function_obj));
   TEST_ASSERT (jerry_value_is_function (function_obj));
 
   jerry_value_t this_val = jerry_create_undefined ();
@@ -97,7 +97,7 @@ static void test_function_snapshot (void)
 
   jerry_value_t res = jerry_call_function (function_obj, this_val, args, 2);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_number (res));
   double num = jerry_get_number_value (res);
   TEST_ASSERT (num == 3);
@@ -114,7 +114,7 @@ static void arguments_test_exec_snapshot (uint32_t *snapshot_p, size_t snapshot_
 {
   jerry_init (JERRY_INIT_EMPTY);
   jerry_value_t res = jerry_exec_snapshot (snapshot_p, snapshot_size, 0, exec_snapshot_flags);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_number (res));
   double raw_value = jerry_get_number_value (res);
   TEST_ASSERT (raw_value == 15);
@@ -148,7 +148,7 @@ static void test_function_arguments_snapshot (void)
                                                arguments_snapshot_buffer,
                                                SNAPSHOT_BUFFER_SIZE);
 
-    TEST_ASSERT (!jerry_value_has_error_flag (generate_result)
+    TEST_ASSERT (!jerry_value_is_error (generate_result)
                  && jerry_value_is_number (generate_result));
 
     size_t snapshot_size = (size_t) jerry_get_number_value (generate_result);
@@ -173,7 +173,7 @@ static void test_exec_snapshot (uint32_t *snapshot_p, size_t snapshot_size, uint
 
   jerry_value_t res = jerry_exec_snapshot (snapshot_p, snapshot_size, 0, exec_snapshot_flags);
 
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_string (res));
   jerry_size_t sz = jerry_get_string_size (res);
   TEST_ASSERT (sz == 20);
@@ -207,7 +207,7 @@ main (void)
                                                0,
                                                snapshot_buffer,
                                                SNAPSHOT_BUFFER_SIZE);
-    TEST_ASSERT (!jerry_value_has_error_flag (generate_result)
+    TEST_ASSERT (!jerry_value_is_error (generate_result)
                  && jerry_value_is_number (generate_result));
 
     size_t snapshot_size = (size_t) jerry_get_number_value (generate_result);
@@ -261,7 +261,7 @@ main (void)
                                                JERRY_SNAPSHOT_SAVE_STATIC,
                                                snapshot_buffer,
                                                SNAPSHOT_BUFFER_SIZE);
-    TEST_ASSERT (!jerry_value_has_error_flag (generate_result)
+    TEST_ASSERT (!jerry_value_is_error (generate_result)
                  && jerry_value_is_number (generate_result));
 
     size_t snapshot_size = (size_t) jerry_get_number_value (generate_result);
@@ -269,7 +269,7 @@ main (void)
 
     /* Static snapshots are not supported by default. */
     jerry_value_t exec_result = jerry_exec_snapshot (snapshot_buffer, snapshot_size, 0, 0);
-    TEST_ASSERT (jerry_value_has_error_flag (exec_result));
+    TEST_ASSERT (jerry_value_is_error (exec_result));
     jerry_release_value (exec_result);
 
     jerry_cleanup ();
@@ -297,7 +297,7 @@ main (void)
                                                0,
                                                snapshot_buffer_0,
                                                SNAPSHOT_BUFFER_SIZE);
-    TEST_ASSERT (!jerry_value_has_error_flag (generate_result)
+    TEST_ASSERT (!jerry_value_is_error (generate_result)
                  && jerry_value_is_number (generate_result));
 
     snapshot_sizes[0] = (size_t) jerry_get_number_value (generate_result);
@@ -315,7 +315,7 @@ main (void)
                                                0,
                                                snapshot_buffer_1,
                                                SNAPSHOT_BUFFER_SIZE);
-    TEST_ASSERT (!jerry_value_has_error_flag (generate_result)
+    TEST_ASSERT (!jerry_value_is_error (generate_result)
                  && jerry_value_is_number (generate_result));
 
     snapshot_sizes[1] = (size_t) jerry_get_number_value (generate_result);
@@ -344,12 +344,12 @@ main (void)
     jerry_init (JERRY_INIT_EMPTY);
 
     jerry_value_t res = jerry_exec_snapshot (merged_snapshot_buffer, merged_size, 0, 0);
-    TEST_ASSERT (!jerry_value_has_error_flag (res));
+    TEST_ASSERT (!jerry_value_is_error (res));
     TEST_ASSERT (jerry_get_number_value (res) == 123);
     jerry_release_value (res);
 
     res = jerry_exec_snapshot (merged_snapshot_buffer, merged_size, 1, 0);
-    TEST_ASSERT (!jerry_value_has_error_flag (res));
+    TEST_ASSERT (!jerry_value_is_error (res));
     TEST_ASSERT (jerry_get_number_value (res) == 456);
     jerry_release_value (res);
 

tests/unit-core/test-typedarray.c

@@ -108,7 +108,7 @@ test_typedarray_info (jerry_value_t typedarray, /**< target TypedArray to query
                       jerry_length_t element_count, /**< expected element count */
                       jerry_length_t bytes_per_element) /**< bytes per element for the given type */
 {
-  TEST_ASSERT (!jerry_value_has_error_flag (typedarray));
+  TEST_ASSERT (!jerry_value_is_error (typedarray));
   TEST_ASSERT (jerry_value_is_typedarray (typedarray));
   TEST_ASSERT (jerry_get_typedarray_type (typedarray) == typedarray_type);
   TEST_ASSERT (jerry_get_typedarray_length (typedarray) == element_count);
@@ -138,7 +138,7 @@ test_typedarray_queries (test_entry_t test_entries[]) /**< test cases */
     {
       jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) test_entries[i].constructor_name);
       jerry_value_t prop_value = jerry_get_property (global_obj_val, prop_name);
-      TEST_ASSERT (!jerry_value_has_error_flag (prop_value));
+      TEST_ASSERT (!jerry_value_is_error (prop_value));
       jerry_value_t length_arg = jerry_create_number (test_entries[i].element_count);
 
       jerry_value_t typedarray = jerry_construct_object (prop_value, &length_arg, 1);
@@ -256,7 +256,7 @@ test_typedarray_complex_creation (test_entry_t test_entries[], /**< test cases *
                                                                arraybuffer,
                                                                offset,
                                                                element_count);
-      TEST_ASSERT (!jerry_value_has_error_flag (typedarray));
+      TEST_ASSERT (!jerry_value_is_error (typedarray));
 
       jerry_release_value (js_offset);
       jerry_release_value (js_element_count);
@@ -273,7 +273,7 @@ test_typedarray_complex_creation (test_entry_t test_entries[], /**< test cases *
     jerry_value_t result = jerry_eval ((jerry_char_t *) eval_src_p,
                                        strlen (eval_src_p),
                                        true);
-    TEST_ASSERT (!jerry_value_has_error_flag (result));
+    TEST_ASSERT (!jerry_value_is_error (result));
     jerry_release_value (result);
 
     {
@@ -385,7 +385,7 @@ main (void)
                                        strlen (eval_src_p),
                                        true);
 
-    TEST_ASSERT (!jerry_value_has_error_flag (result));
+    TEST_ASSERT (!jerry_value_is_error (result));
     jerry_release_value (result);
 
     /* Check write results */
@@ -451,7 +451,7 @@ main (void)
         jerry_length_t offset = 22;
         jerry_length_t byte_count = 23;
         jerry_value_t error = jerry_get_typedarray_buffer (values[idx], &offset, &byte_count);
-        TEST_ASSERT (jerry_value_has_error_flag (error));
+        TEST_ASSERT (jerry_value_is_error (error));
         TEST_ASSERT (offset == 22);
         TEST_ASSERT (byte_count == 23);
         jerry_release_value (error);
@@ -463,7 +463,7 @@ main (void)
       if (!jerry_value_is_arraybuffer (values[idx]))
       {
         jerry_value_t error = jerry_create_typedarray_for_arraybuffer (JERRY_TYPEDARRAY_UINT8, values[idx]);
-        TEST_ASSERT (jerry_value_has_error_flag (error));
+        TEST_ASSERT (jerry_value_is_error (error));
         jerry_release_value (error);
       }
 

tests/unit-ext/module/jerry-module-test.c

@@ -140,7 +140,7 @@ handle_require (const jerry_value_t js_function,
 static void
 assert_number (jerry_value_t js_value, double expected_result)
 {
-  TEST_ASSERT (!jerry_value_has_error_flag (js_value));
+  TEST_ASSERT (!jerry_value_is_error (js_value));
   TEST_ASSERT (jerry_get_number_value (js_value) == expected_result);
 } /* assert_number */
 

tests/unit-ext/test-ext-arg.c

@@ -133,7 +133,7 @@ test_validator1_handler (const jerry_value_t func_obj_val __attribute__((unused)
 
   if (validator1_count == 0)
   {
-    TEST_ASSERT (!jerry_value_has_error_flag (is_ok));
+    TEST_ASSERT (!jerry_value_is_error (is_ok));
     TEST_ASSERT (arg1);
     TEST_ASSERT (arg2 == 10.5);
     TEST_ASSERT (strcmp (arg3, "abc") == 0);
@@ -141,7 +141,7 @@ test_validator1_handler (const jerry_value_t func_obj_val __attribute__((unused)
   }
   else if (validator1_count == 1)
   {
-    TEST_ASSERT (!jerry_value_has_error_flag (is_ok));
+    TEST_ASSERT (!jerry_value_is_error (is_ok));
     TEST_ASSERT (arg1);
     TEST_ASSERT (arg2 == 10.5);
     TEST_ASSERT (strcmp (arg3, "abc") == 0);
@@ -149,7 +149,7 @@ test_validator1_handler (const jerry_value_t func_obj_val __attribute__((unused)
   }
   else if (validator1_count == 2)
   {
-    TEST_ASSERT (!jerry_value_has_error_flag (is_ok));
+    TEST_ASSERT (!jerry_value_is_error (is_ok));
     TEST_ASSERT (arg1);
     TEST_ASSERT (arg2 == 10.5);
     TEST_ASSERT (strcmp (arg3, "") == 0);
@@ -157,7 +157,7 @@ test_validator1_handler (const jerry_value_t func_obj_val __attribute__((unused)
   }
   else
   {
-    TEST_ASSERT (jerry_value_has_error_flag (is_ok));
+    TEST_ASSERT (jerry_value_is_error (is_ok));
   }
 
   jerry_release_value (is_ok);
@@ -177,7 +177,7 @@ my_custom_transform (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< available JS
   jerry_value_t js_arg = jerryx_arg_js_iterator_pop (js_arg_iter_p);
   jerry_value_t to_number = jerry_value_to_number (js_arg);
 
-  if (jerry_value_has_error_flag (to_number))
+  if (jerry_value_is_error (to_number))
   {
     jerry_release_value (to_number);
 
@@ -226,13 +226,13 @@ test_validator2_handler (const jerry_value_t func_obj_val __attribute__((unused)
 
   if (validator2_count == 0)
   {
-    TEST_ASSERT (!jerry_value_has_error_flag (is_ok));
+    TEST_ASSERT (!jerry_value_is_error (is_ok));
     TEST_ASSERT (thing_p == &my_thing_a);
     TEST_ASSERT (thing_p->x == 1);
   }
   else
   {
-    TEST_ASSERT (jerry_value_has_error_flag (is_ok));
+    TEST_ASSERT (jerry_value_is_error (is_ok));
   }
 
   jerry_release_value (is_ok);
@@ -269,7 +269,7 @@ test_validator_prop1_handler (const jerry_value_t func_obj_val __attribute__((un
                                                                 mapping,
                                                                 ARRAY_SIZE (mapping));
 
-  TEST_ASSERT (!jerry_value_has_error_flag (is_ok));
+  TEST_ASSERT (!jerry_value_is_error (is_ok));
   TEST_ASSERT (native1);
   TEST_ASSERT (native2 == 1.5);
   TEST_ASSERT (native3 == 3);
@@ -317,7 +317,7 @@ test_validator_prop2_handler (const jerry_value_t func_obj_val __attribute__((un
   jerry_value_t is_ok = jerryx_arg_transform_args (args_p, args_cnt, mapping, ARRAY_SIZE (mapping));
 
 
-  TEST_ASSERT (!jerry_value_has_error_flag (is_ok));
+  TEST_ASSERT (!jerry_value_is_error (is_ok));
 
   if (validator_prop_count == 1)
   {
@@ -354,7 +354,7 @@ test_validator_prop3_handler (const jerry_value_t func_obj_val __attribute__((un
                                                                 mapping,
                                                                 ARRAY_SIZE (mapping));
 
-  TEST_ASSERT (jerry_value_has_error_flag (is_ok));
+  TEST_ASSERT (jerry_value_is_error (is_ok));
   TEST_ASSERT (!native1);
   TEST_ASSERT (native2);
 
@@ -399,7 +399,7 @@ test_validator_int1_handler (const jerry_value_t func_obj_val __attribute__((unu
                                                    mapping,
                                                    ARRAY_SIZE (mapping));
 
-  TEST_ASSERT (!jerry_value_has_error_flag (is_ok));
+  TEST_ASSERT (!jerry_value_is_error (is_ok));
   TEST_ASSERT (num0 == 0);
   TEST_ASSERT (num1 == 255);
   TEST_ASSERT (num2 == 128);
@@ -448,7 +448,7 @@ test_validator_int2_handler (const jerry_value_t func_obj_val __attribute__((unu
                                                    mapping,
                                                    ARRAY_SIZE (mapping));
 
-  TEST_ASSERT (jerry_value_has_error_flag (is_ok));
+  TEST_ASSERT (jerry_value_is_error (is_ok));
   TEST_ASSERT (num0 == -2);
   TEST_ASSERT (num1 == -2);
   TEST_ASSERT (num2 == -1);
@@ -484,7 +484,7 @@ test_validator_int3_handler (const jerry_value_t func_obj_val __attribute__((unu
                                                    mapping,
                                                    ARRAY_SIZE (mapping));
 
-  TEST_ASSERT (jerry_value_has_error_flag (is_ok));
+  TEST_ASSERT (jerry_value_is_error (is_ok));
 
   jerry_release_value (is_ok);
   validator_int_count++;
@@ -522,7 +522,7 @@ test_validator_array1_handler (const jerry_value_t func_obj_val __attribute__((u
   jerry_value_t is_ok = jerryx_arg_transform_args (args_p, args_cnt, mapping, ARRAY_SIZE (mapping));
 
 
-  TEST_ASSERT (!jerry_value_has_error_flag (is_ok));
+  TEST_ASSERT (!jerry_value_is_error (is_ok));
 
   if (validator_array_count == 0)
   {
@@ -553,7 +553,7 @@ test_validator_array2_handler (const jerry_value_t func_obj_val __attribute__((u
 
   jerry_value_t is_ok = jerryx_arg_transform_array (args_p[0], item_mapping, ARRAY_SIZE (item_mapping));
 
-  TEST_ASSERT (jerry_value_has_error_flag (is_ok));
+  TEST_ASSERT (jerry_value_is_error (is_ok));
   TEST_ASSERT (native1 == 1);
   TEST_ASSERT (!native2);
 
@@ -582,7 +582,7 @@ test_utf8_string (void)
                                                    mapping,
                                                    ARRAY_SIZE (mapping));
 
-  TEST_ASSERT (!jerry_value_has_error_flag (is_ok));
+  TEST_ASSERT (!jerry_value_is_error (is_ok));
   TEST_ASSERT (!strcmp (buf, expect_utf8_buf));
 
   jerry_release_value (str);
@@ -665,10 +665,10 @@ main (void)
                                                (jerry_char_t *) test_source,
                                                strlen (test_source),
                                                JERRY_PARSE_NO_OPTS);
-  TEST_ASSERT (!jerry_value_has_error_flag (parsed_code_val));
+  TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
 
   jerry_value_t res = jerry_run (parsed_code_val);
-  TEST_ASSERT (!jerry_value_has_error_flag (res));
+  TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (validator1_count == 5);
   TEST_ASSERT (validator2_count == 3);
   TEST_ASSERT (validator_prop_count == 4);

tests/unit-ext/test-ext-module-empty.c

@@ -36,7 +36,7 @@ main (int argc, char **argv)
   jerry_value_t module = jerryx_module_resolve (module_name, &resolver, 1);
   jerry_release_value (module_name);
 
-  TEST_ASSERT (jerry_value_has_error_flag (module));
+  TEST_ASSERT (jerry_value_is_error (module));
 
   /* Retrieve the error message. */
   jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "message");