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>
extern int64_t bt_integer_range_signed_get_upper(
const bt_integer_range_signed *range);
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);
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);
const bt_integer_range_signed *range_a,
const bt_integer_range_signed *range_b);
bt_integer_range_set_signed_borrow_range_by_index_const(
const bt_integer_range_set_signed *range_set, uint64_t index);
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);
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);
const bt_integer_range_set_signed *range_set_a,
const bt_integer_range_set_signed *range_set_b);
extern bt_value_copy_status bt_value_copy(const bt_value *object,
bt_value **copy);
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);
const bt_value *object_b);
extern bt_bool bt_value_bool_get(const bt_value *bool_obj);
if not isinstance(other, _IntegerRangeSetConst):
return False
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:
def contains_value(self, value):
for rg in self:
)
_range_get_lower = staticmethod(native_bt.integer_range_signed_get_lower)
_range_get_upper = staticmethod(native_bt.integer_range_signed_get_upper)
)
_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
_range_pycls = _SignedIntegerRangeConst
)
_range_get_lower = staticmethod(native_bt.integer_range_unsigned_get_lower)
_range_get_upper = staticmethod(native_bt.integer_range_unsigned_get_upper)
)
_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
_range_pycls = _UnsignedIntegerRangeConst
range_a->upper.u == range_b->upper.u;
}
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)
{
const struct bt_integer_range_unsigned *range_a,
const struct bt_integer_range_unsigned *range_b)
{
(const void *) range_b);
}
(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)
{
const struct bt_integer_range_signed *range_a,
const struct bt_integer_range_signed *range_b)
{
-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)
{
const struct bt_integer_range_set_unsigned *range_set_a,
const struct bt_integer_range_set_unsigned *range_set_b)
{
(const void *) range_set_b);
}
(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)
{
const struct bt_integer_range_set_signed *range_set_a,
const struct bt_integer_range_set_signed *range_set_b)
{
-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)
{
/*
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.
*/
* 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.
*/
-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 !=
const struct bt_value *object_b)
{
if (BT_VALUE_TO_BOOL(object_a)->value !=
-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 !=
const struct bt_value *object_b)
{
if (BT_VALUE_TO_INTEGER(object_a)->value.u !=
-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 !=
const struct bt_value *object_b)
{
if (BT_VALUE_TO_REAL(object_a)->value !=
-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,
const struct bt_value *object_b)
{
if (strcmp(BT_VALUE_TO_STRING(object_a)->gstr->str,
-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;
const struct bt_value *object_b)
{
int i;
element_obj_b = bt_value_array_borrow_element_by_index_const(
object_b, i);
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);
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);
-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;
const struct bt_value *object_b)
{
bt_bool ret = BT_TRUE;
element_obj_b = bt_value_map_borrow_entry_value_const(object_b,
key_str);
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);
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);
-bt_bool (* const compare_funcs[])(const struct bt_value *,
+bt_bool (* const is_equal_funcs[])(const struct bt_value *,
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,
-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;
const struct bt_value *object_b)
{
bt_bool ret = BT_FALSE;
- ret = compare_funcs[object_a->type](object_a, object_b);
+ ret = is_equal_funcs[object_a->type](object_a, object_b);
mapping_ranges = bt_field_class_enumeration_unsigned_mapping_borrow_ranges_const(
mapping);
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 =
mapping_ranges)) {
/* We have a winner */
mapping_base =
mapping_ranges = bt_field_class_enumeration_signed_mapping_borrow_ranges_const(
mapping);
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 =
mapping_ranges)) {
/* We have a winner */
mapping_base =
opt_name_b =
bt_value_array_borrow_element_by_index_const(
prot_opt_names, j);
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.
/*
* Variant FC option names are not
* unique when protected.
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(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);
"bt_component_class_query() receives the expected parameters");
bt_component_class_sink_get_ref(sink_comp_class);
-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
"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);
{
bt_value *bool1 =
bt_value_bool_create_init(BT_FALSE);
bt_value_bool_create_init(BT_FALSE);
BT_ASSERT(bool1 && bool2 && bool3);
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");
"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)");
"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);
"boolean value objects are equivalent (BT_FALSE and BT_FALSE)");
BT_VALUE_PUT_REF_AND_RESET(bool1);
-void test_compare_unsigned_integer(void)
+void test_is_equal_unsigned_integer(void)
{
bt_value *int1 =
bt_value_integer_unsigned_create_init(10);
{
bt_value *int1 =
bt_value_integer_unsigned_create_init(10);
bt_value_integer_unsigned_create_init(10);
BT_ASSERT(int1 && int2 && int3);
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");
"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)");
"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);
"unsigned integer value objects are equivalent (10 and 10)");
BT_VALUE_PUT_REF_AND_RESET(int1);
BT_VALUE_PUT_REF_AND_RESET(int3);
}
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);
{
bt_value *int1 =
bt_value_integer_signed_create_init(10);
bt_value_integer_signed_create_init(10);
BT_ASSERT(int1 && int2 && int3);
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");
"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)");
"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);
"signed integer value objects are equivalent (10 and 10)");
BT_VALUE_PUT_REF_AND_RESET(int1);
-void test_compare_real(void)
+void test_is_equal_real(void)
{
bt_value *real1 =
bt_value_real_create_init(17.38);
{
bt_value *real1 =
bt_value_real_create_init(17.38);
BT_ASSERT(real1 && real2 && real3);
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");
"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)");
"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);
"real number value objects are equivalent (17.38 and 17.38)");
BT_VALUE_PUT_REF_AND_RESET(real1);
-void test_compare_string(void)
+void test_is_equal_string(void)
{
bt_value *string1 =
bt_value_string_create_init("hello");
{
bt_value *string1 =
bt_value_string_create_init("hello");
BT_ASSERT(string1 && string2 && string3);
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");
"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\")");
"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);
"string value objects are equivalent (\"hello\" and \"hello\")");
BT_VALUE_PUT_REF_AND_RESET(string1);
-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();
{
bt_value *array1 = bt_value_array_create();
bt_value *array2 = bt_value_array_create();
BT_ASSERT(array1 && array2 && array3);
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);
"empty array value objects are equivalent");
append_status = bt_value_array_append_signed_integer_element(array1, 23);
BT_ASSERT(bt_value_array_get_length(array2) == 3);
BT_ASSERT(bt_value_array_get_length(array3) == 3);
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");
"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])");
"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);
"array value objects are equivalent ([23, 14.2, BT_FALSE] and [23, 14.2, BT_FALSE])");
BT_VALUE_PUT_REF_AND_RESET(array1);
-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();
{
bt_value *map1 = bt_value_map_create();
bt_value *map2 = bt_value_map_create();
BT_ASSERT(map1 && map2 && map3);
BT_ASSERT(map1 && map2 && map3);
- ok(bt_value_compare(map1,
- map2),
+ ok(bt_value_is_equal(map1, map2),
"empty map value objects are equivalent");
"empty map value objects are equivalent");
BT_ASSERT(bt_value_map_get_size(map2) == 3);
BT_ASSERT(bt_value_map_get_size(map3) == 3);
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");
"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");
"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);
"map value objects are equivalent");
BT_VALUE_PUT_REF_AND_RESET(map1);
+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();
/*
* 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
/*
* 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
* 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;
* copy is a success.
*/
bt_value *null_copy_obj;
ok(null_copy_obj == bt_value_null,
"bt_value_copy() returns the same pointer (null)");
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);
"source and destination value objects have the same content");
BT_VALUE_PUT_REF_AND_RESET(map_copy_obj);
elem_a = bt_value_map_borrow_entry_value_const(map_a, key);
elem_b = bt_value_map_borrow_entry_value_const(map_b, key);
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);
{
plan_tests(NR_TESTS);
test_types();
{
plan_tests(NR_TESTS);
test_types();
test_copy();
test_extend();
return 0;
test_copy();
test_extend();
return 0;