/*
- * test_bt_values.c
+ * SPDX-License-Identifier: GPL-2.0-only
*
- * Babeltrace value objects tests
- *
- * Copyright (c) 2015 EfficiOS Inc. and Linux Foundation
- * Copyright (c) 2015 Philippe Proulx <pproulx@efficios.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; under version 2 of the License.
+ * Copyright (C) 2015 EfficiOS Inc. and Linux Foundation
+ * Copyright (C) 2015 Philippe Proulx <pproulx@efficios.com>
*
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * Babeltrace value objects tests
*/
#include <babeltrace2/babeltrace.h>
#include <string.h>
#include "tap/tap.h"
-#define NR_TESTS 166
+#define NR_TESTS 190
static
void test_null(void)
bt_value *obj;
const char *string_value;
bt_value *array_obj;
+ bt_value *appended_obj;
array_obj = bt_value_array_create();
ok(array_obj && bt_value_is_array(array_obj),
ret |= bt_value_array_append_element(array_obj,
bt_value_null);
ok(!ret, "bt_value_array_append_element() succeeds");
- ok(bt_value_array_get_size(array_obj) == 5,
+ ok(bt_value_array_get_length(array_obj) == 5,
"appending an element to an array value object increment its size");
obj = bt_value_array_borrow_element_by_index(array_obj, 0);
- ok(obj && bt_value_is_unsigned_integer(obj),
+ ok(bt_value_is_unsigned_integer(obj),
"bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (unsigned integer)");
int_value = bt_value_integer_unsigned_get(obj);
ok(int_value == 345,
"bt_value_array_borrow_element_by_index() returns an value object with the appropriate value (unsigned integer)");
obj = bt_value_array_borrow_element_by_index(array_obj, 1);
- ok(obj && bt_value_is_signed_integer(obj),
+ ok(bt_value_is_signed_integer(obj),
"bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (signed integer)");
int_value = bt_value_integer_signed_get(obj);
ok(int_value == -507,
"bt_value_array_borrow_element_by_index() returns an value object with the appropriate value (signed integer)");
obj = bt_value_array_borrow_element_by_index(array_obj, 2);
- ok(obj && bt_value_is_real(obj),
+ ok(bt_value_is_real(obj),
"bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (real number)");
real_value = bt_value_real_get(obj);
ok(real_value == -17.45,
"bt_value_array_borrow_element_by_index() returns an value object with the appropriate value (real number)");
obj = bt_value_array_borrow_element_by_index(array_obj, 3);
- ok(obj && bt_value_is_bool(obj),
+ ok(bt_value_is_bool(obj),
"bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (boolean)");
bool_value = bt_value_bool_get(obj);
ok(bool_value,
"bt_value_array_borrow_element_by_index() returns an value object with the appropriate value (boolean)");
obj = bt_value_array_borrow_element_by_index(array_obj, 4);
- ok(obj == bt_value_null,
+ ok(bt_value_null,
"bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (null)");
obj = bt_value_integer_signed_create_init(1001);
"bt_value_array_set_element_by_index() succeeds");
BT_VALUE_PUT_REF_AND_RESET(obj);
obj = bt_value_array_borrow_element_by_index(array_obj, 2);
- ok(obj && bt_value_is_signed_integer(obj),
+ ok(bt_value_is_signed_integer(obj),
"bt_value_array_set_element_by_index() inserts an value object with the appropriate type");
int_value = bt_value_integer_signed_get(obj);
BT_ASSERT(!ret);
ret = bt_value_array_append_string_element(array_obj,
"bt_value");
ok(!ret, "bt_value_array_append_string_element() succeeds");
- ret = bt_value_array_append_empty_array_element(array_obj);
+ ret = bt_value_array_append_empty_array_element(array_obj, NULL);
ok(!ret, "bt_value_array_append_empty_array_element() succeeds");
- ret = bt_value_array_append_empty_map_element(array_obj);
+ ret = bt_value_array_append_empty_array_element(array_obj, &appended_obj);
+ ok(!ret, "bt_value_array_append_empty_array_element() with returned value object succeeds");
+ ok(appended_obj,
+ "object returned by bt_value_array_append_empty_array_element() is not NULL");
+ ok(bt_value_is_array(appended_obj),
+ "object returned by bt_value_array_append_empty_array_element() is an array value");
+ ret = bt_value_array_append_empty_map_element(array_obj, NULL);
ok(!ret, "bt_value_array_append_empty_map_element() succeeds");
-
- ok(bt_value_array_get_size(array_obj) == 12,
+ ret = bt_value_array_append_empty_map_element(array_obj, &appended_obj);
+ ok(!ret, "bt_value_array_append_empty_map_element() with returned value object succeeds");
+ ok(appended_obj,
+ "object returned by bt_value_array_append_empty_map_element() is not NULL");
+ ok(bt_value_is_map(appended_obj),
+ "object returned by bt_value_array_append_empty_map_element() is an array value");
+
+ ok(bt_value_array_get_length(array_obj) == 14,
"the bt_value_array_append_element_*() functions increment the array value object's size");
ok(!bt_value_array_is_empty(array_obj),
"map value object is not empty");
obj = bt_value_array_borrow_element_by_index(array_obj, 5);
- ok(obj && bt_value_is_bool(obj),
+ ok(bt_value_is_bool(obj),
"bt_value_array_append_bool_element() appends a boolean value object");
bool_value = bt_value_bool_get(obj);
ok(!bool_value,
"bt_value_array_append_bool_element() appends the appropriate value");
obj = bt_value_array_borrow_element_by_index(array_obj, 6);
- ok(obj && bt_value_is_unsigned_integer(obj),
+ ok(bt_value_is_unsigned_integer(obj),
"bt_value_array_append_unsigned_integer_element() appends an unsigned integer value object");
int_value = bt_value_integer_unsigned_get(obj);
ok(int_value == 98765,
"bt_value_array_append_unsigned_integer_element() appends the appropriate value");
obj = bt_value_array_borrow_element_by_index(array_obj, 7);
- ok(obj && bt_value_is_signed_integer(obj),
+ ok(bt_value_is_signed_integer(obj),
"bt_value_array_append_signed_integer_element() appends a signed integer value object");
int_value = bt_value_integer_signed_get(obj);
ok(int_value == -10101,
"bt_value_array_append_signed_integer_element() appends the appropriate value");
obj = bt_value_array_borrow_element_by_index(array_obj, 8);
- ok(obj && bt_value_is_real(obj),
+ ok(bt_value_is_real(obj),
"bt_value_array_append_real_element() appends a real number value object");
real_value = bt_value_real_get(obj);
ok(real_value == 2.49578,
"bt_value_array_append_real_element() appends the appropriate value");
obj = bt_value_array_borrow_element_by_index(array_obj, 9);
- ok(obj && bt_value_is_string(obj),
+ ok(bt_value_is_string(obj),
"bt_value_array_append_string_element() appends a string value object");
string_value = bt_value_string_get(obj);
ok(!ret && string_value && strcmp(string_value, "bt_value") == 0,
"bt_value_array_append_string_element() appends the appropriate value");
obj = bt_value_array_borrow_element_by_index(array_obj, 10);
- ok(obj && bt_value_is_array(obj),
+ ok(bt_value_is_array(obj),
"bt_value_array_append_empty_array_element() appends an array value object");
ok(bt_value_array_is_empty(obj),
"bt_value_array_append_empty_array_element() an empty array value object");
obj = bt_value_array_borrow_element_by_index(array_obj, 11);
- ok(obj && bt_value_is_map(obj),
+ ok(bt_value_is_array(obj),
+ "bt_value_array_append_empty_array_element() appends an array value object");
+ ok(bt_value_array_is_empty(obj),
+ "bt_value_array_append_empty_array_element() an empty array value object");
+ obj = bt_value_array_borrow_element_by_index(array_obj, 12);
+ ok(bt_value_is_map(obj),
+ "bt_value_array_append_empty_map_element() appends a map value object");
+ ok(bt_value_map_is_empty(obj),
+ "bt_value_array_append_empty_map_element() an empty map value object");
+ obj = bt_value_array_borrow_element_by_index(array_obj, 13);
+ ok(bt_value_is_map(obj),
"bt_value_array_append_empty_map_element() appends a map value object");
ok(bt_value_map_is_empty(obj),
"bt_value_array_append_empty_map_element() an empty map value object");
}
static
-bt_bool test_map_foreach_cb_count(const char *key, bt_value *object,
+bt_value_map_foreach_entry_func_status test_map_foreach_cb_count(
+ const char *key, bt_value *object,
void *data)
{
int *count = data;
if (*count == 3) {
- return BT_FALSE;
+ return BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_INTERRUPT;
+ } else if (*count == 4) {
+ return BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_ERROR;
+ } else if (*count == 5) {
+ return BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_MEMORY_ERROR;
}
(*count)++;
- return BT_TRUE;
+ return BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_OK;
}
struct map_foreach_checklist {
bt_bool real2;
bt_bool string2;
bt_bool array2;
+ bt_bool array3;
bt_bool map2;
+ bt_bool map3;
};
static
-bt_bool test_map_foreach_cb_check(const char *key, bt_value *object,
- void *data)
+bt_value_map_foreach_entry_func_status test_map_foreach_cb_check(
+ const char *key, bt_value *object, void *data)
{
struct map_foreach_checklist *checklist = data;
"test_map_foreach_cb_check(): \"array2\" value object is empty");
checklist->array2 = BT_TRUE;
}
+ } else if (strcmp(key, "array3") == 0) {
+ if (checklist->array3) {
+ fail("test_map_foreach_cb_check(): duplicate key \"array3\"");
+ } else {
+ ok(bt_value_is_array(object), "test_map_foreach_cb_check(): success getting \"array3\" value object");
+ ok(bt_value_array_is_empty(object),
+ "test_map_foreach_cb_check(): \"array3\" value object is empty");
+ checklist->array3 = BT_TRUE;
+ }
+ } else if (strcmp(key, "map3") == 0) {
+ if (checklist->map3) {
+ fail("test_map_foreach_cb_check(): duplicate key \"map3\"");
+ } else {
+ ok(bt_value_is_map(object), "test_map_foreach_cb_check(): success getting \"map3\" value object");
+ ok(bt_value_map_is_empty(object),
+ "test_map_foreach_cb_check(): \"map3\" value object is empty");
+ checklist->map3 = BT_TRUE;
+ }
} else if (strcmp(key, "map2") == 0) {
if (checklist->map2) {
fail("test_map_foreach_cb_check(): duplicate key \"map2\"");
key);
}
- return BT_TRUE;
+ return BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_OK;
}
static
double real_value;
bt_value *obj;
bt_value *map_obj;
+ bt_value *inserted_obj;
struct map_foreach_checklist checklist;
map_obj = bt_value_map_create();
ret = bt_value_map_insert_string_entry(map_obj, "string2",
"bt_value");
ok(!ret, "bt_value_map_insert_string_entry() succeeds");
- ret = bt_value_map_insert_empty_array_entry(map_obj,
- "array2");
+ ret = bt_value_map_insert_empty_array_entry(map_obj, "array2", NULL);
ok(!ret, "bt_value_map_insert_empty_array_entry() succeeds");
- ret = bt_value_map_insert_empty_map_entry(map_obj, "map2");
+ ret = bt_value_map_insert_empty_array_entry(map_obj, "array3", &inserted_obj);
+ ok(!ret, "bt_value_map_insert_empty_array_entry() with returned value object succeeds");
+ ok(inserted_obj,
+ "object returned by bt_value_map_insert_empty_array_entry() is not NULL");
+ ok(bt_value_is_array(inserted_obj),
+ "object returned by bt_value_map_insert_empty_array_entry() is an array value");
+ ret = bt_value_map_insert_empty_map_entry(map_obj, "map2", NULL);
ok(!ret, "bt_value_map_insert_empty_map_entry() succeeds");
-
- ok(bt_value_map_get_size(map_obj) == 11,
+ ret = bt_value_map_insert_empty_map_entry(map_obj, "map3", &inserted_obj);
+ ok(!ret, "bt_value_map_insert_empty_map_entry() with returned value object succeeds");
+ ok(inserted_obj,
+ "object returned by bt_value_map_insert_empty_map_entry() is not NULL");
+ ok(bt_value_is_map(inserted_obj),
+ "object returned by bt_value_map_insert_empty_map_entry() is an array value");
+
+ ok(bt_value_map_get_size(map_obj) == 13,
"the bt_value_map_insert*() functions increment the map value object's size");
ok(!bt_value_map_has_entry(map_obj, "hello"),
"map value object has key \"string2\"");
ok(bt_value_map_has_entry(map_obj, "array2"),
"map value object has key \"array2\"");
+ ok(bt_value_map_has_entry(map_obj, "array3"),
+ "map value object has key \"array3\"");
ok(bt_value_map_has_entry(map_obj, "map2"),
"map value object has key \"map2\"");
+ ok(bt_value_map_has_entry(map_obj, "map3"),
+ "map value object has key \"map3\"");
ret = bt_value_map_foreach_entry(map_obj, test_map_foreach_cb_count,
&count);
ok(ret == BT_VALUE_MAP_FOREACH_ENTRY_STATUS_INTERRUPTED && count == 3,
- "bt_value_map_foreach_entry() breaks the loop when the user function returns BT_FALSE");
+ "bt_value_map_foreach_entry() breaks the loop when the user function returns BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_INTERRUPT");
+
+ count = 4;
+ ret = bt_value_map_foreach_entry(map_obj, test_map_foreach_cb_count,
+ &count);
+ ok(ret == BT_VALUE_MAP_FOREACH_ENTRY_STATUS_USER_ERROR,
+ "bt_value_map_foreach_entry() fails when the user function returns BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_ERROR");
+ bt_current_thread_clear_error();
+
+ count = 5;
+ ret = bt_value_map_foreach_entry(map_obj, test_map_foreach_cb_count,
+ &count);
+ ok(ret == BT_VALUE_MAP_FOREACH_ENTRY_STATUS_MEMORY_ERROR,
+ "bt_value_map_foreach_entry() fails when the user function returns BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_MEMORY_ERROR");
+ bt_current_thread_clear_error();
memset(&checklist, 0, sizeof(checklist));
ret = bt_value_map_foreach_entry(map_obj, test_map_foreach_cb_check,
}
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);
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);
}
static
-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_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);
BT_VALUE_PUT_REF_AND_RESET(int3);
}
-void test_compare_signed_integer(void)
+static
+void test_is_equal_signed_integer(void)
{
bt_value *int1 =
bt_value_integer_signed_create_init(10);
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);
}
static
-void test_compare_real(void)
+void test_is_equal_real(void)
{
bt_value *real1 =
bt_value_real_create_init(17.38);
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);
}
static
-void test_compare_string(void)
+void test_is_equal_string(void)
{
bt_value *string1 =
bt_value_string_create_init("hello");
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);
}
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();
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);
BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK);
append_status = bt_value_array_append_bool_element(array3, BT_FALSE);
BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK);
- BT_ASSERT(bt_value_array_get_size(array1) == 3);
- BT_ASSERT(bt_value_array_get_size(array2) == 3);
- BT_ASSERT(bt_value_array_get_size(array3) == 3);
+ BT_ASSERT(bt_value_array_get_length(array1) == 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");
- 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);
}
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();
BT_ASSERT(map1 && map2 && map3);
- ok(bt_value_compare(map1,
- map2),
+ ok(bt_value_is_equal(map1, map2),
"empty map value objects are equivalent");
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);
}
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
/*
* 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;
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);
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;
}
bt_value *extended_map = NULL;
bt_value *array = bt_value_array_create();
bt_value_map_insert_entry_status insert_status;
+ bt_value_copy_status copy_status;
bt_value_map_extend_status extend_status;
BT_ASSERT(base_map);
insert_status = bt_value_map_insert_real_entry(extension_map,
"project", -404);
BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK);
- extend_status = bt_value_map_extend(base_map, extension_map, &extended_map);
+ copy_status = bt_value_copy(base_map, &extended_map);
+ BT_ASSERT(copy_status == BT_VALUE_COPY_STATUS_OK);
+ extend_status = bt_value_map_extend(extended_map, extension_map);
ok(extend_status == BT_VALUE_MAP_EXTEND_STATUS_OK &&
extended_map, "bt_value_map_extend() succeeds");
ok(bt_value_map_get_size(extended_map) == 5,
{
plan_tests(NR_TESTS);
test_types();
- test_compare();
+ test_is_equal();
test_copy();
test_extend();
return 0;
projects / babeltrace.git / blobdiff