ok(bt_value_null, "bt_value_null is not NULL");
ok(bt_value_is_null(bt_value_null),
"bt_value_null is a null value object");
- bt_object_get_ref(bt_value_null);
+ bt_value_get_ref(bt_value_null);
pass("getting bt_value_null does not cause a crash");
- bt_object_put_ref(bt_value_null);
+ bt_value_put_ref(bt_value_null);
pass("putting bt_value_null does not cause a crash");
}
void test_bool(void)
{
bt_bool value;
- struct bt_value *obj;
+ bt_value *obj;
obj = bt_value_bool_create();
ok(obj && bt_value_is_bool(obj),
value = bt_value_bool_get(obj);
ok(value, "bt_value_bool_set() works");
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
pass("putting an existing boolean value object does not cause a crash")
value = BT_FALSE;
ok(value,
"bt_value_bool_create_init() sets the appropriate initial value");
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
}
static
void test_integer(void)
{
int64_t value;
- struct bt_value *obj;
+ bt_value *obj;
obj = bt_value_integer_create();
ok(obj && bt_value_is_integer(obj),
value = bt_value_integer_get(obj);
ok(value == -98765, "bt_private_integer_bool_set() works");
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
pass("putting an existing integer value object does not cause a crash")
obj = bt_value_integer_create_init(321456987);
ok(value == 321456987,
"bt_value_integer_create_init() sets the appropriate initial value");
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
}
static
void test_real(void)
{
double value;
- struct bt_value *obj;
+ bt_value *obj;
obj = bt_value_real_create();
ok(obj && bt_value_is_real(obj),
value = bt_value_real_get(obj);
ok(value == -3.1416, "bt_value_real_set() works");
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
pass("putting an existing real number value object does not cause a crash")
obj = bt_value_real_create_init(33.1649758);
ok(value == 33.1649758,
"bt_value_real_create_init() sets the appropriate initial value");
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
}
static
void test_string(void)
{
const char *value;
- struct bt_value *obj;
+ bt_value *obj;
obj = bt_value_string_create();
ok(obj && bt_value_is_string(obj),
ok(value && !strcmp(value, "hello worldz"),
"bt_value_string_get() works");
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
pass("putting an existing string value object does not cause a crash")
obj = bt_value_string_create_init("initial value");
ok(value && !strcmp(value, "initial value"),
"bt_value_string_create_init() sets the appropriate initial value");
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
}
static
bt_bool bool_value;
int64_t int_value;
double real_value;
- struct bt_value *obj;
+ bt_value *obj;
const char *string_value;
- struct bt_value *array_obj;
+ bt_value *array_obj;
array_obj = bt_value_array_create();
ok(array_obj && bt_value_is_array(array_obj),
obj = bt_value_integer_create_init(345);
ret = bt_value_array_append_element(array_obj, obj);
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
obj = bt_value_real_create_init(-17.45);
ret |= bt_value_array_append_element(array_obj, obj);
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
obj = bt_value_bool_create_init(BT_TRUE);
ret |= bt_value_array_append_element(array_obj, obj);
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
ret |= bt_value_array_append_element(array_obj,
bt_value_null);
ok(!ret, "bt_value_array_append_element() succeeds");
BT_ASSERT(obj);
ok(!bt_value_array_set_element_by_index(array_obj, 2, obj),
"bt_value_array_set_element_by_index() succeeds");
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
obj = bt_value_array_borrow_element_by_index(array_obj, 2);
ok(obj && bt_value_is_integer(obj),
"bt_value_array_set_element_by_index() inserts an value object with the appropriate type");
ok(bt_value_map_is_empty(obj),
"bt_value_array_append_empty_map_element() an empty map value object");
- BT_OBJECT_PUT_REF_AND_RESET(array_obj);
+ BT_VALUE_PUT_REF_AND_RESET(array_obj);
pass("putting an existing array value object does not cause a crash")
}
static
-bt_bool test_map_foreach_cb_count(const char *key, struct bt_value *object,
+bt_bool test_map_foreach_cb_count(const char *key, bt_value *object,
void *data)
{
int *count = data;
};
static
-bt_bool test_map_foreach_cb_check(const char *key, struct bt_value *object,
+bt_bool test_map_foreach_cb_check(const char *key, bt_value *object,
void *data)
{
struct map_foreach_checklist *checklist = data;
bt_bool bool_value;
int64_t int_value;
double real_value;
- struct bt_value *obj;
- struct bt_value *map_obj;
+ bt_value *obj;
+ bt_value *map_obj;
struct map_foreach_checklist checklist;
map_obj = bt_value_map_create();
obj = bt_value_integer_create_init(19457);
ret = bt_value_map_insert_entry(map_obj, "int", obj);
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
obj = bt_value_real_create_init(5.444);
ret |= bt_value_map_insert_entry(map_obj, "real", obj);
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
obj = bt_value_bool_create();
ret |= bt_value_map_insert_entry(map_obj, "bt_bool", obj);
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
ret |= bt_value_map_insert_entry(map_obj, "null",
bt_value_null);
ok(!ret, "bt_value_map_insert_entry() succeeds");
obj = bt_value_bool_create_init(BT_TRUE);
ret = bt_value_map_insert_entry(map_obj, "bt_bool", obj);
- BT_OBJECT_PUT_REF_AND_RESET(obj);
+ BT_VALUE_PUT_REF_AND_RESET(obj);
ok(!ret, "bt_value_map_insert_entry() accepts an existing key");
obj = bt_value_map_borrow_entry_value(map_obj, "life");
checklist.array2 && checklist.map2,
"bt_value_map_foreach_entry() iterates over all the map value object's elements");
- BT_OBJECT_PUT_REF_AND_RESET(map_obj);
+ BT_VALUE_PUT_REF_AND_RESET(map_obj);
pass("putting an existing map value object does not cause a crash")
}
static
void test_compare_bool(void)
{
- struct bt_value *bool1 =
+ bt_value *bool1 =
bt_value_bool_create_init(BT_FALSE);
- struct bt_value *bool2 =
+ bt_value *bool2 =
bt_value_bool_create_init(BT_TRUE);
- struct bt_value *bool3 =
+ bt_value *bool3 =
bt_value_bool_create_init(BT_FALSE);
BT_ASSERT(bool1 && bool2 && bool3);
bool3),
"boolean value objects are equivalent (BT_FALSE and BT_FALSE)");
- BT_OBJECT_PUT_REF_AND_RESET(bool1);
- BT_OBJECT_PUT_REF_AND_RESET(bool2);
- BT_OBJECT_PUT_REF_AND_RESET(bool3);
+ BT_VALUE_PUT_REF_AND_RESET(bool1);
+ BT_VALUE_PUT_REF_AND_RESET(bool2);
+ BT_VALUE_PUT_REF_AND_RESET(bool3);
}
static
void test_compare_integer(void)
{
- struct bt_value *int1 =
+ bt_value *int1 =
bt_value_integer_create_init(10);
- struct bt_value *int2 =
+ bt_value *int2 =
bt_value_integer_create_init(-23);
- struct bt_value *int3 =
+ bt_value *int3 =
bt_value_integer_create_init(10);
BT_ASSERT(int1 && int2 && int3);
int3),
"integer value objects are equivalent (10 and 10)");
- BT_OBJECT_PUT_REF_AND_RESET(int1);
- BT_OBJECT_PUT_REF_AND_RESET(int2);
- BT_OBJECT_PUT_REF_AND_RESET(int3);
+ BT_VALUE_PUT_REF_AND_RESET(int1);
+ BT_VALUE_PUT_REF_AND_RESET(int2);
+ BT_VALUE_PUT_REF_AND_RESET(int3);
}
static
void test_compare_real(void)
{
- struct bt_value *real1 =
+ bt_value *real1 =
bt_value_real_create_init(17.38);
- struct bt_value *real2 =
+ bt_value *real2 =
bt_value_real_create_init(-14.23);
- struct bt_value *real3 =
+ bt_value *real3 =
bt_value_real_create_init(17.38);
BT_ASSERT(real1 && real2 && real3);
real3),
"real number value objects are equivalent (17.38 and 17.38)");
- BT_OBJECT_PUT_REF_AND_RESET(real1);
- BT_OBJECT_PUT_REF_AND_RESET(real2);
- BT_OBJECT_PUT_REF_AND_RESET(real3);
+ BT_VALUE_PUT_REF_AND_RESET(real1);
+ BT_VALUE_PUT_REF_AND_RESET(real2);
+ BT_VALUE_PUT_REF_AND_RESET(real3);
}
static
void test_compare_string(void)
{
- struct bt_value *string1 =
+ bt_value *string1 =
bt_value_string_create_init("hello");
- struct bt_value *string2 =
+ bt_value *string2 =
bt_value_string_create_init("bt_value");
- struct bt_value *string3 =
+ bt_value *string3 =
bt_value_string_create_init("hello");
BT_ASSERT(string1 && string2 && string3);
string3),
"string value objects are equivalent (\"hello\" and \"hello\")");
- BT_OBJECT_PUT_REF_AND_RESET(string1);
- BT_OBJECT_PUT_REF_AND_RESET(string2);
- BT_OBJECT_PUT_REF_AND_RESET(string3);
+ BT_VALUE_PUT_REF_AND_RESET(string1);
+ BT_VALUE_PUT_REF_AND_RESET(string2);
+ BT_VALUE_PUT_REF_AND_RESET(string3);
}
static
void test_compare_array(void)
{
- struct bt_value *array1 = bt_value_array_create();
- struct bt_value *array2 = bt_value_array_create();
- struct bt_value *array3 = bt_value_array_create();
- enum bt_value_status status;
+ bt_value *array1 = bt_value_array_create();
+ bt_value *array2 = bt_value_array_create();
+ bt_value *array3 = bt_value_array_create();
+ bt_value_status status;
BT_ASSERT(array1 && array2 && array3);
array3),
"array value objects are equivalent ([23, 14.2, BT_FALSE] and [23, 14.2, BT_FALSE])");
- BT_OBJECT_PUT_REF_AND_RESET(array1);
- BT_OBJECT_PUT_REF_AND_RESET(array2);
- BT_OBJECT_PUT_REF_AND_RESET(array3);
+ BT_VALUE_PUT_REF_AND_RESET(array1);
+ BT_VALUE_PUT_REF_AND_RESET(array2);
+ BT_VALUE_PUT_REF_AND_RESET(array3);
}
static
void test_compare_map(void)
{
- struct bt_value *map1 = bt_value_map_create();
- struct bt_value *map2 = bt_value_map_create();
- struct bt_value *map3 = bt_value_map_create();
- enum bt_value_status status;
+ bt_value *map1 = bt_value_map_create();
+ bt_value *map2 = bt_value_map_create();
+ bt_value *map3 = bt_value_map_create();
+ bt_value_status status;
BT_ASSERT(map1 && map2 && map3);
map3),
"map value objects are equivalent");
- BT_OBJECT_PUT_REF_AND_RESET(map1);
- BT_OBJECT_PUT_REF_AND_RESET(map2);
- BT_OBJECT_PUT_REF_AND_RESET(map3);
+ BT_VALUE_PUT_REF_AND_RESET(map1);
+ BT_VALUE_PUT_REF_AND_RESET(map2);
+ BT_VALUE_PUT_REF_AND_RESET(map3);
}
static
* bt_value_compare() elsewhere, then the deep copy is a
* success.
*/
- struct bt_value *null_copy_obj;
- struct bt_value *bool_obj, *bool_copy_obj;
- struct bt_value *integer_obj, *integer_copy_obj;
- struct bt_value *real_obj, *real_copy_obj;
- struct bt_value *string_obj, *string_copy_obj;
- struct bt_value *array_obj, *array_copy_obj;
- struct bt_value *map_obj, *map_copy_obj;
- enum bt_value_status status;
+ bt_value *null_copy_obj;
+ bt_value *bool_obj, *bool_copy_obj;
+ bt_value *integer_obj, *integer_copy_obj;
+ bt_value *real_obj, *real_copy_obj;
+ bt_value *string_obj, *string_copy_obj;
+ bt_value *array_obj, *array_copy_obj;
+ bt_value *map_obj, *map_copy_obj;
+ bt_value_status status;
bool_obj = bt_value_bool_create_init(BT_TRUE);
integer_obj = bt_value_integer_create_init(23);
string_obj);
BT_ASSERT(status == BT_VALUE_STATUS_OK);
- status = bt_value_copy(&map_copy_obj,
- map_obj);
+ status = bt_value_copy(map_obj, &map_copy_obj);
ok(status == BT_VALUE_STATUS_OK && map_copy_obj,
"bt_value_copy() succeeds");
map_copy_obj),
"source and destination value objects have the same content");
- BT_OBJECT_PUT_REF_AND_RESET(map_copy_obj);
- BT_OBJECT_PUT_REF_AND_RESET(bool_obj);
- BT_OBJECT_PUT_REF_AND_RESET(integer_obj);
- BT_OBJECT_PUT_REF_AND_RESET(real_obj);
- BT_OBJECT_PUT_REF_AND_RESET(string_obj);
- BT_OBJECT_PUT_REF_AND_RESET(array_obj);
- BT_OBJECT_PUT_REF_AND_RESET(map_obj);
+ BT_VALUE_PUT_REF_AND_RESET(map_copy_obj);
+ BT_VALUE_PUT_REF_AND_RESET(bool_obj);
+ BT_VALUE_PUT_REF_AND_RESET(integer_obj);
+ BT_VALUE_PUT_REF_AND_RESET(real_obj);
+ BT_VALUE_PUT_REF_AND_RESET(string_obj);
+ BT_VALUE_PUT_REF_AND_RESET(array_obj);
+ BT_VALUE_PUT_REF_AND_RESET(map_obj);
}
static
-bt_bool compare_map_elements(const struct bt_value *map_a, const struct bt_value *map_b,
+bt_bool compare_map_elements(const bt_value *map_a, const bt_value *map_b,
const char *key)
{
- const struct bt_value *elem_a = NULL;
- const struct bt_value *elem_b = NULL;
+ const bt_value *elem_a = NULL;
+ const bt_value *elem_b = NULL;
bt_bool equal;
elem_a = bt_value_map_borrow_entry_value_const(map_a, key);
static
void test_extend(void)
{
- struct bt_value *base_map = bt_value_map_create();
- struct bt_value *extension_map = bt_value_map_create();
- struct bt_value *extended_map = NULL;
- struct bt_value *array = bt_value_array_create();
- enum bt_value_status status;
+ bt_value *base_map = bt_value_map_create();
+ bt_value *extension_map = bt_value_map_create();
+ bt_value *extended_map = NULL;
+ bt_value *array = bt_value_array_create();
+ bt_value_status status;
BT_ASSERT(base_map);
BT_ASSERT(extension_map);
status = bt_value_map_insert_real_entry(extension_map,
"project", -404);
BT_ASSERT(status == BT_VALUE_STATUS_OK);
- status = bt_value_map_extend(
- &extended_map,
- base_map,
- extension_map);
+ status = bt_value_map_extend(base_map, extension_map, &extended_map);
ok(status == BT_VALUE_STATUS_OK &&
extended_map, "bt_value_map_extend() succeeds");
ok(bt_value_map_get_size(extended_map) == 5,
extended_map, "project"),
"bt_value_map_extend() picks the appropriate element (project)");
- BT_OBJECT_PUT_REF_AND_RESET(array);
- BT_OBJECT_PUT_REF_AND_RESET(base_map);
- BT_OBJECT_PUT_REF_AND_RESET(extension_map);
- BT_OBJECT_PUT_REF_AND_RESET(extended_map);
+ BT_VALUE_PUT_REF_AND_RESET(array);
+ BT_VALUE_PUT_REF_AND_RESET(base_map);
+ BT_VALUE_PUT_REF_AND_RESET(extension_map);
+ BT_VALUE_PUT_REF_AND_RESET(extended_map);
}
int main(void)