X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Flib%2Ftest_bt_values.c;h=6a6ca7c3560a433a48ee4c7882cade7722195deb;hb=05e2128659970c32648a01255ed870449f05d518;hp=52a2f559a3a8d8437c92d883b0b5a5a3fa2f35e6;hpb=398454ed067b95215c7affbe265fd36edab931ee;p=babeltrace.git diff --git a/tests/lib/test_bt_values.c b/tests/lib/test_bt_values.c index 52a2f559..6a6ca7c3 100644 --- a/tests/lib/test_bt_values.c +++ b/tests/lib/test_bt_values.c @@ -20,9 +20,7 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#include -#include -#include +#include #include #include #include "tap/tap.h" @@ -45,140 +43,128 @@ static void test_bool(void) { bt_bool value; - struct bt_private_value *priv_obj; struct bt_value *obj; - priv_obj = bt_private_value_bool_create(); - obj = bt_private_value_as_value(priv_obj); + obj = bt_value_bool_create(); ok(obj && bt_value_is_bool(obj), - "bt_private_value_bool_create() returns a boolean value object"); + "bt_value_bool_create() returns a boolean value object"); value = BT_TRUE; value = bt_value_bool_get(obj); ok(!value, "default boolean value object value is BT_FALSE"); - bt_private_value_bool_set(priv_obj, BT_FALSE); - bt_private_value_bool_set(priv_obj, BT_TRUE); + bt_value_bool_set(obj, BT_FALSE); + bt_value_bool_set(obj, BT_TRUE); value = bt_value_bool_get(obj); - ok(value, "bt_private_value_bool_set() works"); + ok(value, "bt_value_bool_set() works"); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); pass("putting an existing boolean value object does not cause a crash") value = BT_FALSE; - priv_obj = bt_private_value_bool_create_init(BT_TRUE); - obj = bt_private_value_as_value(priv_obj); + obj = bt_value_bool_create_init(BT_TRUE); ok(obj && bt_value_is_bool(obj), - "bt_private_value_bool_create_init() returns a boolean value object"); + "bt_value_bool_create_init() returns a boolean value object"); value = bt_value_bool_get(obj); ok(value, - "bt_private_value_bool_create_init() sets the appropriate initial value"); + "bt_value_bool_create_init() sets the appropriate initial value"); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); } static void test_integer(void) { int64_t value; - struct bt_private_value *priv_obj; struct bt_value *obj; - priv_obj = bt_private_value_integer_create(); - obj = bt_private_value_as_value(priv_obj); + obj = bt_value_integer_create(); ok(obj && bt_value_is_integer(obj), - "bt_private_value_integer_create() returns an integer value object"); + "bt_value_integer_create() returns an integer value object"); value = 1961; value = bt_value_integer_get(obj); ok(value == 0, "default integer value object value is 0"); - bt_private_value_integer_set(priv_obj, -98765); + bt_value_integer_set(obj, -98765); value = bt_value_integer_get(obj); ok(value == -98765, "bt_private_integer_bool_set() works"); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); pass("putting an existing integer value object does not cause a crash") - priv_obj = bt_private_value_integer_create_init(321456987); - obj = bt_private_value_as_value(priv_obj); + obj = bt_value_integer_create_init(321456987); ok(obj && bt_value_is_integer(obj), - "bt_private_value_integer_create_init() returns an integer value object"); + "bt_value_integer_create_init() returns an integer value object"); value = bt_value_integer_get(obj); ok(value == 321456987, - "bt_private_value_integer_create_init() sets the appropriate initial value"); + "bt_value_integer_create_init() sets the appropriate initial value"); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); } static void test_real(void) { double value; - struct bt_private_value *priv_obj; struct bt_value *obj; - priv_obj = bt_private_value_real_create(); - obj = bt_private_value_as_value(priv_obj); + obj = bt_value_real_create(); ok(obj && bt_value_is_real(obj), - "bt_private_value_real_create() returns a real number value object"); + "bt_value_real_create() returns a real number value object"); value = 17.34; value = bt_value_real_get(obj); ok(value == 0., "default real number value object value is 0"); - bt_private_value_real_set(priv_obj, -3.1416); + bt_value_real_set(obj, -3.1416); value = bt_value_real_get(obj); - ok(value == -3.1416, "bt_private_value_real_set() works"); + ok(value == -3.1416, "bt_value_real_set() works"); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); pass("putting an existing real number value object does not cause a crash") - priv_obj = bt_private_value_real_create_init(33.1649758); - obj = bt_private_value_as_value(priv_obj); + obj = bt_value_real_create_init(33.1649758); ok(obj && bt_value_is_real(obj), - "bt_private_value_real_create_init() returns a real number value object"); + "bt_value_real_create_init() returns a real number value object"); value = bt_value_real_get(obj); ok(value == 33.1649758, - "bt_private_value_real_create_init() sets the appropriate initial value"); + "bt_value_real_create_init() sets the appropriate initial value"); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); } static void test_string(void) { const char *value; - struct bt_private_value *priv_obj; struct bt_value *obj; - priv_obj = bt_private_value_string_create(); - obj = bt_private_value_as_value(priv_obj); + obj = bt_value_string_create(); ok(obj && bt_value_is_string(obj), - "bt_private_value_string_create() returns a string value object"); + "bt_value_string_create() returns a string value object"); value = bt_value_string_get(obj); ok(value && !strcmp(value, ""), "default string value object value is \"\""); - bt_private_value_string_set(priv_obj, "hello worldz"); + bt_value_string_set(obj, "hello worldz"); value = bt_value_string_get(obj); ok(value && !strcmp(value, "hello worldz"), "bt_value_string_get() works"); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); pass("putting an existing string value object does not cause a crash") - priv_obj = bt_private_value_string_create_init("initial value"); - obj = bt_private_value_as_value(priv_obj); + obj = bt_value_string_create_init("initial value"); ok(obj && bt_value_is_string(obj), - "bt_private_value_string_create_init() returns a string value object"); + "bt_value_string_create_init() returns a string value object"); value = bt_value_string_get(obj); ok(value && !strcmp(value, "initial value"), - "bt_private_value_string_create_init() sets the appropriate initial value"); + "bt_value_string_create_init() sets the appropriate initial value"); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); } static @@ -188,34 +174,28 @@ void test_array(void) bt_bool bool_value; int64_t int_value; double real_value; - struct bt_private_value *priv_obj; struct bt_value *obj; const char *string_value; - struct bt_private_value *priv_array_obj; struct bt_value *array_obj; - priv_array_obj = bt_private_value_array_create(); - array_obj = bt_private_value_as_value(priv_array_obj); + array_obj = bt_value_array_create(); ok(array_obj && bt_value_is_array(array_obj), - "bt_private_value_array_create() returns an array value object"); + "bt_value_array_create() returns an array value object"); ok(bt_value_array_is_empty(array_obj), "initial array value object size is 0"); - priv_obj = bt_private_value_integer_create_init(345); - obj = bt_private_value_as_value(priv_obj); - ret = bt_private_value_array_append_element(priv_array_obj, obj); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); - priv_obj = bt_private_value_real_create_init(-17.45); - obj = bt_private_value_as_value(priv_obj); - ret |= bt_private_value_array_append_element(priv_array_obj, obj); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); - priv_obj = bt_private_value_bool_create_init(BT_TRUE); - obj = bt_private_value_as_value(priv_obj); - ret |= bt_private_value_array_append_element(priv_array_obj, obj); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); - ret |= bt_private_value_array_append_element(priv_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); + obj = bt_value_real_create_init(-17.45); + ret |= bt_value_array_append_element(array_obj, obj); + BT_OBJECT_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); + ret |= bt_value_array_append_element(array_obj, bt_value_null); - ok(!ret, "bt_private_value_array_append_element() succeeds"); + ok(!ret, "bt_value_array_append_element() succeeds"); ok(bt_value_array_get_size(array_obj) == 4, "appending an element to an array value object increment its size"); @@ -241,12 +221,11 @@ void test_array(void) ok(obj == bt_value_null, "bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (null)"); - priv_obj = bt_private_value_integer_create_init(1001); - obj = bt_private_value_as_value(priv_obj); + obj = bt_value_integer_create_init(1001); BT_ASSERT(obj); - ok(!bt_private_value_array_set_element_by_index(priv_array_obj, 2, 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(priv_obj); + BT_OBJECT_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"); @@ -255,64 +234,64 @@ void test_array(void) ok(int_value == 1001, "bt_value_array_set_element_by_index() inserts an value object with the appropriate value"); - ret = bt_private_value_array_append_bool_element(priv_array_obj, + ret = bt_value_array_append_bool_element(array_obj, BT_FALSE); - ok(!ret, "bt_private_value_array_append_bool_element() succeeds"); - ret = bt_private_value_array_append_integer_element(priv_array_obj, + ok(!ret, "bt_value_array_append_bool_element() succeeds"); + ret = bt_value_array_append_integer_element(array_obj, 98765); - ok(!ret, "bt_private_value_array_append_integer_element() succeeds"); - ret = bt_private_value_array_append_real_element(priv_array_obj, + ok(!ret, "bt_value_array_append_integer_element() succeeds"); + ret = bt_value_array_append_real_element(array_obj, 2.49578); - ok(!ret, "bt_private_value_array_append_real_element() succeeds"); - ret = bt_private_value_array_append_string_element(priv_array_obj, + ok(!ret, "bt_value_array_append_real_element() succeeds"); + ret = bt_value_array_append_string_element(array_obj, "bt_value"); - ok(!ret, "bt_private_value_array_append_string_element() succeeds"); - ret = bt_private_value_array_append_empty_array_element(priv_array_obj); - ok(!ret, "bt_private_value_array_append_empty_array_element() succeeds"); - ret = bt_private_value_array_append_empty_map_element(priv_array_obj); - ok(!ret, "bt_private_value_array_append_empty_map_element() succeeds"); + ok(!ret, "bt_value_array_append_string_element() succeeds"); + ret = bt_value_array_append_empty_array_element(array_obj); + ok(!ret, "bt_value_array_append_empty_array_element() succeeds"); + ret = bt_value_array_append_empty_map_element(array_obj); + ok(!ret, "bt_value_array_append_empty_map_element() succeeds"); ok(bt_value_array_get_size(array_obj) == 10, - "the bt_private_value_array_append_element_*() functions increment the array value object's size"); + "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, 4); ok(obj && bt_value_is_bool(obj), - "bt_private_value_array_append_bool_element() appends a boolean value object"); + "bt_value_array_append_bool_element() appends a boolean value object"); bool_value = bt_value_bool_get(obj); ok(!bool_value, - "bt_private_value_array_append_bool_element() appends the appropriate value"); + "bt_value_array_append_bool_element() appends the appropriate value"); obj = bt_value_array_borrow_element_by_index(array_obj, 5); ok(obj && bt_value_is_integer(obj), - "bt_private_value_array_append_integer_element() appends an integer value object"); + "bt_value_array_append_integer_element() appends an integer value object"); int_value = bt_value_integer_get(obj); ok(int_value == 98765, - "bt_private_value_array_append_integer_element() appends the appropriate value"); + "bt_value_array_append_integer_element() appends the appropriate value"); obj = bt_value_array_borrow_element_by_index(array_obj, 6); ok(obj && bt_value_is_real(obj), - "bt_private_value_array_append_real_element() appends a real number value object"); + "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_private_value_array_append_real_element() appends the appropriate value"); + "bt_value_array_append_real_element() appends the appropriate value"); obj = bt_value_array_borrow_element_by_index(array_obj, 7); ok(obj && bt_value_is_string(obj), - "bt_private_value_array_append_string_element() appends a string value object"); + "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"), - "bt_private_value_array_append_string_element() appends the appropriate value"); + "bt_value_array_append_string_element() appends the appropriate value"); obj = bt_value_array_borrow_element_by_index(array_obj, 8); ok(obj && bt_value_is_array(obj), - "bt_private_value_array_append_empty_array_element() appends an array value object"); + "bt_value_array_append_empty_array_element() appends an array value object"); ok(bt_value_array_is_empty(obj), - "bt_private_value_array_append_empty_array_element() an empty array value object"); + "bt_value_array_append_empty_array_element() an empty array value object"); obj = bt_value_array_borrow_element_by_index(array_obj, 9); ok(obj && bt_value_is_map(obj), - "bt_private_value_array_append_empty_map_element() appends a map value object"); + "bt_value_array_append_empty_map_element() appends a map value object"); ok(bt_value_map_is_empty(obj), - "bt_private_value_array_append_empty_map_element() an empty map value object"); + "bt_value_array_append_empty_map_element() an empty map value object"); - BT_OBJECT_PUT_REF_AND_RESET(priv_array_obj); + BT_OBJECT_PUT_REF_AND_RESET(array_obj); pass("putting an existing array value object does not cause a crash") } @@ -496,42 +475,35 @@ void test_map(void) bt_bool bool_value; int64_t int_value; double real_value; - struct bt_private_value *priv_obj; struct bt_value *obj; - struct bt_private_value *priv_map_obj; struct bt_value *map_obj; struct map_foreach_checklist checklist; - priv_map_obj = bt_private_value_map_create(); - map_obj = bt_private_value_as_value(priv_map_obj); + map_obj = bt_value_map_create(); ok(map_obj && bt_value_is_map(map_obj), - "bt_private_value_map_create() returns a map value object"); + "bt_value_map_create() returns a map value object"); ok(bt_value_map_get_size(map_obj) == 0, "initial map value object size is 0"); - priv_obj = bt_private_value_integer_create_init(19457); - obj = bt_private_value_as_value(priv_obj); - ret = bt_private_value_map_insert_entry(priv_map_obj, "int", obj); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); - priv_obj = bt_private_value_real_create_init(5.444); - obj = bt_private_value_as_value(priv_obj); - ret |= bt_private_value_map_insert_entry(priv_map_obj, "real", obj); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); - priv_obj = bt_private_value_bool_create(); - obj = bt_private_value_as_value(priv_obj); - ret |= bt_private_value_map_insert_entry(priv_map_obj, "bt_bool", obj); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); - ret |= bt_private_value_map_insert_entry(priv_map_obj, "null", + obj = bt_value_integer_create_init(19457); + ret = bt_value_map_insert_entry(map_obj, "int", obj); + BT_OBJECT_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); + obj = bt_value_bool_create(); + ret |= bt_value_map_insert_entry(map_obj, "bt_bool", obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); + ret |= bt_value_map_insert_entry(map_obj, "null", bt_value_null); - ok(!ret, "bt_private_value_map_insert_entry() succeeds"); + ok(!ret, "bt_value_map_insert_entry() succeeds"); ok(bt_value_map_get_size(map_obj) == 4, "inserting an element into a map value object increment its size"); - priv_obj = bt_private_value_bool_create_init(BT_TRUE); - obj = bt_private_value_as_value(priv_obj); - ret = bt_private_value_map_insert_entry(priv_map_obj, "bt_bool", obj); - BT_OBJECT_PUT_REF_AND_RESET(priv_obj); - ok(!ret, "bt_private_value_map_insert_entry() accepts an existing key"); + 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); + ok(!ret, "bt_value_map_insert_entry() accepts an existing key"); obj = bt_value_map_borrow_entry_value(map_obj, "life"); ok(!obj, "bt_value_map_borrow_entry_value() returns NULL with an non existing key"); @@ -557,23 +529,23 @@ void test_map(void) ok(bool_value, "bt_value_map_borrow_entry_value() returns an value object with the appropriate value (boolean)"); - ret = bt_private_value_map_insert_bool_entry(priv_map_obj, "bool2", + ret = bt_value_map_insert_bool_entry(map_obj, "bool2", BT_TRUE); - ok(!ret, "bt_private_value_map_insert_bool_entry() succeeds"); - ret = bt_private_value_map_insert_integer_entry(priv_map_obj, "int2", + ok(!ret, "bt_value_map_insert_bool_entry() succeeds"); + ret = bt_value_map_insert_integer_entry(map_obj, "int2", 98765); - ok(!ret, "bt_private_value_map_insert_integer_entry() succeeds"); - ret = bt_private_value_map_insert_real_entry(priv_map_obj, "real2", + ok(!ret, "bt_value_map_insert_integer_entry() succeeds"); + ret = bt_value_map_insert_real_entry(map_obj, "real2", -49.0001); - ok(!ret, "bt_private_value_map_insert_real_entry() succeeds"); - ret = bt_private_value_map_insert_string_entry(priv_map_obj, "string2", + ok(!ret, "bt_value_map_insert_real_entry() succeeds"); + ret = bt_value_map_insert_string_entry(map_obj, "string2", "bt_value"); - ok(!ret, "bt_private_value_map_insert_string_entry() succeeds"); - ret = bt_private_value_map_insert_empty_array_entry(priv_map_obj, + ok(!ret, "bt_value_map_insert_string_entry() succeeds"); + ret = bt_value_map_insert_empty_array_entry(map_obj, "array2"); - ok(!ret, "bt_private_value_map_insert_empty_array_entry() succeeds"); - ret = bt_private_value_map_insert_empty_map_entry(priv_map_obj, "map2"); - ok(!ret, "bt_private_value_map_insert_empty_map_entry() succeeds"); + ok(!ret, "bt_value_map_insert_empty_array_entry() succeeds"); + ret = bt_value_map_insert_empty_map_entry(map_obj, "map2"); + ok(!ret, "bt_value_map_insert_empty_map_entry() succeeds"); ok(bt_value_map_get_size(map_obj) == 10, "the bt_value_map_insert*() functions increment the map value object's size"); @@ -617,7 +589,7 @@ void test_map(void) checklist.array2 && checklist.map2, "bt_value_map_foreach_entry() iterates over all the map value object's elements"); - BT_OBJECT_PUT_REF_AND_RESET(priv_map_obj); + BT_OBJECT_PUT_REF_AND_RESET(map_obj); pass("putting an existing map value object does not cause a crash") } @@ -643,22 +615,22 @@ void test_compare_null(void) static void test_compare_bool(void) { - struct bt_private_value *bool1 = - bt_private_value_bool_create_init(BT_FALSE); - struct bt_private_value *bool2 = - bt_private_value_bool_create_init(BT_TRUE); - struct bt_private_value *bool3 = - bt_private_value_bool_create_init(BT_FALSE); + struct bt_value *bool1 = + bt_value_bool_create_init(BT_FALSE); + struct bt_value *bool2 = + bt_value_bool_create_init(BT_TRUE); + struct bt_value *bool3 = + bt_value_bool_create_init(BT_FALSE); BT_ASSERT(bool1 && bool2 && bool3); ok(!bt_value_compare(bt_value_null, - bt_private_value_as_value(bool1)), + bool1), "cannot compare null value object and bt_bool value object"); - ok(!bt_value_compare(bt_private_value_as_value(bool1), - bt_private_value_as_value(bool2)), + ok(!bt_value_compare(bool1, + bool2), "boolean value objects are not equivalent (BT_FALSE and BT_TRUE)"); - ok(bt_value_compare(bt_private_value_as_value(bool1), - bt_private_value_as_value(bool3)), + ok(bt_value_compare(bool1, + bool3), "boolean value objects are equivalent (BT_FALSE and BT_FALSE)"); BT_OBJECT_PUT_REF_AND_RESET(bool1); @@ -669,22 +641,22 @@ void test_compare_bool(void) static void test_compare_integer(void) { - struct bt_private_value *int1 = - bt_private_value_integer_create_init(10); - struct bt_private_value *int2 = - bt_private_value_integer_create_init(-23); - struct bt_private_value *int3 = - bt_private_value_integer_create_init(10); + struct bt_value *int1 = + bt_value_integer_create_init(10); + struct bt_value *int2 = + bt_value_integer_create_init(-23); + struct bt_value *int3 = + bt_value_integer_create_init(10); BT_ASSERT(int1 && int2 && int3); ok(!bt_value_compare(bt_value_null, - bt_private_value_as_value(int1)), + int1), "cannot compare null value object and integer value object"); - ok(!bt_value_compare(bt_private_value_as_value(int1), - bt_private_value_as_value(int2)), + ok(!bt_value_compare(int1, + int2), "integer value objects are not equivalent (10 and -23)"); - ok(bt_value_compare(bt_private_value_as_value(int1), - bt_private_value_as_value(int3)), + ok(bt_value_compare(int1, + int3), "integer value objects are equivalent (10 and 10)"); BT_OBJECT_PUT_REF_AND_RESET(int1); @@ -695,23 +667,23 @@ void test_compare_integer(void) static void test_compare_real(void) { - struct bt_private_value *real1 = - bt_private_value_real_create_init(17.38); - struct bt_private_value *real2 = - bt_private_value_real_create_init(-14.23); - struct bt_private_value *real3 = - bt_private_value_real_create_init(17.38); + struct bt_value *real1 = + bt_value_real_create_init(17.38); + struct bt_value *real2 = + bt_value_real_create_init(-14.23); + struct bt_value *real3 = + bt_value_real_create_init(17.38); BT_ASSERT(real1 && real2 && real3); ok(!bt_value_compare(bt_value_null, - bt_private_value_as_value(real1)), + real1), "cannot compare null value object and real number value object"); - ok(!bt_value_compare(bt_private_value_as_value(real1), - bt_private_value_as_value(real2)), + ok(!bt_value_compare(real1, + real2), "real number value objects are not equivalent (17.38 and -14.23)"); - ok(bt_value_compare(bt_private_value_as_value(real1), - bt_private_value_as_value(real3)), + ok(bt_value_compare(real1, + real3), "real number value objects are equivalent (17.38 and 17.38)"); BT_OBJECT_PUT_REF_AND_RESET(real1); @@ -722,23 +694,23 @@ void test_compare_real(void) static void test_compare_string(void) { - struct bt_private_value *string1 = - bt_private_value_string_create_init("hello"); - struct bt_private_value *string2 = - bt_private_value_string_create_init("bt_value"); - struct bt_private_value *string3 = - bt_private_value_string_create_init("hello"); + struct bt_value *string1 = + bt_value_string_create_init("hello"); + struct bt_value *string2 = + bt_value_string_create_init("bt_value"); + struct bt_value *string3 = + bt_value_string_create_init("hello"); BT_ASSERT(string1 && string2 && string3); ok(!bt_value_compare(bt_value_null, - bt_private_value_as_value(string1)), + string1), "cannot compare null value object and string value object"); - ok(!bt_value_compare(bt_private_value_as_value(string1), - bt_private_value_as_value(string2)), + ok(!bt_value_compare(string1, + string2), "string value objects are not equivalent (\"hello\" and \"bt_value\")"); - ok(bt_value_compare(bt_private_value_as_value(string1), - bt_private_value_as_value(string3)), + ok(bt_value_compare(string1, + string3), "string value objects are equivalent (\"hello\" and \"hello\")"); BT_OBJECT_PUT_REF_AND_RESET(string1); @@ -749,50 +721,47 @@ void test_compare_string(void) static void test_compare_array(void) { - struct bt_private_value *array1 = bt_private_value_array_create(); - struct bt_private_value *array2 = bt_private_value_array_create(); - struct bt_private_value *array3 = bt_private_value_array_create(); + 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_ASSERT(array1 && array2 && array3); - ok(bt_value_compare(bt_private_value_as_value(array1), - bt_private_value_as_value(array2)), + ok(bt_value_compare(array1, + array2), "empty array value objects are equivalent"); - status = bt_private_value_array_append_integer_element(array1, 23); + status = bt_value_array_append_integer_element(array1, 23); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_array_append_real_element(array1, 14.2); + status = bt_value_array_append_real_element(array1, 14.2); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_array_append_bool_element(array1, BT_FALSE); + status = bt_value_array_append_bool_element(array1, BT_FALSE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_array_append_real_element(array2, 14.2); + status = bt_value_array_append_real_element(array2, 14.2); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_array_append_integer_element(array2, 23); + status = bt_value_array_append_integer_element(array2, 23); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_array_append_bool_element(array2, BT_FALSE); + status = bt_value_array_append_bool_element(array2, BT_FALSE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_array_append_integer_element(array3, 23); + status = bt_value_array_append_integer_element(array3, 23); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_array_append_real_element(array3, 14.2); + status = bt_value_array_append_real_element(array3, 14.2); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_array_append_bool_element(array3, BT_FALSE); + status = bt_value_array_append_bool_element(array3, BT_FALSE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - BT_ASSERT(bt_value_array_get_size( - bt_private_value_as_value(array1)) == 3); - BT_ASSERT(bt_value_array_get_size( - bt_private_value_as_value(array2)) == 3); - BT_ASSERT(bt_value_array_get_size( - bt_private_value_as_value(array3)) == 3); + 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); ok(!bt_value_compare(bt_value_null, - bt_private_value_as_value(array1)), + array1), "cannot compare null value object and array value object"); - ok(!bt_value_compare(bt_private_value_as_value(array1), - bt_private_value_as_value(array2)), + ok(!bt_value_compare(array1, + array2), "array value objects are not equivalent ([23, 14.2, BT_FALSE] and [14.2, 23, BT_FALSE])"); - ok(bt_value_compare(bt_private_value_as_value(array1), - bt_private_value_as_value(array3)), + ok(bt_value_compare(array1, + array3), "array value objects are equivalent ([23, 14.2, BT_FALSE] and [23, 14.2, BT_FALSE])"); BT_OBJECT_PUT_REF_AND_RESET(array1); @@ -803,54 +772,51 @@ void test_compare_array(void) static void test_compare_map(void) { - struct bt_private_value *map1 = bt_private_value_map_create(); - struct bt_private_value *map2 = bt_private_value_map_create(); - struct bt_private_value *map3 = bt_private_value_map_create(); + 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_ASSERT(map1 && map2 && map3); - ok(bt_value_compare(bt_private_value_as_value(map1), - bt_private_value_as_value(map2)), + ok(bt_value_compare(map1, + map2), "empty map value objects are equivalent"); - status = bt_private_value_map_insert_integer_entry(map1, "one", 23); + status = bt_value_map_insert_integer_entry(map1, "one", 23); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_real_entry(map1, "two", 14.2); + status = bt_value_map_insert_real_entry(map1, "two", 14.2); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_bool_entry(map1, "three", + status = bt_value_map_insert_bool_entry(map1, "three", BT_FALSE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_real_entry(map2, "one", 14.2); + status = bt_value_map_insert_real_entry(map2, "one", 14.2); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_integer_entry(map2, "two", 23); + status = bt_value_map_insert_integer_entry(map2, "two", 23); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_bool_entry(map2, "three", + status = bt_value_map_insert_bool_entry(map2, "three", BT_FALSE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_bool_entry(map3, "three", + status = bt_value_map_insert_bool_entry(map3, "three", BT_FALSE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_integer_entry(map3, "one", 23); + status = bt_value_map_insert_integer_entry(map3, "one", 23); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_real_entry(map3, "two", 14.2); + status = bt_value_map_insert_real_entry(map3, "two", 14.2); BT_ASSERT(status == BT_VALUE_STATUS_OK); - BT_ASSERT(bt_value_map_get_size( - bt_private_value_as_value(map1)) == 3); - BT_ASSERT(bt_value_map_get_size( - bt_private_value_as_value(map2)) == 3); - BT_ASSERT(bt_value_map_get_size( - bt_private_value_as_value(map3)) == 3); + BT_ASSERT(bt_value_map_get_size(map1) == 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, - bt_private_value_as_value(map1)), + map1), "cannot compare null value object and map value object"); - ok(!bt_value_compare(bt_private_value_as_value(map1), - bt_private_value_as_value(map2)), + ok(!bt_value_compare(map1, + map2), "map value objects are not equivalent"); - ok(bt_value_compare(bt_private_value_as_value(map1), - bt_private_value_as_value(map3)), + ok(bt_value_compare(map1, + map3), "map value objects are equivalent"); BT_OBJECT_PUT_REF_AND_RESET(map1); @@ -881,78 +847,78 @@ void test_copy(void) * bt_value_compare() elsewhere, then the deep copy is a * success. */ - struct bt_private_value *null_copy_obj; - struct bt_private_value *bool_obj, *bool_copy_obj; - struct bt_private_value *integer_obj, *integer_copy_obj; - struct bt_private_value *real_obj, *real_copy_obj; - struct bt_private_value *string_obj, *string_copy_obj; - struct bt_private_value *array_obj, *array_copy_obj; - struct bt_private_value *map_obj, *map_copy_obj; + 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; - bool_obj = bt_private_value_bool_create_init(BT_TRUE); - integer_obj = bt_private_value_integer_create_init(23); - real_obj = bt_private_value_real_create_init(-3.1416); - string_obj = bt_private_value_string_create_init("test"); - array_obj = bt_private_value_array_create(); - map_obj = bt_private_value_map_create(); + bool_obj = bt_value_bool_create_init(BT_TRUE); + integer_obj = bt_value_integer_create_init(23); + real_obj = bt_value_real_create_init(-3.1416); + string_obj = bt_value_string_create_init("test"); + array_obj = bt_value_array_create(); + map_obj = bt_value_map_create(); BT_ASSERT(bool_obj && integer_obj && real_obj && string_obj && array_obj && map_obj); - status = bt_private_value_array_append_element(array_obj, - bt_private_value_as_value(bool_obj)); + status = bt_value_array_append_element(array_obj, + bool_obj); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_array_append_element(array_obj, - bt_private_value_as_value(integer_obj)); + status = bt_value_array_append_element(array_obj, + integer_obj); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_array_append_element(array_obj, - bt_private_value_as_value(real_obj)); + status = bt_value_array_append_element(array_obj, + real_obj); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_array_append_element(array_obj, + status = bt_value_array_append_element(array_obj, bt_value_null); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_entry(map_obj, "array", - bt_private_value_as_value(array_obj)); + status = bt_value_map_insert_entry(map_obj, "array", + array_obj); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_entry(map_obj, "string", - bt_private_value_as_value(string_obj)); + status = bt_value_map_insert_entry(map_obj, "string", + string_obj); BT_ASSERT(status == BT_VALUE_STATUS_OK); status = bt_value_copy(&map_copy_obj, - bt_private_value_as_value(map_obj)); + map_obj); ok(status == BT_VALUE_STATUS_OK && map_copy_obj, "bt_value_copy() succeeds"); ok(map_obj != map_copy_obj, "bt_value_copy() returns a different pointer (map)"); - string_copy_obj = bt_private_value_map_borrow_entry_value(map_copy_obj, + string_copy_obj = bt_value_map_borrow_entry_value(map_copy_obj, "string"); ok(string_copy_obj != string_obj, "bt_value_copy() returns a different pointer (string)"); - array_copy_obj = bt_private_value_map_borrow_entry_value(map_copy_obj, + array_copy_obj = bt_value_map_borrow_entry_value(map_copy_obj, "array"); ok(array_copy_obj != array_obj, "bt_value_copy() returns a different pointer (array)"); - bool_copy_obj = bt_private_value_array_borrow_element_by_index( + bool_copy_obj = bt_value_array_borrow_element_by_index( array_copy_obj, 0); ok(bool_copy_obj != bool_obj, "bt_value_copy() returns a different pointer (bt_bool)"); - integer_copy_obj = bt_private_value_array_borrow_element_by_index( + integer_copy_obj = bt_value_array_borrow_element_by_index( array_copy_obj, 1); ok(integer_copy_obj != integer_obj, "bt_value_copy() returns a different pointer (integer)"); - real_copy_obj = bt_private_value_array_borrow_element_by_index( + real_copy_obj = bt_value_array_borrow_element_by_index( array_copy_obj, 2); ok(real_copy_obj != real_obj, "bt_value_copy() returns a different pointer (real)"); - null_copy_obj = bt_private_value_array_borrow_element_by_index( + null_copy_obj = bt_value_array_borrow_element_by_index( array_copy_obj, 3); - ok(bt_private_value_as_value(null_copy_obj) == bt_value_null, + ok(null_copy_obj == bt_value_null, "bt_value_copy() returns the same pointer (null)"); - ok(bt_value_compare(bt_private_value_as_value(map_obj), - bt_private_value_as_value(map_copy_obj)), + ok(bt_value_compare(map_obj, + map_copy_obj), "source and destination value objects have the same content"); BT_OBJECT_PUT_REF_AND_RESET(map_copy_obj); @@ -965,15 +931,15 @@ void test_copy(void) } static -bt_bool compare_map_elements(struct bt_value *map_a, struct bt_value *map_b, +bt_bool compare_map_elements(const struct bt_value *map_a, const struct bt_value *map_b, const char *key) { - struct bt_value *elem_a = NULL; - struct bt_value *elem_b = NULL; + const struct bt_value *elem_a = NULL; + const struct bt_value *elem_b = NULL; bt_bool equal; - elem_a = bt_value_map_borrow_entry_value(map_a, key); - elem_b = bt_value_map_borrow_entry_value(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); return equal; } @@ -981,59 +947,58 @@ bt_bool compare_map_elements(struct bt_value *map_a, struct bt_value *map_b, static void test_extend(void) { - struct bt_private_value *base_map = bt_private_value_map_create(); - struct bt_private_value *extension_map = bt_private_value_map_create(); - struct bt_private_value *extended_map = NULL; - struct bt_private_value *array = bt_private_value_array_create(); + 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_ASSERT(base_map); BT_ASSERT(extension_map); BT_ASSERT(array); - status = bt_private_value_map_insert_bool_entry(base_map, "file", + status = bt_value_map_insert_bool_entry(base_map, "file", BT_TRUE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_bool_entry(base_map, "edit", + status = bt_value_map_insert_bool_entry(base_map, "edit", BT_FALSE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_integer_entry(base_map, + status = bt_value_map_insert_integer_entry(base_map, "selection", 17); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_integer_entry(base_map, "find", + status = bt_value_map_insert_integer_entry(base_map, "find", -34); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_bool_entry(extension_map, "edit", + status = bt_value_map_insert_bool_entry(extension_map, "edit", BT_TRUE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_integer_entry(extension_map, + status = bt_value_map_insert_integer_entry(extension_map, "find", 101); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_private_value_map_insert_real_entry(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, - bt_private_value_as_value(base_map), - bt_private_value_as_value(extension_map)); + base_map, + extension_map); ok(status == BT_VALUE_STATUS_OK && extended_map, "bt_value_map_extend() succeeds"); - ok(bt_value_map_get_size( - bt_private_value_as_value(extended_map)) == 5, + ok(bt_value_map_get_size(extended_map) == 5, "bt_value_map_extend() returns a map object with the correct size"); - ok(compare_map_elements(bt_private_value_as_value(base_map), - bt_private_value_as_value(extended_map), "file"), + ok(compare_map_elements(base_map, + extended_map, "file"), "bt_value_map_extend() picks the appropriate element (file)"); - ok(compare_map_elements(bt_private_value_as_value(extension_map), - bt_private_value_as_value(extended_map), "edit"), + ok(compare_map_elements(extension_map, + extended_map, "edit"), "bt_value_map_extend() picks the appropriate element (edit)"); - ok(compare_map_elements(bt_private_value_as_value(base_map), - bt_private_value_as_value(extended_map), "selection"), + ok(compare_map_elements(base_map, + extended_map, "selection"), "bt_value_map_extend() picks the appropriate element (selection)"); - ok(compare_map_elements(bt_private_value_as_value(extension_map), - bt_private_value_as_value(extended_map), "find"), + ok(compare_map_elements(extension_map, + extended_map, "find"), "bt_value_map_extend() picks the appropriate element (find)"); - ok(compare_map_elements(bt_private_value_as_value(extension_map), - bt_private_value_as_value(extended_map), "project"), + ok(compare_map_elements(extension_map, + extended_map, "project"), "bt_value_map_extend() picks the appropriate element (project)"); BT_OBJECT_PUT_REF_AND_RESET(array);