lib: rename `bt_*_compare()` to `bt_*_is_equal()`

Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: I7782ad5c7b5374e88d5f0e31c4fe3fec4e4bea6c
Reviewed-on: https://review.lttng.org/c/babeltrace/+/2145
Tested-by: jenkins <jenkins@lttng.org>
Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>

diff --git a/include/babeltrace2/integer-range-set-const.h b/include/babeltrace2/integer-range-set-const.h
index 0357eaa16a2404796c29dd3e58e66e1bdaa1194f..d762de06c1fe2b2ec434d1ab8715f3cf65a29b16 100644 (file)
--- a/include/babeltrace2/integer-range-set-const.h
+++ b/include/babeltrace2/integer-range-set-const.h
@@ -48,11 +48,11 @@ extern int64_t bt_integer_range_signed_get_lower(
 extern int64_t bt_integer_range_signed_get_upper(
                const bt_integer_range_signed *range);
 
-extern bt_bool bt_integer_range_unsigned_compare(
+extern bt_bool bt_integer_range_unsigned_is_equal(
                const bt_integer_range_unsigned *range_a,
                const bt_integer_range_unsigned *range_b);
 
-extern bt_bool bt_integer_range_signed_compare(
+extern bt_bool bt_integer_range_signed_is_equal(
                const bt_integer_range_signed *range_a,
                const bt_integer_range_signed *range_b);
 
@@ -80,11 +80,11 @@ extern const bt_integer_range_signed *
 bt_integer_range_set_signed_borrow_range_by_index_const(
                const bt_integer_range_set_signed *range_set, uint64_t index);
 
-extern bt_bool bt_integer_range_set_unsigned_compare(
+extern bt_bool bt_integer_range_set_unsigned_is_equal(
                const bt_integer_range_set_unsigned *range_set_a,
                const bt_integer_range_set_unsigned *range_set_b);
 
-extern bt_bool bt_integer_range_set_signed_compare(
+extern bt_bool bt_integer_range_set_signed_is_equal(
                const bt_integer_range_set_signed *range_set_a,
                const bt_integer_range_set_signed *range_set_b);
 

diff --git a/include/babeltrace2/value-const.h b/include/babeltrace2/value-const.h
index f9a1d3d093cad57badc49151f8a4fc083e889f4b..4ac17cb083ce0c1658c8cbd591960dff475e4665 100644 (file)
--- a/include/babeltrace2/value-const.h
+++ b/include/babeltrace2/value-const.h
@@ -120,7 +120,7 @@ typedef enum bt_value_copy_status {
 extern bt_value_copy_status bt_value_copy(const bt_value *object,
                bt_value **copy);
 
-extern bt_bool bt_value_compare(const bt_value *object_a,
+extern bt_bool bt_value_is_equal(const bt_value *object_a,
                const bt_value *object_b);
 
 extern bt_bool bt_value_bool_get(const bt_value *bool_obj);

diff --git a/src/bindings/python/bt2/bt2/integer_range_set.py b/src/bindings/python/bt2/bt2/integer_range_set.py
index 44f08ed4876319f1a249bc1af643326137f3c4c2..b00724fe5042276ab7100fd12c291902d0023f3b 100644 (file)
--- a/src/bindings/python/bt2/bt2/integer_range_set.py
+++ b/src/bindings/python/bt2/bt2/integer_range_set.py
@@ -113,7 +113,7 @@ class _IntegerRangeSetConst(object._SharedObject, collections.abc.Set):
         if not isinstance(other, _IntegerRangeSetConst):
             return False
 
-        return self._compare(self._ptr, other._ptr)
+        return self._is_equal(self._ptr, other._ptr)
 
     def contains_value(self, value):
         for rg in self:
@@ -163,7 +163,7 @@ class _SignedIntegerRangeSetConst(_IntegerRangeSetConst):
     )
     _range_get_lower = staticmethod(native_bt.integer_range_signed_get_lower)
     _range_get_upper = staticmethod(native_bt.integer_range_signed_get_upper)
-    _compare = staticmethod(native_bt.integer_range_set_signed_compare)
+    _is_equal = staticmethod(native_bt.integer_range_set_signed_is_equal)
     _range_pycls = _SignedIntegerRangeConst
 
 
@@ -184,7 +184,7 @@ class _UnsignedIntegerRangeSetConst(_IntegerRangeSetConst):
     )
     _range_get_lower = staticmethod(native_bt.integer_range_unsigned_get_lower)
     _range_get_upper = staticmethod(native_bt.integer_range_unsigned_get_upper)
-    _compare = staticmethod(native_bt.integer_range_set_unsigned_compare)
+    _is_equal = staticmethod(native_bt.integer_range_set_unsigned_is_equal)
     _range_pycls = _UnsignedIntegerRangeConst
 
 

diff --git a/src/lib/integer-range-set.c b/src/lib/integer-range-set.c
index 35483c93b27865818d018e52cb48fdb033dc4869..a422e4e419ecbc4a918667f0590a455f43611db3 100644 (file)
--- a/src/lib/integer-range-set.c
+++ b/src/lib/integer-range-set.c
@@ -73,7 +73,7 @@ bool compare_ranges(const struct bt_integer_range *range_a,
                range_a->upper.u == range_b->upper.u;
 }
 
-bt_bool bt_integer_range_unsigned_compare(
+bt_bool bt_integer_range_unsigned_is_equal(
                const struct bt_integer_range_unsigned *range_a,
                const struct bt_integer_range_unsigned *range_b)
 {
@@ -83,7 +83,7 @@ bt_bool bt_integer_range_unsigned_compare(
                (const void *) range_b);
 }
 
-bt_bool bt_integer_range_signed_compare(
+bt_bool bt_integer_range_signed_is_equal(
                const struct bt_integer_range_signed *range_a,
                const struct bt_integer_range_signed *range_b)
 {
@@ -353,7 +353,7 @@ end:
        return is_equal;
 }
 
-bt_bool bt_integer_range_set_unsigned_compare(
+bt_bool bt_integer_range_set_unsigned_is_equal(
                const struct bt_integer_range_set_unsigned *range_set_a,
                const struct bt_integer_range_set_unsigned *range_set_b)
 {
@@ -363,7 +363,7 @@ bt_bool bt_integer_range_set_unsigned_compare(
                (const void *) range_set_b);
 }
 
-bt_bool bt_integer_range_set_signed_compare(
+bt_bool bt_integer_range_set_signed_is_equal(
                const struct bt_integer_range_set_signed *range_set_a,
                const struct bt_integer_range_set_signed *range_set_b)
 {

diff --git a/src/lib/value.c b/src/lib/value.c
index c8865ebc05c2d37eb451a3ccbb6bf1acdd920073..91d109fc5d3dbf1d1ea6afc5f5cf0e2c47a58e98 100644 (file)
--- a/src/lib/value.c
+++ b/src/lib/value.c
@@ -297,11 +297,11 @@ struct bt_value *(* const copy_funcs[])(const struct bt_value *) = {
 };
 
 static
-bt_bool bt_value_null_compare(const struct bt_value *object_a,
+bt_bool bt_value_null_is_equal(const struct bt_value *object_a,
                const struct bt_value *object_b)
 {
        /*
-        * Always BT_TRUE since bt_value_compare() already checks if both
+        * Always BT_TRUE since bt_value_is_equal() already checks if both
         * object_a and object_b have the same type, and in the case of
         * null value objects, they're always the same if it is so.
         */
@@ -309,7 +309,7 @@ bt_bool bt_value_null_compare(const struct bt_value *object_a,
 }
 
 static
-bt_bool bt_value_bool_compare(const struct bt_value *object_a,
+bt_bool bt_value_bool_is_equal(const struct bt_value *object_a,
                const struct bt_value *object_b)
 {
        if (BT_VALUE_TO_BOOL(object_a)->value !=
@@ -325,7 +325,7 @@ bt_bool bt_value_bool_compare(const struct bt_value *object_a,
 }
 
 static
-bt_bool bt_value_integer_compare(const struct bt_value *object_a,
+bt_bool bt_value_integer_is_equal(const struct bt_value *object_a,
                const struct bt_value *object_b)
 {
        if (BT_VALUE_TO_INTEGER(object_a)->value.u !=
@@ -349,7 +349,7 @@ bt_bool bt_value_integer_compare(const struct bt_value *object_a,
 }
 
 static
-bt_bool bt_value_real_compare(const struct bt_value *object_a,
+bt_bool bt_value_real_is_equal(const struct bt_value *object_a,
                const struct bt_value *object_b)
 {
        if (BT_VALUE_TO_REAL(object_a)->value !=
@@ -365,7 +365,7 @@ bt_bool bt_value_real_compare(const struct bt_value *object_a,
 }
 
 static
-bt_bool bt_value_string_compare(const struct bt_value *object_a,
+bt_bool bt_value_string_is_equal(const struct bt_value *object_a,
                const struct bt_value *object_b)
 {
        if (strcmp(BT_VALUE_TO_STRING(object_a)->gstr->str,
@@ -381,7 +381,7 @@ bt_bool bt_value_string_compare(const struct bt_value *object_a,
 }
 
 static
-bt_bool bt_value_array_compare(const struct bt_value *object_a,
+bt_bool bt_value_array_is_equal(const struct bt_value *object_a,
                const struct bt_value *object_b)
 {
        int i;
@@ -410,7 +410,7 @@ bt_bool bt_value_array_compare(const struct bt_value *object_a,
                element_obj_b = bt_value_array_borrow_element_by_index_const(
                        object_b, i);
 
-               if (!bt_value_compare(element_obj_a, element_obj_b)) {
+               if (!bt_value_is_equal(element_obj_a, element_obj_b)) {
                        BT_LOGT("Array values's elements are different: "
                                "value-a-addr=%p, value-b-addr=%p, index=%d",
                                element_obj_a, element_obj_b, i);
@@ -424,7 +424,7 @@ end:
 }
 
 static
-bt_bool bt_value_map_compare(const struct bt_value *object_a,
+bt_bool bt_value_map_is_equal(const struct bt_value *object_a,
                const struct bt_value *object_b)
 {
        bt_bool ret = BT_TRUE;
@@ -453,7 +453,7 @@ bt_bool bt_value_map_compare(const struct bt_value *object_a,
                element_obj_b = bt_value_map_borrow_entry_value_const(object_b,
                        key_str);
 
-               if (!bt_value_compare(element_obj_a, element_obj_b)) {
+               if (!bt_value_is_equal(element_obj_a, element_obj_b)) {
                        BT_LOGT("Map values's elements are different: "
                                "value-a-addr=%p, value-b-addr=%p, key=\"%s\"",
                                element_obj_a, element_obj_b, key_str);
@@ -467,16 +467,16 @@ end:
 }
 
 static
-bt_bool (* const compare_funcs[])(const struct bt_value *,
+bt_bool (* const is_equal_funcs[])(const struct bt_value *,
                const struct bt_value *) = {
-       [BT_VALUE_TYPE_NULL] =                  bt_value_null_compare,
-       [BT_VALUE_TYPE_BOOL] =                  bt_value_bool_compare,
-       [BT_VALUE_TYPE_UNSIGNED_INTEGER] =      bt_value_integer_compare,
-       [BT_VALUE_TYPE_SIGNED_INTEGER] =        bt_value_integer_compare,
-       [BT_VALUE_TYPE_REAL] =                  bt_value_real_compare,
-       [BT_VALUE_TYPE_STRING] =                bt_value_string_compare,
-       [BT_VALUE_TYPE_ARRAY] =                 bt_value_array_compare,
-       [BT_VALUE_TYPE_MAP] =                   bt_value_map_compare,
+       [BT_VALUE_TYPE_NULL] =                  bt_value_null_is_equal,
+       [BT_VALUE_TYPE_BOOL] =                  bt_value_bool_is_equal,
+       [BT_VALUE_TYPE_UNSIGNED_INTEGER] =      bt_value_integer_is_equal,
+       [BT_VALUE_TYPE_SIGNED_INTEGER] =        bt_value_integer_is_equal,
+       [BT_VALUE_TYPE_REAL] =                  bt_value_real_is_equal,
+       [BT_VALUE_TYPE_STRING] =                bt_value_string_is_equal,
+       [BT_VALUE_TYPE_ARRAY] =                 bt_value_array_is_equal,
+       [BT_VALUE_TYPE_MAP] =                   bt_value_map_is_equal,
 };
 
 static
@@ -1382,7 +1382,7 @@ enum bt_value_copy_status bt_value_copy(const struct bt_value *object,
        return status;
 }
 
-bt_bool bt_value_compare(const struct bt_value *object_a,
+bt_bool bt_value_is_equal(const struct bt_value *object_a,
        const struct bt_value *object_b)
 {
        bt_bool ret = BT_FALSE;
@@ -1400,7 +1400,7 @@ bt_bool bt_value_compare(const struct bt_value *object_a,
                goto end;
        }
 
-       ret = compare_funcs[object_a->type](object_a, object_b);
+       ret = is_equal_funcs[object_a->type](object_a, object_b);
 
 end:
        return ret;

diff --git a/src/plugins/ctf/fs-sink/translate-trace-ir-to-ctf-ir.c b/src/plugins/ctf/fs-sink/translate-trace-ir-to-ctf-ir.c
index f2a2c7175527e9708ea54d12b329a968716e83e5..90f98e613c805e8e17fbb31e8ddb9b42b7d2d956 100644 (file)
--- a/src/plugins/ctf/fs-sink/translate-trace-ir-to-ctf-ir.c
+++ b/src/plugins/ctf/fs-sink/translate-trace-ir-to-ctf-ir.c
@@ -862,7 +862,7 @@ int maybe_protect_variant_option_name(const bt_field_class *ir_var_fc,
                        mapping_ranges = bt_field_class_enumeration_unsigned_mapping_borrow_ranges_const(
                                mapping);
 
-                       if (bt_integer_range_set_unsigned_compare(opt_ranges,
+                       if (bt_integer_range_set_unsigned_is_equal(opt_ranges,
                                        mapping_ranges)) {
                                /* We have a winner */
                                mapping_base =
@@ -883,7 +883,7 @@ int maybe_protect_variant_option_name(const bt_field_class *ir_var_fc,
                        mapping_ranges = bt_field_class_enumeration_signed_mapping_borrow_ranges_const(
                                mapping);
 
-                       if (bt_integer_range_set_signed_compare(opt_ranges,
+                       if (bt_integer_range_set_signed_is_equal(opt_ranges,
                                        mapping_ranges)) {
                                /* We have a winner */
                                mapping_base =
@@ -1092,7 +1092,7 @@ validate_opts:
                        opt_name_b =
                                bt_value_array_borrow_element_by_index_const(
                                        prot_opt_names, j);
-                       if (bt_value_compare(opt_name_a, opt_name_b)) {
+                       if (bt_value_is_equal(opt_name_a, opt_name_b)) {
                                /*
                                 * Variant FC option names are not
                                 * unique when protected.

diff --git a/tests/lib/plugin.c b/tests/lib/plugin.c
index 5990481286dc49bb4c83824f28b2dddaceb7604e..590cc29465031251c5588954154b938c49b3afd0 100644 (file)
--- a/tests/lib/plugin.c
+++ b/tests/lib/plugin.c
@@ -193,7 +193,7 @@ static void test_sfs(const char *plugin_dir)
        ok(strcmp(object_str, "get-something") == 0,
                "bt_component_class_query() receives the expected object name");
        res_params = bt_value_array_borrow_element_by_index_const(results, 1);
-       ok(bt_value_compare(res_params, params),
+       ok(bt_value_is_equal(res_params, params),
                "bt_component_class_query() receives the expected parameters");
 
        bt_component_class_sink_get_ref(sink_comp_class);

diff --git a/tests/lib/test_bt_values.c b/tests/lib/test_bt_values.c
index 97e26b97b26b97febc4dc1255ceef2ac311f1664..617bdc006edc8aacf755bd2cd95a2120c736b997 100644 (file)
--- a/tests/lib/test_bt_values.c
+++ b/tests/lib/test_bt_values.c
@@ -742,14 +742,14 @@ void test_types(void)
 }
 
 static
-void test_compare_null(void)
+void test_is_equal_null(void)
 {
-       ok(bt_value_compare(bt_value_null, bt_value_null),
+       ok(bt_value_is_equal(bt_value_null, bt_value_null),
                "null value objects are equivalent");
 }
 
 static
-void test_compare_bool(void)
+void test_is_equal_bool(void)
 {
        bt_value *bool1 =
                bt_value_bool_create_init(BT_FALSE);
@@ -759,14 +759,11 @@ void test_compare_bool(void)
                bt_value_bool_create_init(BT_FALSE);
 
        BT_ASSERT(bool1 && bool2 && bool3);
-       ok(!bt_value_compare(bt_value_null,
-               bool1),
+       ok(!bt_value_is_equal(bt_value_null, bool1),
                "cannot compare null value object and bt_bool value object");
-       ok(!bt_value_compare(bool1,
-                            bool2),
+       ok(!bt_value_is_equal(bool1, bool2),
                "boolean value objects are not equivalent (BT_FALSE and BT_TRUE)");
-       ok(bt_value_compare(bool1,
-                           bool3),
+       ok(bt_value_is_equal(bool1, bool3),
                "boolean value objects are equivalent (BT_FALSE and BT_FALSE)");
 
        BT_VALUE_PUT_REF_AND_RESET(bool1);
@@ -775,7 +772,7 @@ void test_compare_bool(void)
 }
 
 static
-void test_compare_unsigned_integer(void)
+void test_is_equal_unsigned_integer(void)
 {
        bt_value *int1 =
                bt_value_integer_unsigned_create_init(10);
@@ -785,12 +782,11 @@ void test_compare_unsigned_integer(void)
                bt_value_integer_unsigned_create_init(10);
 
        BT_ASSERT(int1 && int2 && int3);
-       ok(!bt_value_compare(bt_value_null,
-               int1),
+       ok(!bt_value_is_equal(bt_value_null, int1),
                "cannot compare null value object and unsigned integer value object");
-       ok(!bt_value_compare(int1, int2),
+       ok(!bt_value_is_equal(int1, int2),
                "unsigned integer value objects are not equivalent (10 and 23)");
-       ok(bt_value_compare(int1, int3),
+       ok(bt_value_is_equal(int1, int3),
                "unsigned integer value objects are equivalent (10 and 10)");
 
        BT_VALUE_PUT_REF_AND_RESET(int1);
@@ -798,7 +794,7 @@ void test_compare_unsigned_integer(void)
        BT_VALUE_PUT_REF_AND_RESET(int3);
 }
 
-void test_compare_signed_integer(void)
+void test_is_equal_signed_integer(void)
 {
        bt_value *int1 =
                bt_value_integer_signed_create_init(10);
@@ -808,12 +804,11 @@ void test_compare_signed_integer(void)
                bt_value_integer_signed_create_init(10);
 
        BT_ASSERT(int1 && int2 && int3);
-       ok(!bt_value_compare(bt_value_null,
-               int1),
+       ok(!bt_value_is_equal(bt_value_null, int1),
                "cannot compare null value object and signed integer value object");
-       ok(!bt_value_compare(int1, int2),
+       ok(!bt_value_is_equal(int1, int2),
                "signed integer value objects are not equivalent (10 and -23)");
-       ok(bt_value_compare(int1, int3),
+       ok(bt_value_is_equal(int1, int3),
                "signed integer value objects are equivalent (10 and 10)");
 
        BT_VALUE_PUT_REF_AND_RESET(int1);
@@ -822,7 +817,7 @@ void test_compare_signed_integer(void)
 }
 
 static
-void test_compare_real(void)
+void test_is_equal_real(void)
 {
        bt_value *real1 =
                bt_value_real_create_init(17.38);
@@ -833,14 +828,11 @@ void test_compare_real(void)
 
        BT_ASSERT(real1 && real2 && real3);
 
-       ok(!bt_value_compare(bt_value_null,
-               real1),
+       ok(!bt_value_is_equal(bt_value_null, real1),
                "cannot compare null value object and real number value object");
-       ok(!bt_value_compare(real1,
-                            real2),
+       ok(!bt_value_is_equal(real1, real2),
                "real number value objects are not equivalent (17.38 and -14.23)");
-       ok(bt_value_compare(real1,
-                           real3),
+       ok(bt_value_is_equal(real1, real3),
                "real number value objects are equivalent (17.38 and 17.38)");
 
        BT_VALUE_PUT_REF_AND_RESET(real1);
@@ -849,7 +841,7 @@ void test_compare_real(void)
 }
 
 static
-void test_compare_string(void)
+void test_is_equal_string(void)
 {
        bt_value *string1 =
                bt_value_string_create_init("hello");
@@ -860,14 +852,11 @@ void test_compare_string(void)
 
        BT_ASSERT(string1 && string2 && string3);
 
-       ok(!bt_value_compare(bt_value_null,
-               string1),
+       ok(!bt_value_is_equal(bt_value_null, string1),
                "cannot compare null value object and string value object");
-       ok(!bt_value_compare(string1,
-                            string2),
+       ok(!bt_value_is_equal(string1, string2),
                "string value objects are not equivalent (\"hello\" and \"bt_value\")");
-       ok(bt_value_compare(string1,
-                           string3),
+       ok(bt_value_is_equal(string1, string3),
                "string value objects are equivalent (\"hello\" and \"hello\")");
 
        BT_VALUE_PUT_REF_AND_RESET(string1);
@@ -876,7 +865,7 @@ void test_compare_string(void)
 }
 
 static
-void test_compare_array(void)
+void test_is_equal_array(void)
 {
        bt_value *array1 = bt_value_array_create();
        bt_value *array2 = bt_value_array_create();
@@ -885,7 +874,7 @@ void test_compare_array(void)
 
        BT_ASSERT(array1 && array2 && array3);
 
-       ok(bt_value_compare(array1, array2),
+       ok(bt_value_is_equal(array1, array2),
                "empty array value objects are equivalent");
 
        append_status = bt_value_array_append_signed_integer_element(array1, 23);
@@ -910,14 +899,11 @@ void test_compare_array(void)
        BT_ASSERT(bt_value_array_get_length(array2) == 3);
        BT_ASSERT(bt_value_array_get_length(array3) == 3);
 
-       ok(!bt_value_compare(bt_value_null,
-               array1),
+       ok(!bt_value_is_equal(bt_value_null, array1),
                "cannot compare null value object and array value object");
-       ok(!bt_value_compare(array1,
-                            array2),
+       ok(!bt_value_is_equal(array1, array2),
                "array value objects are not equivalent ([23, 14.2, BT_FALSE] and [14.2, 23, BT_FALSE])");
-       ok(bt_value_compare(array1,
-                           array3),
+       ok(bt_value_is_equal(array1, array3),
                "array value objects are equivalent ([23, 14.2, BT_FALSE] and [23, 14.2, BT_FALSE])");
 
        BT_VALUE_PUT_REF_AND_RESET(array1);
@@ -926,7 +912,7 @@ void test_compare_array(void)
 }
 
 static
-void test_compare_map(void)
+void test_is_equal_map(void)
 {
        bt_value *map1 = bt_value_map_create();
        bt_value *map2 = bt_value_map_create();
@@ -935,8 +921,7 @@ void test_compare_map(void)
 
        BT_ASSERT(map1 && map2 && map3);
 
-       ok(bt_value_compare(map1,
-                           map2),
+       ok(bt_value_is_equal(map1, map2),
                "empty map value objects are equivalent");
 
 
@@ -965,14 +950,11 @@ void test_compare_map(void)
        BT_ASSERT(bt_value_map_get_size(map2) == 3);
        BT_ASSERT(bt_value_map_get_size(map3) == 3);
 
-       ok(!bt_value_compare(bt_value_null,
-               map1),
+       ok(!bt_value_is_equal(bt_value_null, map1),
                "cannot compare null value object and map value object");
-       ok(!bt_value_compare(map1,
-                            map2),
+       ok(!bt_value_is_equal(map1, map2),
                "map value objects are not equivalent");
-       ok(bt_value_compare(map1,
-                           map3),
+       ok(bt_value_is_equal(map1, map3),
                "map value objects are equivalent");
 
        BT_VALUE_PUT_REF_AND_RESET(map1);
@@ -981,16 +963,16 @@ void test_compare_map(void)
 }
 
 static
-void test_compare(void)
+void test_is_equal(void)
 {
-       test_compare_null();
-       test_compare_bool();
-       test_compare_unsigned_integer();
-       test_compare_signed_integer();
-       test_compare_real();
-       test_compare_string();
-       test_compare_array();
-       test_compare_map();
+       test_is_equal_null();
+       test_is_equal_bool();
+       test_is_equal_unsigned_integer();
+       test_is_equal_signed_integer();
+       test_is_equal_real();
+       test_is_equal_string();
+       test_is_equal_array();
+       test_is_equal_map();
 }
 
 static
@@ -999,9 +981,9 @@ void test_copy(void)
        /*
         * Here's the deal here. If we make sure that each value object
         * of our deep copy has a different address than its source, and
-        * that bt_value_compare() returns BT_TRUE for the top-level
+        * that bt_value_is_equal() returns BT_TRUE for the top-level
         * value object, taking into account that we test the
-        * correctness of bt_value_compare() elsewhere, then the deep
+        * correctness of bt_value_is_equal() elsewhere, then the deep
         * copy is a success.
         */
        bt_value *null_copy_obj;
@@ -1077,7 +1059,7 @@ void test_copy(void)
        ok(null_copy_obj == bt_value_null,
                "bt_value_copy() returns the same pointer (null)");
 
-       ok(bt_value_compare(map_obj, map_copy_obj),
+       ok(bt_value_is_equal(map_obj, map_copy_obj),
                "source and destination value objects have the same content");
 
        BT_VALUE_PUT_REF_AND_RESET(map_copy_obj);
@@ -1100,7 +1082,7 @@ bt_bool compare_map_elements(const bt_value *map_a, const bt_value *map_b,
 
        elem_a = bt_value_map_borrow_entry_value_const(map_a, key);
        elem_b = bt_value_map_borrow_entry_value_const(map_b, key);
-       equal = bt_value_compare(elem_a, elem_b);
+       equal = bt_value_is_equal(elem_a, elem_b);
        return equal;
 }
 
@@ -1169,7 +1151,7 @@ int main(void)
 {
        plan_tests(NR_TESTS);
        test_types();
-       test_compare();
+       test_is_equal();
        test_copy();
        test_extend();
        return 0;