Remove jerry_get_boolean_value (#4685)

JerryScript-DCO-1.0-Signed-off-by: Gergo Csizi csgergo92@gmail.com

docs/02.API-REFERENCE.md

@@ -3223,7 +3223,7 @@ jerry_binary_operation (jerry_binary_operation_t op,
 
   if (!jerry_value_is_error (result))
   {
-    if (jerry_get_boolean_value (result))
+    if (jerry_value_is_true (result))
     {
        // value1 and value2 are equal
     }
@@ -3279,7 +3279,7 @@ main (void)
                                                       instance_val,
                                                       constructor);
   if (!jerry_value_is_error (is_instance)
-      && jerry_get_boolean_value (is_instance) == true)
+      && jerry_value_is_true (is_instance))
   {
     /* ... */
   }
@@ -3591,48 +3591,6 @@ void main(void)
 
 Get raw data from API values.
 
-## jerry_get_boolean_value
-
-**Summary**
-
-Gets the raw bool value from a `jerry_value_t`.
-
-**Prototype**
-
-```c
-bool
-jerry_get_boolean_value (const jerry_value_t value);
-```
-
-- `value` - api value
-- return value - boolean value represented by the argument.
-
-**Example**
-
-```c
-{
-  jerry_value_t value;
-  ... // create or acquire value
-
-  if (jerry_value_is_boolean (value))
-  {
-    bool raw_value = jerry_get_boolean_value (value);
-
-    ... // usage of raw value
-
-  }
-
-  jerry_release_value (value);
-}
-
-```
-
-**See also**
-
-- [jerry_value_is_boolean](#jerry_value_is_boolean)
-- [jerry_release_value](#jerry_release_value)
-
-
 ## jerry_get_number_value
 
 **Summary**
@@ -7628,7 +7586,7 @@ main (void)
   jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "handler_field");
 
   jerry_value_t has_prop_js = jerry_has_property (global_object, prop_name);
-  bool has_prop = jerry_get_boolean_value (has_prop_js);
+  bool has_prop = jerry_value_is_true (has_prop_js);
 
   jerry_release_value (has_prop_js);
   jerry_release_value (prop_name);
@@ -7689,7 +7647,7 @@ main (void)
   jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "handler_field");
 
   jerry_value_t has_prop_js = jerry_has_own_property (global_object, prop_name);
-  bool has_prop = jerry_get_boolean_value (has_prop_js);
+  bool has_prop = jerry_value_is_true (has_prop_js);
 
   jerry_release_value (has_prop_js);
   jerry_release_value (prop_name);
@@ -9540,7 +9498,7 @@ find_my_object (const jerry_value_t candidate,
 
   /* Check if the given object has the required property. */
   jerry_value_t has_property = jerry_has_property (candidate, info_p->property_name);
-  bool object_found = jerry_get_boolean_value (has_property);
+  bool object_found = jerry_value_is_true (has_property);
 
   if (object_found)
   {
@@ -11633,7 +11591,7 @@ jerry_is_arraybuffer_detachable (const jerry_value_t value);
   jerry_value_t buffer = jerry_create_arraybuffer (16);
 
   jerry_value_t res = jerry_is_arraybuffer_detachable (buffer);
-  bool is_detachable = jerry_get_boolean_value (res);
+  bool is_detachable = jerry_value_is_true (res);
 
   // release buffer as it is not needed after this point
   jerry_release_value (res);

docs/03.API-EXAMPLE.md

@@ -615,7 +615,7 @@ print_value (const jerry_value_t jsvalue)
   }
   else if (jerry_value_is_boolean (value))
   {
-    if (jerry_get_boolean_value (value))
+    if (jerry_value_is_true (value))
     {
       printf ("true");
     }
@@ -709,7 +709,7 @@ print_value (const jerry_value_t jsvalue)
   }
   else if (jerry_value_is_boolean (value))
   {
-    if (jerry_get_boolean_value (value))
+    if (jerry_value_is_true (value))
     {
       printf ("true");
     }

jerry-core/api/jerry.c

@@ -2066,19 +2066,6 @@ jerry_get_error_type (jerry_value_t value) /**< api value */
   return (jerry_error_t) error_type;
 } /* jerry_get_error_type */
 
-/**
- * Get boolean from the specified value.
- *
- * @return true or false.
- */
-bool
-jerry_get_boolean_value (const jerry_value_t value) /**< api value */
-{
-  jerry_assert_api_available ();
-
-  return ecma_is_value_true (value);
-} /* jerry_get_boolean_value */
-
 /**
  * Get number from the specified value as a double.
  *

jerry-core/include/jerryscript-core.h

@@ -114,7 +114,6 @@ jerry_error_t jerry_get_error_type (jerry_value_t value);
 /**
  * Getter functions of 'jerry_value_t'.
  */
-bool jerry_get_boolean_value (const jerry_value_t value);
 double jerry_get_number_value (const jerry_value_t value);
 
 /**

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

@@ -228,7 +228,7 @@ jerryx_arg_transform_boolean_strict (jerryx_arg_js_iterator_t *js_arg_iter_p, /*
   }
 
   bool *dest = c_arg_p->dest;
-  *dest = jerry_get_boolean_value (js_arg);
+  *dest = jerry_value_is_true (js_arg);
 
   return jerry_create_undefined ();
 } /* jerryx_arg_transform_boolean_strict */

jerry-ext/handler/handler-assert.c

@@ -36,8 +36,7 @@ jerryx_handler_assert_fatal (const jerry_call_info_t *call_info_p, /**< call inf
   (void) call_info_p; /* unused */
 
   if (args_cnt == 1
-      && jerry_value_is_boolean (args_p[0])
+      && jerry_value_is_true (args_p[0]))
-      && jerry_get_boolean_value (args_p[0]))
   {
     return jerry_create_boolean (true);
   }
@@ -105,8 +104,7 @@ jerryx_handler_assert_throw (const jerry_call_info_t *call_info_p, /**< call inf
   (void) call_info_p; /* unused */
 
   if (args_cnt == 1
-      && jerry_value_is_boolean (args_p[0])
+      && jerry_value_is_true (args_p[0]))
-      && jerry_get_boolean_value (args_p[0]))
   {
     return jerry_create_boolean (true);
   }

jerry-ext/handler/handler-register.c

@@ -185,7 +185,7 @@ jerryx_has_property_str (const jerry_value_t target_object, /**< target object *
 
   if (!jerry_value_is_error (has_prop_val))
   {
-    has_property = jerry_get_boolean_value (has_prop_val);
+    has_property = jerry_value_is_true (has_prop_val);
   }
 
   jerry_release_value (has_prop_val);

jerry-ext/module/module.c

@@ -122,7 +122,7 @@ jerryx_module_check_cache (jerry_value_t cache, /**< cache from which to attempt
   /* If we succeed in getting an answer, we examine the answer. */
   if (!jerry_value_is_error (js_has_property))
   {
-    bool has_property = jerry_get_boolean_value (js_has_property);
+    bool has_property = jerry_value_is_true (js_has_property);
 
     /* If the module is indeed in the cache, we return it. */
     if (has_property)

targets/esp8266/user/jerry_extapi.c

@@ -35,8 +35,7 @@ NAME ## _handler (const jerry_call_info_t *call_info_p __UNUSED__, \
 
 DELCARE_HANDLER(assert) {
   if (args_cnt == 1
-      && jerry_value_is_boolean (args_p[0])
+      && jerry_value_is_true (args_p[0]))
-      && jerry_get_boolean_value (args_p[0]))
   {
     printf (">> Jerry assert true\r\n");
     return jerry_create_boolean (true);

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

@@ -131,7 +131,7 @@ DECLARE_CLASS_FUNCTION(I2C, read) {
 
         bool repeated = false;
         if (args_count == 4) {
-            repeated = jerry_get_boolean_value(args[3]);
+            repeated = jerry_value_is_true(args[3]);
         }
 
         int result = native_ptr->read(address, data, length, repeated);
@@ -223,7 +223,7 @@ DECLARE_CLASS_FUNCTION(I2C, write) {
         int address = jerry_get_number_value(args[0]);
         const uint32_t data_len = jerry_get_array_length(args[1]);
         int length = jerry_get_number_value(args[2]);
-        bool repeated = args_count == 4 && jerry_get_boolean_value(args[3]);
+        bool repeated = args_count == 4 && jerry_value_is_true(args[3]);
 
         // Construct data byte array
         char *data = new char[data_len];

targets/particle/source/main.cpp

@@ -34,7 +34,7 @@ set_led  (const jerry_value_t func_value, /**< function object */
   }
 
   int ledPin = jerry_get_number_value (args_p[0]);
-  bool value = jerry_get_boolean_value (args_p[1]);
+  bool value = jerry_value_is_true (args_p[1]);
 
   pinMode (ledPin, OUTPUT);
   digitalWrite (ledPin, value);

tests/unit-core/test-api-binary-operations-arithmetics.c

@@ -230,7 +230,7 @@ main (void)
     TEST_ASSERT (!jerry_value_is_error (result));
 
     jerry_value_t equals = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, result, tests[idx].expected);
-    TEST_ASSERT (jerry_value_is_boolean (equals) && jerry_get_boolean_value (equals));
+    TEST_ASSERT (jerry_value_is_boolean (equals) && jerry_value_is_true (equals));
     jerry_release_value (equals);
 
     jerry_release_value (tests[idx].lhs);

tests/unit-core/test-api-binary-operations-comparisons.c

@@ -266,7 +266,7 @@ main (void)
   {
     jerry_value_t result = jerry_binary_operation (tests[idx].op, tests[idx].lhs, tests[idx].rhs);
     TEST_ASSERT (!jerry_value_is_error (result));
-    TEST_ASSERT (jerry_get_boolean_value (result) == tests[idx].expected);
+    TEST_ASSERT (jerry_value_is_true (result) == tests[idx].expected);
     jerry_release_value (tests[idx].lhs);
     jerry_release_value (tests[idx].rhs);
     jerry_release_value (result);

tests/unit-core/test-api-binary-operations-instanceof.c

@@ -73,7 +73,7 @@ main (void)
                                                    bool_tests[idx].lhs,
                                                    bool_tests[idx].rhs);
     TEST_ASSERT (!jerry_value_is_error (result));
-    TEST_ASSERT (jerry_get_boolean_value (result) == bool_tests[idx].expected);
+    TEST_ASSERT (jerry_value_is_true (result) == bool_tests[idx].expected);
     jerry_release_value (bool_tests[idx].lhs);
     jerry_release_value (bool_tests[idx].rhs);
     jerry_release_value (result);

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

@@ -38,7 +38,7 @@ test_promise_resolve_success (void)
   {
     jerry_value_t obj_key = jerry_create_string ((const jerry_char_t *) "key_one");
     jerry_value_t set_result = jerry_set_property (resolve_value, obj_key, jerry_create_number (3));
-    TEST_ASSERT (jerry_value_is_boolean (set_result) && (jerry_get_boolean_value (set_result) == true));
+    TEST_ASSERT (jerry_value_is_boolean (set_result) && (jerry_value_is_true (set_result)));
     jerry_release_value (set_result);
     jerry_release_value (obj_key);
   }

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

@@ -37,7 +37,7 @@ main (void)
   prop_desc.flags |= JERRY_PROP_IS_VALUE_DEFINED;
   prop_desc.value = jerry_acquire_value (prop_name);
   jerry_value_t res = jerry_define_own_property (global_obj_val, prop_name, &prop_desc);
-  TEST_ASSERT (jerry_value_is_boolean (res) && jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_boolean (res) && jerry_value_is_true (res));
   jerry_release_value (res);
   jerry_property_descriptor_free (&prop_desc);
 
@@ -54,17 +54,17 @@ main (void)
   prop_desc = jerry_property_descriptor_create ();
   prop_desc.flags |= JERRY_PROP_IS_VALUE_DEFINED | JERRY_PROP_IS_GET_DEFINED;
   res = jerry_define_own_property (prop_name, prop_name, &prop_desc);
-  TEST_ASSERT (jerry_value_is_boolean (res) && !jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_boolean (res) && !jerry_value_is_true (res));
   jerry_release_value (res);
   res = jerry_define_own_property (global_obj_val, prop_name, &prop_desc);
-  TEST_ASSERT (jerry_value_is_boolean (res) && !jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_boolean (res) && !jerry_value_is_true (res));
   jerry_release_value (res);
   jerry_property_descriptor_free (&prop_desc);
 
   /* Test: get own property descriptor */
   prop_desc = jerry_property_descriptor_create ();
   jerry_value_t is_ok = jerry_get_own_property_descriptor (global_obj_val, prop_name, &prop_desc);
-  TEST_ASSERT (jerry_value_is_boolean (is_ok) && jerry_get_boolean_value (is_ok));
+  TEST_ASSERT (jerry_value_is_boolean (is_ok) && jerry_value_is_true (is_ok));
   jerry_release_value (is_ok);
   TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_VALUE_DEFINED);
   TEST_ASSERT (jerry_value_is_string (prop_desc.value));
@@ -87,7 +87,7 @@ main (void)
     jerry_release_value (target);
     jerry_release_value (handler);
     is_ok = jerry_get_own_property_descriptor (proxy, prop_name, &prop_desc);
-    TEST_ASSERT (jerry_value_is_boolean (is_ok) && !jerry_get_boolean_value (is_ok));
+    TEST_ASSERT (jerry_value_is_boolean (is_ok) && !jerry_value_is_true (is_ok));
     jerry_release_value (is_ok);
     jerry_release_value (proxy);
   }
@@ -100,11 +100,11 @@ main (void)
   res = jerry_define_own_property (global_obj_val, prop_name, &prop_desc);
   TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_boolean (res));
-  TEST_ASSERT (jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_true (res));
   jerry_release_value (res);
   jerry_property_descriptor_free (&prop_desc);
   is_ok = jerry_get_own_property_descriptor (global_obj_val, prop_name, &prop_desc);
-  TEST_ASSERT (jerry_value_is_boolean (is_ok) && jerry_get_boolean_value (is_ok));
+  TEST_ASSERT (jerry_value_is_boolean (is_ok) && jerry_value_is_true (is_ok));
   jerry_release_value (is_ok);
   TEST_ASSERT (!(prop_desc.flags & JERRY_PROP_IS_WRITABLE));
   TEST_ASSERT (prop_desc.flags & JERRY_PROP_IS_ENUMERABLE);

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

@@ -28,7 +28,7 @@ strict_equals (jerry_value_t a, /**< the first string to compare */
   jerry_value_t res = jerry_call_function (is_equal_fn_val, jerry_create_undefined (), args, 2);
   TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_boolean (res));
-  bool is_strict_equal = jerry_get_boolean_value (res);
+  bool is_strict_equal = jerry_value_is_true (res);
   jerry_release_value (res);
   jerry_release_value (is_equal_fn_val);
   return is_strict_equal;

tests/unit-core/test-api.c

@@ -162,15 +162,13 @@ handler_construct (const jerry_call_info_t *call_info_p, /**< call information *
 
   TEST_ASSERT (args_cnt == 1);
   TEST_ASSERT (jerry_value_is_boolean (args_p[0]));
-  TEST_ASSERT (jerry_get_boolean_value (args_p[0]) == true);
-
   TEST_ASSERT (jerry_value_is_true (args_p[0]));
 
   jerry_value_t this_value = call_info_p->this_value;
   jerry_value_t field_name = jerry_create_string ((jerry_char_t *) "value_field");
   jerry_value_t res = jerry_set_property (this_value, field_name, args_p[0]);
   TEST_ASSERT (!jerry_value_is_error (res));
-  TEST_ASSERT (jerry_value_is_boolean (res) && jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_true (res));
   jerry_release_value (res);
   jerry_release_value (field_name);
 
@@ -258,7 +256,7 @@ foreach (const jerry_value_t name, /**< field name */
   else if (!strncmp (str_buf_p, "bravo", (size_t) sz))
   {
     TEST_ASSERT (jerry_value_is_boolean (value));
-    TEST_ASSERT (jerry_get_boolean_value (value) == false);
+    TEST_ASSERT (jerry_value_is_true (value) == false);
     TEST_ASSERT (jerry_value_is_false (value));
     return true;
   }
@@ -468,7 +466,7 @@ main (void)
   args[0] = jerry_create_string ((jerry_char_t *) "abcd");
   res = set_property (global_obj_val, "t", args[0]);
   TEST_ASSERT (!jerry_value_is_error (res));
-  TEST_ASSERT (jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_true (res));
   jerry_release_value (res);
 
   /* Call foo (4, 2) */
@@ -500,7 +498,7 @@ main (void)
   /* Set A.prototype.foo = global.foo */
   res = set_property (val_A_prototype, "foo", val_foo);
   TEST_ASSERT (!jerry_value_is_error (res));
-  TEST_ASSERT (jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_true (res));
   jerry_release_value (res);
   jerry_release_value (val_A_prototype);
   jerry_release_value (val_foo);
@@ -557,7 +555,7 @@ main (void)
 
   res = set_property (global_obj_val, "external", external_func_val);
   TEST_ASSERT (!jerry_value_is_error (res));
-  TEST_ASSERT (jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_true (res));
   jerry_release_value (external_func_val);
 
   /* Call 'call_external' function that should call external function created above */
@@ -582,7 +580,7 @@ main (void)
 
   res = set_property (global_obj_val, "external_construct", external_construct_val);
   TEST_ASSERT (!jerry_value_is_error (res));
-  TEST_ASSERT (jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_true (res));
   jerry_release_value (res);
 
   /* Call external function created above, as constructor */
@@ -595,7 +593,7 @@ main (void)
   /* Get 'value_field' of constructed object */
   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_value_is_true (val_value_field));
   jerry_release_value (val_value_field);
   jerry_release_value (external_construct_val);
 
@@ -624,7 +622,7 @@ main (void)
 
   res = set_property (global_obj_val, "throw_test", throw_test_handler_val);
   TEST_ASSERT (!jerry_value_is_error (res));
-  TEST_ASSERT (jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_true (res));
   jerry_release_value (res);
   jerry_release_value (throw_test_handler_val);
 
@@ -698,7 +696,7 @@ main (void)
   jerry_value_t v_in = jerry_create_number (10.5);
   res = jerry_set_property_by_index (array_obj_val, 5, v_in);
   TEST_ASSERT (!jerry_value_is_error (res));
-  TEST_ASSERT (jerry_value_is_boolean (res) && jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_boolean (res) && jerry_value_is_true (res));
   jerry_release_value (res);
   jerry_value_t v_out = jerry_get_property_by_index (array_obj_val, 5);
 
@@ -767,14 +765,14 @@ main (void)
   res = jerry_set_prototype (obj_val, jerry_create_null ());
   TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_boolean (res));
-  TEST_ASSERT (jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_true (res));
 
   jerry_value_t new_proto = jerry_create_object ();
   res = jerry_set_prototype (obj_val, new_proto);
   jerry_release_value (new_proto);
   TEST_ASSERT (!jerry_value_is_error (res));
   TEST_ASSERT (jerry_value_is_boolean (res));
-  TEST_ASSERT (jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_true (res));
   proto_val = jerry_get_prototype (obj_val);
   TEST_ASSERT (!jerry_value_is_error (proto_val));
   TEST_ASSERT (jerry_value_is_object (proto_val));
@@ -959,7 +957,7 @@ main (void)
     prop_desc.value = jerry_create_number (5.2);
 
     jerry_value_t define_result = jerry_define_own_property (global_obj, prop_name, &prop_desc);
-    TEST_ASSERT (jerry_value_is_boolean (define_result) && jerry_get_boolean_value (define_result));
+    TEST_ASSERT (jerry_value_is_boolean (define_result) && jerry_value_is_true (define_result));
     jerry_release_value (define_result);
 
     jerry_property_descriptor_free (&prop_desc);
@@ -985,7 +983,7 @@ main (void)
       jerry_value_t new_realm_value = jerry_create_realm ();
 
       jerry_value_t set_realm_this_result = jerry_realm_set_this (new_realm_value, proxy);
-      TEST_ASSERT (jerry_value_is_boolean (set_realm_this_result) && jerry_get_boolean_value (set_realm_this_result));
+      TEST_ASSERT (jerry_value_is_boolean (set_realm_this_result) && jerry_value_is_true (set_realm_this_result));
       jerry_release_value (set_realm_this_result);
 
       jerry_value_t old_realm = jerry_set_realm (new_realm_value);
@@ -1014,7 +1012,7 @@ main (void)
       new_realm_value = jerry_create_realm ();
 
       set_realm_this_result = jerry_realm_set_this (new_realm_value, proxy);
-      TEST_ASSERT (jerry_value_is_boolean (set_realm_this_result) && jerry_get_boolean_value (set_realm_this_result));
+      TEST_ASSERT (jerry_value_is_boolean (set_realm_this_result) && jerry_value_is_true (set_realm_this_result));
       jerry_release_value (set_realm_this_result);
 
       old_realm = jerry_set_realm (new_realm_value);
@@ -1118,7 +1116,6 @@ main (void)
                     sizeof (test_magic_str_access_src) - 1,
                     JERRY_PARSE_NO_OPTS);
   TEST_ASSERT (jerry_value_is_boolean (res));
-  TEST_ASSERT (jerry_get_boolean_value (res) == true);
   TEST_ASSERT (jerry_value_is_true (res));
 
   jerry_release_value (res);

tests/unit-core/test-arraybuffer.c

@@ -45,8 +45,7 @@ assert_handler (const jerry_call_info_t *call_info_p, /**< call information */
   JERRY_UNUSED (call_info_p);
 
   if (args_cnt > 0
-      && jerry_value_is_boolean (args_p[0])
+      && jerry_value_is_true (args_p[0]))
-      && jerry_get_boolean_value (args_p[0]))
   {
     return jerry_create_boolean (true);
   }
@@ -379,7 +378,7 @@ main (void)
 
     jerry_value_t is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
     TEST_ASSERT (!jerry_value_is_error (is_detachable));
-    TEST_ASSERT (jerry_get_boolean_value (is_detachable));
+    TEST_ASSERT (jerry_value_is_true (is_detachable));
     TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
     jerry_release_value (is_detachable);
 
@@ -403,7 +402,7 @@ main (void)
 
     jerry_value_t is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
     TEST_ASSERT (!jerry_value_is_error (is_detachable));
-    TEST_ASSERT (jerry_get_boolean_value (is_detachable));
+    TEST_ASSERT (jerry_value_is_true (is_detachable));
     TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
     jerry_release_value (is_detachable);
 
@@ -414,7 +413,7 @@ main (void)
 
     is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
     TEST_ASSERT (!jerry_value_is_error (is_detachable));
-    TEST_ASSERT (!jerry_get_boolean_value (is_detachable));
+    TEST_ASSERT (!jerry_value_is_true (is_detachable));
     jerry_release_value (is_detachable);
 
     jerry_release_value (res);
@@ -432,7 +431,7 @@ main (void)
 
     jerry_value_t is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
     TEST_ASSERT (!jerry_value_is_error (is_detachable));
-    TEST_ASSERT (jerry_get_boolean_value (is_detachable));
+    TEST_ASSERT (jerry_value_is_true (is_detachable));
     TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == length);
     jerry_release_value (is_detachable);
 
@@ -444,7 +443,7 @@ main (void)
 
     is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
     TEST_ASSERT (!jerry_value_is_error (is_detachable));
-    TEST_ASSERT (!jerry_get_boolean_value (is_detachable));
+    TEST_ASSERT (!jerry_value_is_true (is_detachable));
     jerry_release_value (is_detachable);
 
     jerry_release_value (res);

tests/unit-core/test-container.c

@@ -114,7 +114,7 @@ main (void)
   jerry_value_t empty_map = jerry_create_container (JERRY_CONTAINER_TYPE_MAP, NULL, 0);
   TEST_ASSERT (jerry_get_container_type (empty_map) == JERRY_CONTAINER_TYPE_MAP);
   instance_check = jerry_binary_operation (JERRY_BIN_OP_INSTANCEOF, empty_map, global_map);
-  TEST_ASSERT (jerry_get_boolean_value (instance_check));
+  TEST_ASSERT (jerry_value_is_true (instance_check));
   jerry_release_value (instance_check);
   jerry_release_value (global_map);
   jerry_release_value (empty_map);
@@ -122,7 +122,7 @@ main (void)
   jerry_value_t empty_set = jerry_create_container (JERRY_CONTAINER_TYPE_SET, NULL, 0);
   TEST_ASSERT (jerry_get_container_type (empty_set) == JERRY_CONTAINER_TYPE_SET);
   instance_check = jerry_binary_operation (JERRY_BIN_OP_INSTANCEOF, empty_set, global_set);
-  TEST_ASSERT (jerry_get_boolean_value (instance_check));
+  TEST_ASSERT (jerry_value_is_true (instance_check));
   jerry_release_value (instance_check);
   jerry_release_value (global_set);
   jerry_release_value (empty_set);
@@ -130,7 +130,7 @@ main (void)
   jerry_value_t empty_weakmap = jerry_create_container (JERRY_CONTAINER_TYPE_WEAKMAP, NULL, 0);
   TEST_ASSERT (jerry_get_container_type (empty_weakmap) == JERRY_CONTAINER_TYPE_WEAKMAP);
   instance_check = jerry_binary_operation (JERRY_BIN_OP_INSTANCEOF, empty_weakmap, global_weakmap);
-  TEST_ASSERT (jerry_get_boolean_value (instance_check));
+  TEST_ASSERT (jerry_value_is_true (instance_check));
   jerry_release_value (instance_check);
   jerry_release_value (global_weakmap);
   jerry_release_value (empty_weakmap);
@@ -138,7 +138,7 @@ main (void)
   jerry_value_t empty_weakset = jerry_create_container (JERRY_CONTAINER_TYPE_WEAKSET, NULL, 0);
   TEST_ASSERT (jerry_get_container_type (empty_weakset) == JERRY_CONTAINER_TYPE_WEAKSET);
   instance_check = jerry_binary_operation (JERRY_BIN_OP_INSTANCEOF, empty_weakset, global_weakset);
-  TEST_ASSERT (jerry_get_boolean_value (instance_check));
+  TEST_ASSERT (jerry_value_is_true (instance_check));
   jerry_release_value (instance_check);
   jerry_release_value (global_weakset);
   jerry_release_value (empty_weakset);

tests/unit-core/test-error-callback.c

@@ -34,7 +34,7 @@ error_object_created_callback (const jerry_value_t error_object_t, /**< new erro
   jerry_value_t message = jerry_create_string ((const jerry_char_t *) "Replaced message!");
 
   jerry_value_t result = jerry_set_property (error_object_t, name, message);
-  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_get_boolean_value (result) == true);
+  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
   jerry_release_value (result);
 
   /* This SyntaxError must not trigger a recusrsive call of the this callback. */
@@ -56,7 +56,7 @@ run_test (const char *source_p)
   for (int i = 0; i < 5; i++)
   {
     jerry_value_t result = jerry_eval ((const jerry_char_t *) source_p, strlen (source_p), 0);
-    TEST_ASSERT (jerry_value_is_boolean (result) && jerry_get_boolean_value (result) == true);
+    TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
     jerry_release_value (result);
   }
 } /* run_test */

tests/unit-core/test-external-string.c

@@ -89,12 +89,12 @@ main (void)
 
   jerry_value_t result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, external_string, other_string);
   TEST_ASSERT (jerry_value_is_boolean (result));
-  TEST_ASSERT (jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_true (result));
   jerry_release_value (result);
 
   result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, external_string, external_string);
   TEST_ASSERT (jerry_value_is_boolean (result));
-  TEST_ASSERT (jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_true (result));
   jerry_release_value (result);
 
   TEST_ASSERT (free_count == 3);
@@ -125,7 +125,7 @@ main (void)
   jerry_value_t obj = jerry_create_object ();
   result = jerry_set_property (obj, external_string, other_string);
   TEST_ASSERT (jerry_value_is_boolean (result));
-  TEST_ASSERT (jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_true (result));
   jerry_release_value (result);
 
   jerry_value_t get_result = jerry_get_property (obj, other_string);
@@ -134,12 +134,12 @@ main (void)
   result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, get_result, external_string);
   jerry_release_value (get_result);
   TEST_ASSERT (jerry_value_is_boolean (result));
-  TEST_ASSERT (jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_true (result));
   jerry_release_value (result);
 
   result = jerry_set_property (obj, other_string, external_string);
   TEST_ASSERT (jerry_value_is_boolean (result));
-  TEST_ASSERT (jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_true (result));
   jerry_release_value (result);
 
   get_result = jerry_get_property (obj, external_string);
@@ -148,7 +148,7 @@ main (void)
   result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, get_result, other_string);
   jerry_release_value (get_result);
   TEST_ASSERT (jerry_value_is_boolean (result));
-  TEST_ASSERT (jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_true (result));
   jerry_release_value (result);
 
   jerry_release_value (obj);

tests/unit-core/test-from-property-descriptor.c

@@ -43,15 +43,15 @@ main (void)
 
   prop_name = jerry_create_string_from_utf8 ((jerry_char_t *) "writable");
   value = jerry_get_property (from_object, prop_name);
-  TEST_ASSERT (jerry_get_boolean_value (value) == ((prop_desc.flags & JERRY_PROP_IS_WRITABLE) != 0));
+  TEST_ASSERT (jerry_value_is_true (value) == ((prop_desc.flags & JERRY_PROP_IS_WRITABLE) != 0));
 
   prop_name = jerry_create_string_from_utf8 ((jerry_char_t *) "enumerable");
   value = jerry_get_property (from_object, prop_name);
-  TEST_ASSERT (jerry_get_boolean_value (value) == ((prop_desc.flags & JERRY_PROP_IS_ENUMERABLE) != 0));
+  TEST_ASSERT (jerry_value_is_true (value) == ((prop_desc.flags & JERRY_PROP_IS_ENUMERABLE) != 0));
 
   prop_name = jerry_create_string_from_utf8 ((jerry_char_t *) "configurable");
   value = jerry_get_property (from_object, prop_name);
-  TEST_ASSERT (jerry_get_boolean_value (value) == ((prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE) != 0));
+  TEST_ASSERT (jerry_value_is_true (value) == ((prop_desc.flags & JERRY_PROP_IS_CONFIGURABLE) != 0));
 
   jerry_release_value (object);
   jerry_release_value (prop_name);

tests/unit-core/test-has-property.c

@@ -21,7 +21,7 @@ static void
 assert_boolean_and_release (jerry_value_t result, bool expected)
 {
   TEST_ASSERT (jerry_value_is_boolean (result));
-  TEST_ASSERT (jerry_get_boolean_value (result) == expected);
+  TEST_ASSERT (jerry_value_is_true (result) == expected);
   jerry_release_value (result);
 } /* assert_boolean_and_release */
 

tests/unit-core/test-internal-properties.c

@@ -89,12 +89,12 @@ main (void)
   jerry_value_t has_result_5 = jerry_has_property (object, internal_prop_name_2);
   jerry_value_t has_result_6 = jerry_has_property (object, internal_prop_name_3);
 
-  TEST_ASSERT (jerry_value_is_boolean (has_result_1) && jerry_get_boolean_value (has_result_1));
+  TEST_ASSERT (jerry_value_is_boolean (has_result_1) && jerry_value_is_true (has_result_1));
-  TEST_ASSERT (jerry_value_is_boolean (has_result_2) && jerry_get_boolean_value (has_result_2));
+  TEST_ASSERT (jerry_value_is_boolean (has_result_2) && jerry_value_is_true (has_result_2));
-  TEST_ASSERT (jerry_value_is_boolean (has_result_3) && jerry_get_boolean_value (has_result_3));
+  TEST_ASSERT (jerry_value_is_boolean (has_result_3) && jerry_value_is_true (has_result_3));
-  TEST_ASSERT (jerry_value_is_boolean (has_result_4) && !jerry_get_boolean_value (has_result_4));
+  TEST_ASSERT (jerry_value_is_boolean (has_result_4) && !jerry_value_is_true (has_result_4));
-  TEST_ASSERT (jerry_value_is_boolean (has_result_5) && !jerry_get_boolean_value (has_result_5));
+  TEST_ASSERT (jerry_value_is_boolean (has_result_5) && !jerry_value_is_true (has_result_5));
-  TEST_ASSERT (jerry_value_is_boolean (has_result_6) && !jerry_get_boolean_value (has_result_6));
+  TEST_ASSERT (jerry_value_is_boolean (has_result_6) && !jerry_value_is_true (has_result_6));
 
   jerry_release_value (has_result_1);
   jerry_release_value (has_result_2);
@@ -185,11 +185,11 @@ main (void)
   bool has_after_delete_result_6 = jerry_has_internal_property (object, internal_prop_name_3);
 
   TEST_ASSERT (jerry_value_is_boolean (has_after_delete_result_1)
-               && !jerry_get_boolean_value (has_after_delete_result_1));
+               && !jerry_value_is_true (has_after_delete_result_1));
   TEST_ASSERT (jerry_value_is_boolean (has_after_delete_result_2)
-               && !jerry_get_boolean_value (has_after_delete_result_2));
+               && !jerry_value_is_true (has_after_delete_result_2));
   TEST_ASSERT (jerry_value_is_boolean (has_after_delete_result_3)
-               && !jerry_get_boolean_value (has_after_delete_result_3));
+               && !jerry_value_is_true (has_after_delete_result_3));
   TEST_ASSERT (has_after_delete_result_4);
   TEST_ASSERT (has_after_delete_result_5);
   TEST_ASSERT (has_after_delete_result_6);

tests/unit-core/test-json.c

@@ -46,7 +46,7 @@ main (void)
     jerry_value_t name_key = jerry_create_string ((const jerry_char_t *) "name");
 
     jerry_value_t has_name = jerry_has_property (parsed_json, name_key);
-    TEST_ASSERT (jerry_get_boolean_value (has_name));
+    TEST_ASSERT (jerry_value_is_true (has_name));
     jerry_release_value (has_name);
 
     jerry_value_t name_value = jerry_get_property (parsed_json, name_key);
@@ -68,7 +68,7 @@ main (void)
     jerry_value_t age_key = jerry_create_string ((const jerry_char_t *) "age");
 
     jerry_value_t has_age = jerry_has_property (parsed_json, age_key);
-    TEST_ASSERT (jerry_get_boolean_value (has_age));
+    TEST_ASSERT (jerry_value_is_true (has_age));
     jerry_release_value (has_age);
 
     jerry_value_t age_value = jerry_get_property (parsed_json, age_key);
@@ -106,7 +106,7 @@ main (void)
       jerry_value_t name_set = jerry_set_property (obj, name_key, name_value);
       TEST_ASSERT (!jerry_value_is_error (name_set));
       TEST_ASSERT (jerry_value_is_boolean (name_set));
-      TEST_ASSERT (jerry_get_boolean_value (name_set));
+      TEST_ASSERT (jerry_value_is_true (name_set));
       jerry_release_value (name_key);
       jerry_release_value (name_value);
       jerry_release_value (name_set);
@@ -117,7 +117,7 @@ main (void)
       jerry_value_t age_set = jerry_set_property (obj, age_key, age_value);
       TEST_ASSERT (!jerry_value_is_error (age_set));
       TEST_ASSERT (jerry_value_is_boolean (age_set));
-      TEST_ASSERT (jerry_get_boolean_value (age_set));
+      TEST_ASSERT (jerry_value_is_true (age_set));
       jerry_release_value (age_key);
       jerry_release_value (age_value);
       jerry_release_value (age_set);
@@ -150,7 +150,7 @@ main (void)
       jerry_value_t name_set = jerry_set_property (obj, name_key, name_value);
       TEST_ASSERT (!jerry_value_is_error (name_set));
       TEST_ASSERT (jerry_value_is_boolean (name_set));
-      TEST_ASSERT (jerry_get_boolean_value (name_set));
+      TEST_ASSERT (jerry_value_is_true (name_set));
       jerry_release_value (name_key);
       jerry_release_value (name_value);
       jerry_release_value (name_set);

tests/unit-core/test-module.c

@@ -164,13 +164,13 @@ native_module_evaluate (const jerry_value_t native_module) /**< native module */
 
   jerry_value_t export = jerry_create_number (3.5);
   result = jerry_native_module_set_export (native_module, exp_val, export);
-  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
   jerry_release_value (result);
   jerry_release_value (export);
 
   export = jerry_create_string ((const jerry_char_t *) "str");
   result = jerry_native_module_set_export (native_module, other_exp_val, export);
-  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
   jerry_release_value (result);
   jerry_release_value (export);
 
@@ -313,7 +313,7 @@ main (void)
   counter = 31;
   terminate_with_error = false;
   result = jerry_module_link (module, resolve_callback2, NULL);
-  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
   TEST_ASSERT (counter == 32);
   jerry_release_value (result);
 
@@ -331,7 +331,7 @@ main (void)
   counter = 0;
   terminate_with_error = false;
   result = jerry_module_link (module, resolve_callback2, NULL);
-  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
   TEST_ASSERT (counter == 32);
   jerry_release_value (result);
   jerry_release_value (module);
@@ -438,7 +438,7 @@ main (void)
   TEST_ASSERT (jerry_module_get_state (module) == JERRY_MODULE_STATE_UNLINKED);
 
   result = jerry_module_link (module, NULL, NULL);
-  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
   jerry_release_value (result);
 
   result = jerry_module_evaluate (module);

tests/unit-core/test-native-instanceof.c

@@ -47,7 +47,7 @@ test_instanceof (jerry_value_t instanceof,
   TEST_ASSERT (!jerry_value_is_error (result));
   TEST_ASSERT (jerry_value_is_boolean (result));
 
-  TEST_ASSERT (jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_true (result));
 
   jerry_release_value (instance);
   jerry_release_value (result);

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

@@ -168,7 +168,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_is_error (result) && jerry_get_boolean_value (result));
+  bool has_property = (!jerry_value_is_error (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)
@@ -212,7 +212,7 @@ main (void)
   /* Assert that the correct object was retrieved. */
   jerry_value_t undefined = jerry_create_undefined ();
   jerry_value_t strict_equal_result = jerry_call_function (strict_equal, undefined, args, 2);
-  TEST_ASSERT (jerry_value_is_boolean (strict_equal_result) && jerry_get_boolean_value (strict_equal_result));
+  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);
@@ -237,7 +237,7 @@ main (void)
   /* Assert that the right object was retrieved and release both the original reference to it and the retrieved one. */
   args[0] = object;
   strict_equal_result = jerry_call_function (strict_equal, undefined, args, 2);
-  TEST_ASSERT (jerry_value_is_boolean (strict_equal_result) && jerry_get_boolean_value (strict_equal_result));
+  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]);

tests/unit-core/test-promise.c

@@ -75,8 +75,7 @@ assert_handler (const jerry_call_info_t *call_info_p, /**< call information */
   count_in_assert++;
 
   if (args_cnt == 1
-      && jerry_value_is_boolean (args_p[0])
+      && jerry_value_is_true (args_p[0]))
-      && jerry_get_boolean_value (args_p[0]))
   {
     return jerry_create_boolean (true);
   }

tests/unit-core/test-proxy.c

@@ -118,7 +118,7 @@ set_property (jerry_value_t target, /**< target object */
   jerry_value_t result_val = jerry_set_property (target, name_val, value);
 
   TEST_ASSERT (jerry_value_is_boolean (result_val));
-  TEST_ASSERT (jerry_get_boolean_value (result_val));
+  TEST_ASSERT (jerry_value_is_true (result_val));
   jerry_release_value (name_val);
 } /* set_property */
 

tests/unit-core/test-realm.c

@@ -86,7 +86,7 @@ check_array_prototype (jerry_value_t realm_value, jerry_value_t result_value)
   jerry_value_t compare_value = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, result_value, prototype_value);
   jerry_release_value (prototype_value);
 
-  TEST_ASSERT (jerry_value_is_boolean (compare_value) && jerry_get_boolean_value (compare_value));
+  TEST_ASSERT (jerry_value_is_boolean (compare_value) && jerry_value_is_true (compare_value));
   jerry_release_value (compare_value);
 } /* check_array_prototype */
 
@@ -167,7 +167,7 @@ main (void)
   jerry_release_value (number_value);
 
   result_value = jerry_realm_set_this (realm_value, object_value);
-  TEST_ASSERT (jerry_value_is_boolean (result_value) && jerry_get_boolean_value (result_value));
+  TEST_ASSERT (jerry_value_is_boolean (result_value) && jerry_value_is_true (result_value));
   jerry_release_value (result_value);
 
   create_number_property (object_value, "x", 7.25);

tests/unit-core/test-regexp-dotall-unicode.c

@@ -58,9 +58,9 @@ main (void)
   const char expected_result[] = "a\nb";
   TEST_ASSERT (res_size == (sizeof (expected_result) - 1));
   TEST_ASSERT (strncmp (expected_result, (const char *) res_buff, res_size) == 0);
-  TEST_ASSERT (jerry_get_boolean_value (is_dotall));
+  TEST_ASSERT (jerry_value_is_true (is_dotall));
-  TEST_ASSERT (jerry_get_boolean_value (is_sticky));
+  TEST_ASSERT (jerry_value_is_true (is_sticky));
-  TEST_ASSERT (jerry_get_boolean_value (is_unicode));
+  TEST_ASSERT (jerry_value_is_true (is_unicode));
 
   jerry_release_value (regex_obj);
   jerry_release_value (res);

tests/unit-core/test-regexp.c

@@ -53,8 +53,8 @@ main (void)
 
   TEST_ASSERT (res_size == str_size);
   TEST_ASSERT (strncmp (expected_result, (const char *) res_buff, res_size) == 0);
-  TEST_ASSERT (jerry_get_boolean_value (is_multiline));
+  TEST_ASSERT (jerry_value_is_true (is_multiline));
-  TEST_ASSERT (jerry_get_boolean_value (is_global));
+  TEST_ASSERT (jerry_value_is_true (is_global));
 
   jerry_release_value (regex_obj);
   jerry_release_value (res);

tests/unit-core/test-regression-3588.c

@@ -53,7 +53,7 @@ main (void)
     jerry_value_t function_name_val = jerry_create_string ((const jerry_char_t *) "Demo");
     jerry_value_t result_val = jerry_set_property (global_obj_val, function_name_val, function_val);
     TEST_ASSERT (!jerry_value_is_error (result_val));
-    TEST_ASSERT (jerry_get_boolean_value (result_val) == true);
+    TEST_ASSERT (jerry_value_is_true (result_val));
     jerry_release_value (result_val);
     jerry_release_value (function_name_val);
     jerry_release_value (global_obj_val);

tests/unit-core/test-symbol.c

@@ -64,13 +64,13 @@ main (void)
 
   jerry_value_t result_val = jerry_set_property (object, symbol_1, value_1);
   TEST_ASSERT (jerry_value_is_boolean (result_val));
-  TEST_ASSERT (jerry_get_boolean_value (jerry_has_property (object, symbol_1)));
+  TEST_ASSERT (jerry_value_is_true (jerry_has_property (object, symbol_1)));
-  TEST_ASSERT (jerry_get_boolean_value (jerry_has_own_property (object, symbol_1)));
+  TEST_ASSERT (jerry_value_is_true (jerry_has_own_property (object, symbol_1)));
 
   result_val = jerry_set_property (object, symbol_2, value_2);
   TEST_ASSERT (jerry_value_is_boolean (result_val));
-  TEST_ASSERT (jerry_get_boolean_value (jerry_has_property (object, symbol_2)));
+  TEST_ASSERT (jerry_value_is_true (jerry_has_property (object, symbol_2)));
-  TEST_ASSERT (jerry_get_boolean_value (jerry_has_own_property (object, symbol_2)));
+  TEST_ASSERT (jerry_value_is_true (jerry_has_own_property (object, symbol_2)));
 
   jerry_value_t get_value_1 = jerry_get_property (object, symbol_1);
   TEST_ASSERT (jerry_get_number_value (get_value_1) == jerry_get_number_value (value_1));
@@ -82,8 +82,8 @@ main (void)
 
   /* Test delete / has_{own}_property */
   TEST_ASSERT (jerry_delete_property (object, symbol_1));
-  TEST_ASSERT (!jerry_get_boolean_value (jerry_has_property (object, symbol_1)));
+  TEST_ASSERT (!jerry_value_is_true (jerry_has_property (object, symbol_1)));
-  TEST_ASSERT (!jerry_get_boolean_value (jerry_has_own_property (object, symbol_1)));
+  TEST_ASSERT (!jerry_value_is_true (jerry_has_own_property (object, symbol_1)));
 
   jerry_release_value (value_1);
   jerry_release_value (symbol_1);
@@ -112,7 +112,7 @@ main (void)
   | JERRY_PROP_IS_ENUMERABLE_DEFINED
   | JERRY_PROP_IS_CONFIGURABLE_DEFINED;
   prop_desc.value = jerry_acquire_value (value_3);
-  TEST_ASSERT (jerry_get_boolean_value (jerry_define_own_property (object, symbol_2, &prop_desc)));
+  TEST_ASSERT (jerry_value_is_true (jerry_define_own_property (object, symbol_2, &prop_desc)));
   jerry_property_descriptor_free (&prop_desc);
 
   /* Check the modified fields */
@@ -275,7 +275,7 @@ main (void)
                                                      current_global_symbol);
 
     TEST_ASSERT (jerry_value_is_boolean (relation)
-                 && jerry_get_boolean_value (relation));
+                 && jerry_value_is_true (relation));
 
     jerry_release_value (relation);
 
@@ -304,7 +304,7 @@ main (void)
 
   jerry_value_t deleter = jerry_eval (deleter_src, sizeof (deleter_src) - 1, JERRY_PARSE_NO_OPTS);
   TEST_ASSERT (jerry_value_is_boolean (deleter)
-               && jerry_get_boolean_value (deleter));
+               && jerry_value_is_true (deleter));
   jerry_release_value (deleter);
 
   builtin_symbol = jerry_get_property (global_obj, symbol_str);

tests/unit-core/test-to-property-descriptor.c

@@ -40,7 +40,7 @@ check_attribute (jerry_value_t attribute, /**< attribute to be checked */
   else
   {
     jerry_value_t result = jerry_binary_operation (JERRY_BIN_OP_STRICT_EQUAL, attribute, value);
-    TEST_ASSERT (jerry_value_is_boolean (result) && jerry_get_boolean_value (result));
+    TEST_ASSERT (jerry_value_is_true (result));
     jerry_release_value (result);
   }
 
@@ -54,7 +54,7 @@ to_property_descriptor (jerry_value_t object /**< object */)
   jerry_property_descriptor_t prop_desc = jerry_property_descriptor_create ();
 
   jerry_value_t result = jerry_to_property_descriptor (object, &prop_desc);
-  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_get_boolean_value (result));
+  TEST_ASSERT (jerry_value_is_boolean (result) && jerry_value_is_true (result));
   jerry_release_value (result);
 
   return prop_desc;

tests/unit-core/test-typedarray.c

@@ -56,8 +56,7 @@ assert_handler (const jerry_call_info_t *call_info_p, /**< call information */
 {
   JERRY_UNUSED (call_info_p);
 
-  if (jerry_value_is_boolean (args_p[0])
+  if (jerry_value_is_true (args_p[0]))
-      && jerry_get_boolean_value (args_p[0]))
   {
     return jerry_create_boolean (true);
   }
@@ -337,7 +336,7 @@ static void test_property_by_index (test_entry_t test_entries[])
           get_result = jerry_get_property_by_index (typedarray, j);
 
           TEST_ASSERT (jerry_value_is_boolean (set_result));
-          TEST_ASSERT (jerry_get_boolean_value (set_result));
+          TEST_ASSERT (jerry_value_is_true (set_result));
           TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
           TEST_ASSERT (jerry_get_number_value (get_result) == test_int_numbers[j]);
 
@@ -358,7 +357,7 @@ static void test_property_by_index (test_entry_t test_entries[])
           get_result = jerry_get_property_by_index (typedarray, j);
 
           TEST_ASSERT (jerry_value_is_boolean (set_result));
-          TEST_ASSERT (jerry_get_boolean_value (set_result));
+          TEST_ASSERT (jerry_value_is_true (set_result));
           TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
 
           double epsilon = pow (10, -5);
@@ -375,7 +374,7 @@ static void test_property_by_index (test_entry_t test_entries[])
             jerry_value_t inf = jerry_create_number_infinity (k);
             jerry_value_t set_inf = jerry_set_property_by_index (typedarray, 0, inf);
             TEST_ASSERT (jerry_value_is_boolean (set_inf));
-            TEST_ASSERT (jerry_get_boolean_value (set_inf));
+            TEST_ASSERT (jerry_value_is_true (set_inf));
             jerry_value_t get_inf = jerry_get_property_by_index (typedarray, 0);
             TEST_ASSERT (isinf (jerry_get_number_value (get_inf)));
 
@@ -396,7 +395,7 @@ static void test_property_by_index (test_entry_t test_entries[])
           get_result = jerry_get_property_by_index (typedarray, j);
 
           TEST_ASSERT (jerry_value_is_boolean (set_result));
-          TEST_ASSERT (jerry_get_boolean_value (set_result));
+          TEST_ASSERT (jerry_value_is_true (set_result));
           TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
           int64_t get_number;
           bool sign;
@@ -420,7 +419,7 @@ static void test_property_by_index (test_entry_t test_entries[])
           get_result = jerry_get_property_by_index (typedarray, j);
 
           TEST_ASSERT (jerry_value_is_boolean (set_result));
-          TEST_ASSERT (jerry_get_boolean_value (set_result));
+          TEST_ASSERT (jerry_value_is_true (set_result));
           TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
           uint64_t get_number;
           bool sign;
@@ -444,7 +443,7 @@ static void test_property_by_index (test_entry_t test_entries[])
           get_result = jerry_get_property_by_index (typedarray, j);
 
           TEST_ASSERT (jerry_value_is_boolean (set_result));
-          TEST_ASSERT (jerry_get_boolean_value (set_result));
+          TEST_ASSERT (jerry_value_is_true (set_result));
           TEST_ASSERT (!jerry_delete_property_by_index (typedarray, j));
           TEST_ASSERT (jerry_get_number_value (get_result) == test_uint_numbers[j]);
 
@@ -464,7 +463,7 @@ static void test_property_by_index (test_entry_t test_entries[])
     }
     else
     {
-      TEST_ASSERT (jerry_value_is_boolean (set_undefined) && !jerry_get_boolean_value (set_undefined));
+      TEST_ASSERT (jerry_value_is_boolean (set_undefined) && !jerry_value_is_true (set_undefined));
     }
 
     jerry_value_t get_undefined = jerry_get_property_by_index (typedarray, 100);
@@ -514,7 +513,7 @@ test_detached_arraybuffer (void)
 
     jerry_value_t is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
     TEST_ASSERT (!jerry_value_is_error (is_detachable));
-    TEST_ASSERT (jerry_get_boolean_value (is_detachable));
+    TEST_ASSERT (jerry_value_is_true (is_detachable));
     jerry_release_value (is_detachable);
 
     jerry_value_t res = jerry_detach_arraybuffer (arraybuffer);
@@ -543,7 +542,7 @@ test_detached_arraybuffer (void)
 
     jerry_value_t is_detachable = jerry_is_arraybuffer_detachable (arraybuffer);
     TEST_ASSERT (!jerry_value_is_error (is_detachable));
-    TEST_ASSERT (jerry_get_boolean_value (is_detachable));
+    TEST_ASSERT (jerry_value_is_true (is_detachable));
     jerry_release_value (is_detachable);
 
     jerry_value_t res = jerry_detach_arraybuffer (arraybuffer);

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

@@ -210,7 +210,7 @@ main (int argc, char **argv)
   js_property_name = jerry_create_string ((const jerry_char_t *) "require");
   res = jerry_set_property (js_global, js_property_name, js_function);
   TEST_ASSERT (!jerry_value_is_error (res));
-  TEST_ASSERT (jerry_value_is_boolean (res) && jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_boolean (res) && jerry_value_is_true (res));
   jerry_release_value (res);
   jerry_release_value (js_property_name);
   jerry_release_value (js_function);
@@ -219,7 +219,7 @@ main (int argc, char **argv)
   js_property_name = jerry_create_string ((const jerry_char_t *) "clear_require_cache");
   res = jerry_set_property (js_global, js_property_name, js_function);
   TEST_ASSERT (!jerry_value_is_error (res));
-  TEST_ASSERT (jerry_value_is_boolean (res) && jerry_get_boolean_value (res));
+  TEST_ASSERT (jerry_value_is_boolean (res) && jerry_value_is_true (res));
   jerry_release_value (res);
   jerry_release_value (js_property_name);
   jerry_release_value (js_function);

tests/unit-ext/test-ext-method-register.c

@@ -101,7 +101,7 @@ test_simple_registration (void)
     const char *test_A = "test.my_str_sz === 'super_'";
     jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
     TEST_ASSERT (jerry_value_is_boolean (result));
-    TEST_ASSERT (jerry_get_boolean_value (result) == true);
+    TEST_ASSERT (jerry_value_is_true (result));
     jerry_release_value (result);
   }
 
@@ -109,7 +109,7 @@ test_simple_registration (void)
     const char *test_A = "test.my_str === 'super_str'";
     jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
     TEST_ASSERT (jerry_value_is_boolean (result));
-    TEST_ASSERT (jerry_get_boolean_value (result) == true);
+    TEST_ASSERT (jerry_value_is_true (result));
     jerry_release_value (result);
   }
 
@@ -117,7 +117,7 @@ test_simple_registration (void)
     const char *test_A = "test.my_bool";
     jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
     TEST_ASSERT (jerry_value_is_boolean (result));
-    TEST_ASSERT (jerry_get_boolean_value (result) == true);
+    TEST_ASSERT (jerry_value_is_true (result));
     jerry_release_value (result);
   }
 
@@ -125,7 +125,7 @@ test_simple_registration (void)
     const char *test_A = "test.my_bool_false";
     jerry_value_t result = jerry_eval ((const jerry_char_t *) test_A, strlen (test_A), 0);
     TEST_ASSERT (jerry_value_is_boolean (result));
-    TEST_ASSERT (jerry_get_boolean_value (result) == false);
+    TEST_ASSERT (jerry_value_is_true (result) == false);
     jerry_release_value (result);
   }
 
@@ -248,7 +248,7 @@ test_error_multiple_functions (void)
     // Test if property "prop_ok" is correctly registered.
     jerry_value_t prop_ok_val = jerry_create_string ((const jerry_char_t *) prop_ok);
     jerry_value_t prop_ok_exists = jerry_has_own_property (target_object, prop_ok_val);
-    TEST_ASSERT (jerry_get_boolean_value (prop_ok_exists) == true);
+    TEST_ASSERT (jerry_value_is_true (prop_ok_exists));
     jerry_release_value (prop_ok_exists);
 
     // Try calling the method
@@ -279,7 +279,7 @@ test_error_multiple_functions (void)
     // The "prop_err" should exist - as it was "freezed" - but it should not be a function
     jerry_value_t prop_err_val = jerry_create_string ((const jerry_char_t *) prop_err);
     jerry_value_t prop_err_exists = jerry_has_own_property (target_object, prop_err_val);
-    TEST_ASSERT (jerry_get_boolean_value (prop_err_exists) == true);
+    TEST_ASSERT (jerry_value_is_true (prop_err_exists));
     jerry_release_value (prop_err_exists);
 
     jerry_value_t prop_err_func = jerry_value_is_function (prop_err_val);
@@ -290,7 +290,7 @@ test_error_multiple_functions (void)
   { // The "prop_not" is not available on the target object
     jerry_value_t prop_not_val = jerry_create_string ((const jerry_char_t *) prop_not);
     jerry_value_t prop_not_exists = jerry_has_own_property (target_object, prop_not_val);
-    TEST_ASSERT (jerry_get_boolean_value (prop_not_exists) == false);
+    TEST_ASSERT (jerry_value_is_true (prop_not_exists) == false);
     jerry_release_value (prop_not_exists);
     jerry_release_value (prop_not_val);
   }