X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=tests%2Flib%2Ftest_bt_values.c;h=f047448b095ec2b616a5eb563890028904441399;hb=da91b29ad2964b85601e25843f1dca92f6c97406;hp=9ff58a12c79bf45ceccca3911f1ad1bac4100916;hpb=25583cd07e351a64d645978905be94227355f0e5;p=babeltrace.git diff --git a/tests/lib/test_bt_values.c b/tests/lib/test_bt_values.c index 9ff58a12..f047448b 100644 --- a/tests/lib/test_bt_values.c +++ b/tests/lib/test_bt_values.c @@ -20,8 +20,9 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#include +#include #include +#include #include #include #include "tap/tap.h" @@ -34,9 +35,9 @@ void test_null(void) 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_get(bt_value_null); + bt_object_get_ref(bt_value_null); pass("getting bt_value_null does not cause a crash"); - bt_put(bt_value_null); + bt_object_put_ref(bt_value_null); pass("putting bt_value_null does not cause a crash"); } @@ -45,34 +46,37 @@ void test_bool(void) { int ret; bt_bool value; + struct bt_private_value *priv_obj; struct bt_value *obj; - obj = bt_value_bool_create(); + priv_obj = bt_private_value_bool_create(); + obj = bt_value_borrow_from_private(priv_obj); ok(obj && bt_value_is_bool(obj), - "bt_value_bool_create() returns a boolean value object"); + "bt_private_value_bool_create() returns a boolean value object"); value = BT_TRUE; ret = bt_value_bool_get(obj, &value); ok(!ret && !value, "default boolean value object value is BT_FALSE"); - BT_ASSERT(!bt_value_bool_set(obj, BT_FALSE)); - ret = bt_value_bool_set(obj, BT_TRUE); - ok(!ret, "bt_value_bool_set() succeeds"); + BT_ASSERT(!bt_private_value_bool_set(priv_obj, BT_FALSE)); + ret = bt_private_value_bool_set(priv_obj, BT_TRUE); + ok(!ret, "bt_private_value_bool_set() succeeds"); ret = bt_value_bool_get(obj, &value); - ok(!ret && value, "bt_value_bool_set() works"); + ok(!ret && value, "bt_private_value_bool_set() works"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(priv_obj); pass("putting an existing boolean value object does not cause a crash") value = BT_FALSE; - obj = bt_value_bool_create_init(BT_TRUE); + priv_obj = bt_private_value_bool_create_init(BT_TRUE); + obj = bt_value_borrow_from_private(priv_obj); ok(obj && bt_value_is_bool(obj), - "bt_value_bool_create_init() returns a boolean value object"); + "bt_private_value_bool_create_init() returns a boolean value object"); ret = bt_value_bool_get(obj, &value); ok(!ret && value, - "bt_value_bool_create_init() sets the appropriate initial value"); + "bt_private_value_bool_create_init() sets the appropriate initial value"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(priv_obj); } static @@ -80,66 +84,72 @@ void test_integer(void) { int ret; int64_t value; + struct bt_private_value *priv_obj; struct bt_value *obj; - obj = bt_value_integer_create(); + priv_obj = bt_private_value_integer_create(); + obj = bt_value_borrow_from_private(priv_obj); ok(obj && bt_value_is_integer(obj), - "bt_value_integer_create() returns an integer value object"); + "bt_private_value_integer_create() returns an integer value object"); value = 1961; ret = bt_value_integer_get(obj, &value); ok(!ret && value == 0, "default integer value object value is 0"); - ret = bt_value_integer_set(obj, -98765); - ok(!ret, "bt_value_integer_set() succeeds"); + ret = bt_private_integer_bool_set(priv_obj, -98765); + ok(!ret, "bt_private_integer_bool_set() succeeds"); ret = bt_value_integer_get(obj, &value); - ok(!ret && value == -98765, "bt_value_integer_set() works"); + ok(!ret && value == -98765, "bt_private_integer_bool_set() works"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(priv_obj); pass("putting an existing integer value object does not cause a crash") - obj = bt_value_integer_create_init(321456987); + priv_obj = bt_private_value_integer_create_init(321456987); + obj = bt_value_borrow_from_private(priv_obj); ok(obj && bt_value_is_integer(obj), - "bt_value_integer_create_init() returns an integer value object"); + "bt_private_value_integer_create_init() returns an integer value object"); ret = bt_value_integer_get(obj, &value); ok(!ret && value == 321456987, - "bt_value_integer_create_init() sets the appropriate initial value"); + "bt_private_value_integer_create_init() sets the appropriate initial value"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(priv_obj); } static -void test_float(void) +void test_real(void) { int ret; double value; + struct bt_private_value *priv_obj; struct bt_value *obj; - obj = bt_value_float_create(); - ok(obj && bt_value_is_float(obj), - "bt_value_float_create() returns a floating point number value object"); + priv_obj = bt_private_value_real_create(); + obj = bt_value_borrow_from_private(priv_obj); + ok(obj && bt_value_is_real(obj), + "bt_private_value_real_create() returns a real number value object"); value = 17.34; - ret = bt_value_float_get(obj, &value); + ret = bt_value_real_get(obj, &value); ok(!ret && value == 0., - "default floating point number value object value is 0"); + "default real number value object value is 0"); - ret = bt_value_float_set(obj, -3.1416); - ok(!ret, "bt_value_float_set() succeeds"); - ret = bt_value_float_get(obj, &value); - ok(!ret && value == -3.1416, "bt_value_float_set() works"); + ret = bt_private_value_real_set(priv_obj, -3.1416); + ok(!ret, "bt_private_value_real_set() succeeds"); + ret = bt_value_real_get(obj, &value); + ok(!ret && value == -3.1416, "bt_private_value_real_set() works"); - BT_PUT(obj); - pass("putting an existing floating point number value object does not cause a crash") + BT_OBJECT_PUT_REF_AND_RESET(priv_obj); + pass("putting an existing real number value object does not cause a crash") - obj = bt_value_float_create_init(33.1649758); - ok(obj && bt_value_is_float(obj), - "bt_value_float_create_init() returns a floating point number value object"); - ret = bt_value_float_get(obj, &value); + priv_obj = bt_private_value_real_create_init(33.1649758); + obj = bt_value_borrow_from_private(priv_obj); + ok(obj && bt_value_is_real(obj), + "bt_private_value_real_create_init() returns a real number value object"); + ret = bt_value_real_get(obj, &value); ok(!ret && value == 33.1649758, - "bt_value_float_create_init() sets the appropriate initial value"); + "bt_private_value_real_create_init() sets the appropriate initial value"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(priv_obj); } static @@ -147,33 +157,36 @@ void test_string(void) { int ret; const char *value; + struct bt_private_value *priv_obj; struct bt_value *obj; - obj = bt_value_string_create(); + priv_obj = bt_private_value_string_create(); + obj = bt_value_borrow_from_private(priv_obj); ok(obj && bt_value_is_string(obj), - "bt_value_string_create() returns a string value object"); + "bt_private_value_string_create() returns a string value object"); ret = bt_value_string_get(obj, &value); ok(!ret && value && !strcmp(value, ""), "default string value object value is \"\""); - ret = bt_value_string_set(obj, "hello worldz"); - ok(!ret, "bt_value_string_set() succeeds"); + ret = bt_private_value_string_set(priv_obj, "hello worldz"); + ok(!ret, "bt_private_value_string_set() succeeds"); ret = bt_value_string_get(obj, &value); ok(!ret && value && !strcmp(value, "hello worldz"), "bt_value_string_get() works"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(priv_obj); pass("putting an existing string value object does not cause a crash") - obj = bt_value_string_create_init("initial value"); + priv_obj = bt_private_value_string_create_init("initial value"); + obj = bt_value_borrow_from_private(priv_obj); ok(obj && bt_value_is_string(obj), - "bt_value_string_create_init() returns a string value object"); + "bt_private_value_string_create_init() returns a string value object"); ret = bt_value_string_get(obj, &value); ok(!ret && value && !strcmp(value, "initial value"), - "bt_value_string_create_init() sets the appropriate initial value"); + "bt_private_value_string_create_init() sets the appropriate initial value"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(priv_obj); } static @@ -182,130 +195,132 @@ void test_array(void) int ret; bt_bool bool_value; int64_t int_value; - double float_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; - array_obj = bt_value_array_create(); + priv_array_obj = bt_private_value_array_create(); + array_obj = bt_value_borrow_from_private(priv_array_obj); ok(array_obj && bt_value_is_array(array_obj), - "bt_value_array_create() returns an array value object"); + "bt_private_value_array_create() returns an array value object"); ok(bt_value_array_is_empty(array_obj), "initial array value object size is 0"); - obj = bt_value_integer_create_init(345); - ret = bt_value_array_append(array_obj, obj); - BT_PUT(obj); - obj = bt_value_float_create_init(-17.45); - ret |= bt_value_array_append(array_obj, obj); - BT_PUT(obj); - obj = bt_value_bool_create_init(BT_TRUE); - ret |= bt_value_array_append(array_obj, obj); - BT_PUT(obj); - ret |= bt_value_array_append(array_obj, bt_value_null); - ok(!ret, "bt_value_array_append() succeeds"); - ok(bt_value_array_size(array_obj) == 4, + priv_obj = bt_private_value_integer_create_init(345); + obj = bt_value_borrow_from_private(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_value_borrow_from_private(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_value_borrow_from_private(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, + bt_value_null); + ok(!ret, "bt_private_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"); - obj = bt_value_array_get(array_obj, 0); + obj = bt_value_array_borrow_element_by_index(array_obj, 0); ok(obj && bt_value_is_integer(obj), - "bt_value_array_get() returns an value object with the appropriate type (integer)"); + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (integer)"); ret = bt_value_integer_get(obj, &int_value); ok(!ret && int_value == 345, - "bt_value_array_get() returns an value object with the appropriate value (integer)"); - BT_PUT(obj); - obj = bt_value_array_get(array_obj, 1); - ok(obj && bt_value_is_float(obj), - "bt_value_array_get() returns an value object with the appropriate type (floating point number)"); - ret = bt_value_float_get(obj, &float_value); - ok(!ret && float_value == -17.45, - "bt_value_array_get() returns an value object with the appropriate value (floating point number)"); - BT_PUT(obj); - obj = bt_value_array_get(array_obj, 2); + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate value (integer)"); + obj = bt_value_array_borrow_element_by_index(array_obj, 1); + ok(obj && bt_value_is_real(obj), + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (real number)"); + ret = bt_value_real_get(obj, &real_value); + ok(!ret && 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, 2); ok(obj && bt_value_is_bool(obj), - "bt_value_array_get() returns an value object with the appropriate type (boolean)"); + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (boolean)"); ret = bt_value_bool_get(obj, &bool_value); ok(!ret && bool_value, - "bt_value_array_get() returns an value object with the appropriate value (boolean)"); - BT_PUT(obj); - obj = bt_value_array_get(array_obj, 3); + "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, 3); ok(obj == bt_value_null, - "bt_value_array_get() returns an value object with the appropriate type (null)"); + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (null)"); - obj = bt_value_integer_create_init(1001); + priv_obj = bt_private_value_integer_create_init(1001); + obj = bt_value_borrow_from_private(priv_obj); BT_ASSERT(obj); - ok(!bt_value_array_set(array_obj, 2, obj), - "bt_value_array_set() succeeds"); - BT_PUT(obj); - obj = bt_value_array_get(array_obj, 2); + ok(!bt_private_value_array_set_element_by_index(priv_array_obj, 2, obj), + "bt_value_array_set_element_by_index() succeeds"); + BT_OBJECT_PUT_REF_AND_RESET(priv_obj); + obj = bt_value_array_borrow_element_by_index(array_obj, 2); ok(obj && bt_value_is_integer(obj), - "bt_value_array_set() inserts an value object with the appropriate type"); + "bt_value_array_set_element_by_index() inserts an value object with the appropriate type"); ret = bt_value_integer_get(obj, &int_value); BT_ASSERT(!ret); ok(int_value == 1001, - "bt_value_array_set() inserts an value object with the appropriate value"); - BT_PUT(obj); - - ret = bt_value_array_append_bool(array_obj, BT_FALSE); - ok(!ret, "bt_value_array_append_bool() succeeds"); - ret = bt_value_array_append_integer(array_obj, 98765); - ok(!ret, "bt_value_array_append_integer() succeeds"); - ret = bt_value_array_append_float(array_obj, 2.49578); - ok(!ret, "bt_value_array_append_float() succeeds"); - ret = bt_value_array_append_string(array_obj, "bt_value"); - ok(!ret, "bt_value_array_append_string() succeeds"); - ret = bt_value_array_append_empty_array(array_obj); - ok(!ret, "bt_value_array_append_empty_array() succeeds"); - ret = bt_value_array_append_empty_map(array_obj); - ok(!ret, "bt_value_array_append_empty_map() succeeds"); - - ok(bt_value_array_size(array_obj) == 10, - "the bt_value_array_append_*() functions increment the array value object's size"); + "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, + BT_FALSE); + ok(!ret, "bt_private_value_array_append_bool_element() succeeds"); + ret = bt_private_value_array_append_integer_element(priv_array_obj, + 98765); + ok(!ret, "bt_private_value_array_append_integer_element() succeeds"); + ret = bt_private_value_array_append_real_element(priv_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, + "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(bt_value_array_get_size(array_obj) == 10, + "the bt_private_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_get(array_obj, 4); + obj = bt_value_array_borrow_element_by_index(array_obj, 4); ok(obj && bt_value_is_bool(obj), - "bt_value_array_append_bool() appends a boolean value object"); + "bt_private_value_array_append_bool_element() appends a boolean value object"); ret = bt_value_bool_get(obj, &bool_value); ok(!ret && !bool_value, - "bt_value_array_append_bool() appends the appropriate value"); - BT_PUT(obj); - obj = bt_value_array_get(array_obj, 5); + "bt_private_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_value_array_append_integer() appends an integer value object"); + "bt_private_value_array_append_integer_element() appends an integer value object"); ret = bt_value_integer_get(obj, &int_value); ok(!ret && int_value == 98765, - "bt_value_array_append_integer() appends the appropriate value"); - BT_PUT(obj); - obj = bt_value_array_get(array_obj, 6); - ok(obj && bt_value_is_float(obj), - "bt_value_array_append_float() appends a floating point number value object"); - ret = bt_value_float_get(obj, &float_value); - ok(!ret && float_value == 2.49578, - "bt_value_array_append_float() appends the appropriate value"); - BT_PUT(obj); - obj = bt_value_array_get(array_obj, 7); + "bt_private_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"); + ret = bt_value_real_get(obj, &real_value); + ok(!ret && real_value == 2.49578, + "bt_private_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_value_array_append_string() appends a string value object"); + "bt_private_value_array_append_string_element() appends a string value object"); ret = bt_value_string_get(obj, &string_value); ok(!ret && string_value && !strcmp(string_value, "bt_value"), - "bt_value_array_append_string() appends the appropriate value"); - BT_PUT(obj); - obj = bt_value_array_get(array_obj, 8); + "bt_private_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_value_array_append_empty_array() appends an array value object"); + "bt_private_value_array_append_empty_array_element() appends an array value object"); ok(bt_value_array_is_empty(obj), - "bt_value_array_append_empty_array() an empty array value object"); - BT_PUT(obj); - obj = bt_value_array_get(array_obj, 9); + "bt_private_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_value_array_append_empty_map() appends a map value object"); + "bt_private_value_array_append_empty_map_element() appends a map value object"); ok(bt_value_map_is_empty(obj), - "bt_value_array_append_empty_map() an empty map value object"); - BT_PUT(obj); + "bt_private_value_array_append_empty_map_element() an empty map value object"); - BT_PUT(array_obj); + BT_OBJECT_PUT_REF_AND_RESET(priv_array_obj); pass("putting an existing array value object does not cause a crash") } @@ -327,11 +342,11 @@ bt_bool test_map_foreach_cb_count(const char *key, struct bt_value *object, struct map_foreach_checklist { bt_bool bool1; bt_bool int1; - bt_bool float1; + bt_bool real1; bt_bool null1; bt_bool bool2; bt_bool int2; - bt_bool float2; + bt_bool real2; bt_bool string2; bt_bool array2; bt_bool map2; @@ -376,20 +391,20 @@ bt_bool test_map_foreach_cb_check(const char *key, struct bt_value *object, fail("test_map_foreach_cb_check(): \"int\" value object has the wrong value"); } } - } else if (!strcmp(key, "float")) { - if (checklist->float1) { - fail("test_map_foreach_cb_check(): duplicate key \"float\""); + } else if (!strcmp(key, "real")) { + if (checklist->real1) { + fail("test_map_foreach_cb_check(): duplicate key \"real\""); } else { double val = 0; - ret = bt_value_float_get(object, &val); - ok(!ret, "test_map_foreach_cb_check(): success getting \"float\" value"); + ret = bt_value_real_get(object, &val); + ok(!ret, "test_map_foreach_cb_check(): success getting \"real\" value"); if (val == 5.444) { - pass("test_map_foreach_cb_check(): \"float\" value object has the right value"); - checklist->float1 = BT_TRUE; + pass("test_map_foreach_cb_check(): \"real\" value object has the right value"); + checklist->real1 = BT_TRUE; } else { - fail("test_map_foreach_cb_check(): \"float\" value object has the wrong value"); + fail("test_map_foreach_cb_check(): \"real\" value object has the wrong value"); } } } else if (!strcmp(key, "null")) { @@ -431,20 +446,20 @@ bt_bool test_map_foreach_cb_check(const char *key, struct bt_value *object, fail("test_map_foreach_cb_check(): \"int2\" value object has the wrong value"); } } - } else if (!strcmp(key, "float2")) { - if (checklist->float2) { - fail("test_map_foreach_cb_check(): duplicate key \"float2\""); + } else if (!strcmp(key, "real2")) { + if (checklist->real2) { + fail("test_map_foreach_cb_check(): duplicate key \"real2\""); } else { double val = 0; - ret = bt_value_float_get(object, &val); - ok(!ret, "test_map_foreach_cb_check(): success getting \"float2\" value"); + ret = bt_value_real_get(object, &val); + ok(!ret, "test_map_foreach_cb_check(): success getting \"real2\" value"); if (val == -49.0001) { - pass("test_map_foreach_cb_check(): \"float2\" value object has the right value"); - checklist->float2 = BT_TRUE; + pass("test_map_foreach_cb_check(): \"real2\" value object has the right value"); + checklist->real2 = BT_TRUE; } else { - fail("test_map_foreach_cb_check(): \"float2\" value object has the wrong value"); + fail("test_map_foreach_cb_check(): \"real2\" value object has the wrong value"); } } } else if (!strcmp(key, "string2")) { @@ -482,7 +497,8 @@ bt_bool test_map_foreach_cb_check(const char *key, struct bt_value *object, checklist->map2 = BT_TRUE; } } else { - fail("test_map_foreach_cb_check(): unknown map key \"%s\"", key); + fail("test_map_foreach_cb_check(): unknown map key \"%s\"", + key); } return BT_TRUE; @@ -495,118 +511,129 @@ void test_map(void) int count = 0; bt_bool bool_value; int64_t int_value; - double float_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; - map_obj = bt_value_map_create(); + priv_map_obj = bt_private_value_map_create(); + map_obj = bt_value_borrow_from_private(priv_map_obj); ok(map_obj && bt_value_is_map(map_obj), - "bt_value_map_create() returns a map value object"); - ok(bt_value_map_size(map_obj) == 0, + "bt_private_value_map_create() returns a map value object"); + ok(bt_value_map_get_size(map_obj) == 0, "initial map value object size is 0"); - obj = bt_value_integer_create_init(19457); - ret = bt_value_map_insert(map_obj, "int", obj); - BT_PUT(obj); - obj = bt_value_float_create_init(5.444); - ret |= bt_value_map_insert(map_obj, "float", obj); - BT_PUT(obj); - obj = bt_value_bool_create(); - ret |= bt_value_map_insert(map_obj, "bt_bool", obj); - BT_PUT(obj); - ret |= bt_value_map_insert(map_obj, "null", bt_value_null); - ok(!ret, "bt_value_map_insert() succeeds"); - ok(bt_value_map_size(map_obj) == 4, + priv_obj = bt_private_value_integer_create_init(19457); + obj = bt_value_borrow_from_private(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_value_borrow_from_private(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_value_borrow_from_private(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", + bt_value_null); + ok(!ret, "bt_private_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"); - obj = bt_value_bool_create_init(BT_TRUE); - ret = bt_value_map_insert(map_obj, "bt_bool", obj); - BT_PUT(obj); - ok(!ret, "bt_value_map_insert() accepts an existing key"); - - obj = bt_value_map_get(map_obj, "life"); - ok(!obj, "bt_value_map_get() returns NULL with an non existing key"); - obj = bt_value_map_get(map_obj, "float"); - ok(obj && bt_value_is_float(obj), - "bt_value_map_get() returns an value object with the appropriate type (float)"); - ret = bt_value_float_get(obj, &float_value); - ok(!ret && float_value == 5.444, - "bt_value_map_get() returns an value object with the appropriate value (float)"); - BT_PUT(obj); - obj = bt_value_map_get(map_obj, "int"); + priv_obj = bt_private_value_bool_create_init(BT_TRUE); + obj = bt_value_borrow_from_private(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_map_borrow_entry_value(map_obj, "life"); + ok(!obj, "bt_value_map_borrow_entry_value() returns NULL with an non existing key"); + obj = bt_value_map_borrow_entry_value(map_obj, "real"); + ok(obj && bt_value_is_real(obj), + "bt_value_map_borrow_entry_value() returns an value object with the appropriate type (real)"); + ret = bt_value_real_get(obj, &real_value); + ok(!ret && real_value == 5.444, + "bt_value_map_borrow_entry_value() returns an value object with the appropriate value (real)"); + obj = bt_value_map_borrow_entry_value(map_obj, "int"); ok(obj && bt_value_is_integer(obj), - "bt_value_map_get() returns an value object with the appropriate type (integer)"); + "bt_value_map_borrow_entry_value() returns an value object with the appropriate type (integer)"); ret = bt_value_integer_get(obj, &int_value); ok(!ret && int_value == 19457, - "bt_value_map_get() returns an value object with the appropriate value (integer)"); - BT_PUT(obj); - obj = bt_value_map_get(map_obj, "null"); + "bt_value_map_borrow_entry_value() returns an value object with the appropriate value (integer)"); + obj = bt_value_map_borrow_entry_value(map_obj, "null"); ok(obj && bt_value_is_null(obj), - "bt_value_map_get() returns an value object with the appropriate type (null)"); - obj = bt_value_map_get(map_obj, "bt_bool"); + "bt_value_map_borrow_entry_value() returns an value object with the appropriate type (null)"); + obj = bt_value_map_borrow_entry_value(map_obj, "bt_bool"); ok(obj && bt_value_is_bool(obj), - "bt_value_map_get() returns an value object with the appropriate type (boolean)"); + "bt_value_map_borrow_entry_value() returns an value object with the appropriate type (boolean)"); ret = bt_value_bool_get(obj, &bool_value); ok(!ret && bool_value, - "bt_value_map_get() returns an value object with the appropriate value (boolean)"); - BT_PUT(obj); - - ret = bt_value_map_insert_bool(map_obj, "bool2", BT_TRUE); - ok(!ret, "bt_value_map_insert_bool() succeeds"); - ret = bt_value_map_insert_integer(map_obj, "int2", 98765); - ok(!ret, "bt_value_map_insert_integer() succeeds"); - ret = bt_value_map_insert_float(map_obj, "float2", -49.0001); - ok(!ret, "bt_value_map_insert_float() succeeds"); - ret = bt_value_map_insert_string(map_obj, "string2", "bt_value"); - ok(!ret, "bt_value_map_insert_string() succeeds"); - ret = bt_value_map_insert_empty_array(map_obj, "array2"); - ok(!ret, "bt_value_map_insert_empty_array() succeeds"); - ret = bt_value_map_insert_empty_map(map_obj, "map2"); - ok(!ret, "bt_value_map_insert_empty_map() succeeds"); - - ok(bt_value_map_size(map_obj) == 10, + "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", + BT_TRUE); + ok(!ret, "bt_private_value_map_insert_bool_entry() succeeds"); + ret = bt_private_value_map_insert_integer_entry(priv_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", + -49.0001); + ok(!ret, "bt_private_value_map_insert_real_entry() succeeds"); + ret = bt_private_value_map_insert_string_entry(priv_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, + "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(bt_value_map_get_size(map_obj) == 10, "the bt_value_map_insert*() functions increment the map value object's size"); - ok(!bt_value_map_has_key(map_obj, "hello"), + ok(!bt_value_map_has_entry(map_obj, "hello"), "map value object does not have key \"hello\""); - ok(bt_value_map_has_key(map_obj, "bt_bool"), + ok(bt_value_map_has_entry(map_obj, "bt_bool"), "map value object has key \"bt_bool\""); - ok(bt_value_map_has_key(map_obj, "int"), + ok(bt_value_map_has_entry(map_obj, "int"), "map value object has key \"int\""); - ok(bt_value_map_has_key(map_obj, "float"), - "map value object has key \"float\""); - ok(bt_value_map_has_key(map_obj, "null"), + ok(bt_value_map_has_entry(map_obj, "real"), + "map value object has key \"real\""); + ok(bt_value_map_has_entry(map_obj, "null"), "map value object has key \"null\""); - ok(bt_value_map_has_key(map_obj, "bool2"), + ok(bt_value_map_has_entry(map_obj, "bool2"), "map value object has key \"bool2\""); - ok(bt_value_map_has_key(map_obj, "int2"), + ok(bt_value_map_has_entry(map_obj, "int2"), "map value object has key \"int2\""); - ok(bt_value_map_has_key(map_obj, "float2"), - "map value object has key \"float2\""); - ok(bt_value_map_has_key(map_obj, "string2"), + ok(bt_value_map_has_entry(map_obj, "real2"), + "map value object has key \"real2\""); + ok(bt_value_map_has_entry(map_obj, "string2"), "map value object has key \"string2\""); - ok(bt_value_map_has_key(map_obj, "array2"), + ok(bt_value_map_has_entry(map_obj, "array2"), "map value object has key \"array2\""); - ok(bt_value_map_has_key(map_obj, "map2"), + ok(bt_value_map_has_entry(map_obj, "map2"), "map value object has key \"map2\""); - ret = bt_value_map_foreach(map_obj, test_map_foreach_cb_count, &count); + ret = bt_value_map_foreach_entry(map_obj, test_map_foreach_cb_count, + &count); ok(ret == BT_VALUE_STATUS_CANCELED && count == 3, - "bt_value_map_foreach() breaks the loop when the user function returns BT_FALSE"); + "bt_value_map_foreach_entry() breaks the loop when the user function returns BT_FALSE"); memset(&checklist, 0, sizeof(checklist)); - ret = bt_value_map_foreach(map_obj, test_map_foreach_cb_check, + ret = bt_value_map_foreach_entry(map_obj, test_map_foreach_cb_check, &checklist); ok(ret == BT_VALUE_STATUS_OK, - "bt_value_map_foreach() succeeds with test_map_foreach_cb_check()"); - ok(checklist.bool1 && checklist.int1 && checklist.float1 && + "bt_value_map_foreach_entry() succeeds with test_map_foreach_cb_check()"); + ok(checklist.bool1 && checklist.int1 && checklist.real1 && checklist.null1 && checklist.bool2 && checklist.int2 && - checklist.float2 && checklist.string2 && + checklist.real2 && checklist.string2 && checklist.array2 && checklist.map2, - "bt_value_map_foreach() iterates over all the map value object's elements"); + "bt_value_map_foreach_entry() iterates over all the map value object's elements"); - BT_PUT(map_obj); + BT_OBJECT_PUT_REF_AND_RESET(priv_map_obj); pass("putting an existing map value object does not cause a crash") } @@ -616,7 +643,7 @@ void test_types(void) test_null(); test_bool(); test_integer(); - test_float(); + test_real(); test_string(); test_array(); test_map(); @@ -632,157 +659,219 @@ void test_compare_null(void) static void test_compare_bool(void) { - 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); + 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); BT_ASSERT(bool1 && bool2 && bool3); - ok(!bt_value_compare(bt_value_null, bool1), + ok(!bt_value_compare(bt_value_null, + bt_value_borrow_from_private(bool1)), "cannot compare null value object and bt_bool value object"); - ok(!bt_value_compare(bool1, bool2), + ok(!bt_value_compare(bt_value_borrow_from_private(bool1), + bt_value_borrow_from_private(bool2)), "boolean value objects are not equivalent (BT_FALSE and BT_TRUE)"); - ok(bt_value_compare(bool1, bool3), + ok(bt_value_compare(bt_value_borrow_from_private(bool1), + bt_value_borrow_from_private(bool3)), "boolean value objects are equivalent (BT_FALSE and BT_FALSE)"); - BT_PUT(bool1); - BT_PUT(bool2); - BT_PUT(bool3); + BT_OBJECT_PUT_REF_AND_RESET(bool1); + BT_OBJECT_PUT_REF_AND_RESET(bool2); + BT_OBJECT_PUT_REF_AND_RESET(bool3); } static void test_compare_integer(void) { - 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); + 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); BT_ASSERT(int1 && int2 && int3); - ok(!bt_value_compare(bt_value_null, int1), + ok(!bt_value_compare(bt_value_null, + bt_value_borrow_from_private(int1)), "cannot compare null value object and integer value object"); - ok(!bt_value_compare(int1, int2), + ok(!bt_value_compare(bt_value_borrow_from_private(int1), + bt_value_borrow_from_private(int2)), "integer value objects are not equivalent (10 and -23)"); - ok(bt_value_compare(int1, int3), + ok(bt_value_compare(bt_value_borrow_from_private(int1), + bt_value_borrow_from_private(int3)), "integer value objects are equivalent (10 and 10)"); - BT_PUT(int1); - BT_PUT(int2); - BT_PUT(int3); + BT_OBJECT_PUT_REF_AND_RESET(int1); + BT_OBJECT_PUT_REF_AND_RESET(int2); + BT_OBJECT_PUT_REF_AND_RESET(int3); } static -void test_compare_float(void) +void test_compare_real(void) { - struct bt_value *float1 = bt_value_float_create_init(17.38); - struct bt_value *float2 = bt_value_float_create_init(-14.23); - struct bt_value *float3 = bt_value_float_create_init(17.38); - - BT_ASSERT(float1 && float2 && float3); - - ok(!bt_value_compare(bt_value_null, float1), - "cannot compare null value object and floating point number value object"); - ok(!bt_value_compare(float1, float2), - "floating point number value objects are not equivalent (17.38 and -14.23)"); - ok(bt_value_compare(float1, float3), - "floating point number value objects are equivalent (17.38 and 17.38)"); - - BT_PUT(float1); - BT_PUT(float2); - BT_PUT(float3); + 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); + + BT_ASSERT(real1 && real2 && real3); + + ok(!bt_value_compare(bt_value_null, + bt_value_borrow_from_private(real1)), + "cannot compare null value object and real number value object"); + ok(!bt_value_compare(bt_value_borrow_from_private(real1), + bt_value_borrow_from_private(real2)), + "real number value objects are not equivalent (17.38 and -14.23)"); + ok(bt_value_compare(bt_value_borrow_from_private(real1), + bt_value_borrow_from_private(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); } static void test_compare_string(void) { - 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"); + 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"); BT_ASSERT(string1 && string2 && string3); - ok(!bt_value_compare(bt_value_null, string1), + ok(!bt_value_compare(bt_value_null, + bt_value_borrow_from_private(string1)), "cannot compare null value object and string value object"); - ok(!bt_value_compare(string1, string2), + ok(!bt_value_compare(bt_value_borrow_from_private(string1), + bt_value_borrow_from_private(string2)), "string value objects are not equivalent (\"hello\" and \"bt_value\")"); - ok(bt_value_compare(string1, string3), + ok(bt_value_compare(bt_value_borrow_from_private(string1), + bt_value_borrow_from_private(string3)), "string value objects are equivalent (\"hello\" and \"hello\")"); - BT_PUT(string1); - BT_PUT(string2); - BT_PUT(string3); + BT_OBJECT_PUT_REF_AND_RESET(string1); + BT_OBJECT_PUT_REF_AND_RESET(string2); + BT_OBJECT_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(); + 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(); + enum bt_value_status status; BT_ASSERT(array1 && array2 && array3); - ok(bt_value_compare(array1, array2), + ok(bt_value_compare(bt_value_borrow_from_private(array1), + bt_value_borrow_from_private(array2)), "empty array value objects are equivalent"); - BT_ASSERT(!bt_value_array_append_integer(array1, 23)); - BT_ASSERT(!bt_value_array_append_float(array1, 14.2)); - BT_ASSERT(!bt_value_array_append_bool(array1, BT_FALSE)); - BT_ASSERT(!bt_value_array_append_float(array2, 14.2)); - BT_ASSERT(!bt_value_array_append_integer(array2, 23)); - BT_ASSERT(!bt_value_array_append_bool(array2, BT_FALSE)); - BT_ASSERT(!bt_value_array_append_integer(array3, 23)); - BT_ASSERT(!bt_value_array_append_float(array3, 14.2)); - BT_ASSERT(!bt_value_array_append_bool(array3, BT_FALSE)); - BT_ASSERT(bt_value_array_size(array1) == 3); - BT_ASSERT(bt_value_array_size(array2) == 3); - BT_ASSERT(bt_value_array_size(array3) == 3); - - ok(!bt_value_compare(bt_value_null, array1), + status = bt_private_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); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_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); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_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); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_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); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_value_array_append_bool_element(array3, BT_FALSE); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + BT_ASSERT(bt_value_array_get_size( + bt_value_borrow_from_private(array1)) == 3); + BT_ASSERT(bt_value_array_get_size( + bt_value_borrow_from_private(array2)) == 3); + BT_ASSERT(bt_value_array_get_size( + bt_value_borrow_from_private(array3)) == 3); + + ok(!bt_value_compare(bt_value_null, + bt_value_borrow_from_private(array1)), "cannot compare null value object and array value object"); - ok(!bt_value_compare(array1, array2), + ok(!bt_value_compare(bt_value_borrow_from_private(array1), + bt_value_borrow_from_private(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_compare(bt_value_borrow_from_private(array1), + bt_value_borrow_from_private(array3)), "array value objects are equivalent ([23, 14.2, BT_FALSE] and [23, 14.2, BT_FALSE])"); - BT_PUT(array1); - BT_PUT(array2); - BT_PUT(array3); + BT_OBJECT_PUT_REF_AND_RESET(array1); + BT_OBJECT_PUT_REF_AND_RESET(array2); + BT_OBJECT_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(); + 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(); + enum bt_value_status status; BT_ASSERT(map1 && map2 && map3); - ok(bt_value_compare(map1, map2), + ok(bt_value_compare(bt_value_borrow_from_private(map1), + bt_value_borrow_from_private(map2)), "empty map value objects are equivalent"); - BT_ASSERT(!bt_value_map_insert_integer(map1, "one", 23)); - BT_ASSERT(!bt_value_map_insert_float(map1, "two", 14.2)); - BT_ASSERT(!bt_value_map_insert_bool(map1, "three", BT_FALSE)); - BT_ASSERT(!bt_value_map_insert_float(map2, "one", 14.2)); - BT_ASSERT(!bt_value_map_insert_integer(map2, "two", 23)); - BT_ASSERT(!bt_value_map_insert_bool(map2, "three", BT_FALSE)); - BT_ASSERT(!bt_value_map_insert_bool(map3, "three", BT_FALSE)); - BT_ASSERT(!bt_value_map_insert_integer(map3, "one", 23)); - BT_ASSERT(!bt_value_map_insert_float(map3, "two", 14.2)); - BT_ASSERT(bt_value_map_size(map1) == 3); - BT_ASSERT(bt_value_map_size(map2) == 3); - BT_ASSERT(bt_value_map_size(map3) == 3); - - ok(!bt_value_compare(bt_value_null, map1), + + status = bt_private_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); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_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); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_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", + BT_FALSE); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_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); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_value_map_insert_real_entry(map3, "two", 14.2); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + BT_ASSERT(bt_value_map_get_size( + bt_value_borrow_from_private(map1)) == 3); + BT_ASSERT(bt_value_map_get_size( + bt_value_borrow_from_private(map2)) == 3); + BT_ASSERT(bt_value_map_get_size( + bt_value_borrow_from_private(map3)) == 3); + + ok(!bt_value_compare(bt_value_null, + bt_value_borrow_from_private(map1)), "cannot compare null value object and map value object"); - ok(!bt_value_compare(map1, map2), + ok(!bt_value_compare(bt_value_borrow_from_private(map1), + bt_value_borrow_from_private(map2)), "map value objects are not equivalent"); - ok(bt_value_compare(map1, map3), + ok(bt_value_compare(bt_value_borrow_from_private(map1), + bt_value_borrow_from_private(map3)), "map value objects are equivalent"); - BT_PUT(map1); - BT_PUT(map2); - BT_PUT(map3); + BT_OBJECT_PUT_REF_AND_RESET(map1); + BT_OBJECT_PUT_REF_AND_RESET(map2); + BT_OBJECT_PUT_REF_AND_RESET(map3); } static @@ -791,7 +880,7 @@ void test_compare(void) test_compare_null(); test_compare_bool(); test_compare_integer(); - test_compare_float(); + test_compare_real(); test_compare_string(); test_compare_array(); test_compare_map(); @@ -808,71 +897,86 @@ void test_copy(void) * 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 *float_obj, *float_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; - - bool_obj = bt_value_bool_create_init(BT_TRUE); - integer_obj = bt_value_integer_create_init(23); - float_obj = bt_value_float_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 && float_obj && string_obj && + 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; + 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(); + + BT_ASSERT(bool_obj && integer_obj && real_obj && string_obj && array_obj && map_obj); - BT_ASSERT(!bt_value_array_append(array_obj, bool_obj)); - BT_ASSERT(!bt_value_array_append(array_obj, integer_obj)); - BT_ASSERT(!bt_value_array_append(array_obj, float_obj)); - BT_ASSERT(!bt_value_array_append(array_obj, bt_value_null)); - BT_ASSERT(!bt_value_map_insert(map_obj, "array", array_obj)); - BT_ASSERT(!bt_value_map_insert(map_obj, "string", string_obj)); + status = bt_private_value_array_append_element(array_obj, + bt_value_borrow_from_private(bool_obj)); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_value_array_append_element(array_obj, + bt_value_borrow_from_private(integer_obj)); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_value_array_append_element(array_obj, + bt_value_borrow_from_private(real_obj)); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_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_value_borrow_from_private(array_obj)); + BT_ASSERT(status == BT_VALUE_STATUS_OK); + status = bt_private_value_map_insert_entry(map_obj, "string", + bt_value_borrow_from_private(string_obj)); + BT_ASSERT(status == BT_VALUE_STATUS_OK); - map_copy_obj = bt_value_copy(map_obj); + map_copy_obj = bt_value_copy(bt_value_borrow_from_private(map_obj)); 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_value_map_get(map_copy_obj, "string"); + string_copy_obj = bt_private_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_value_map_get(map_copy_obj, "array"); + array_copy_obj = bt_private_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_value_array_get(array_copy_obj, 0); + bool_copy_obj = bt_private_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_value_array_get(array_copy_obj, 1); + integer_copy_obj = bt_private_value_array_borrow_element_by_index( + array_copy_obj, 1); ok(integer_copy_obj != integer_obj, "bt_value_copy() returns a different pointer (integer)"); - float_copy_obj = bt_value_array_get(array_copy_obj, 2); - ok(float_copy_obj != float_obj, - "bt_value_copy() returns a different pointer (float)"); - null_copy_obj = bt_value_array_get(array_copy_obj, 3); - ok(null_copy_obj == bt_value_null, + real_copy_obj = bt_private_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( + array_copy_obj, 3); + ok(bt_value_borrow_from_private(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_compare(bt_value_borrow_from_private(map_obj), + bt_value_borrow_from_private(map_copy_obj)), "source and destination value objects have the same content"); - BT_PUT(bool_copy_obj); - BT_PUT(integer_copy_obj); - BT_PUT(float_copy_obj); - BT_PUT(string_copy_obj); - BT_PUT(array_copy_obj); - BT_PUT(map_copy_obj); - BT_PUT(bool_obj); - BT_PUT(integer_obj); - BT_PUT(float_obj); - BT_PUT(string_obj); - BT_PUT(array_obj); - BT_PUT(map_obj); + 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); } static @@ -883,60 +987,72 @@ bt_bool compare_map_elements(struct bt_value *map_a, struct bt_value *map_b, struct bt_value *elem_b = NULL; bt_bool equal; - elem_a = bt_value_map_get(map_a, key); - elem_b = bt_value_map_get(map_b, key); + elem_a = bt_value_map_borrow_entry_value(map_a, key); + elem_b = bt_value_map_borrow_entry_value(map_b, key); equal = bt_value_compare(elem_a, elem_b); - BT_PUT(elem_a); - BT_PUT(elem_b); - return equal; } 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(); + 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(); enum bt_value_status status; BT_ASSERT(base_map); BT_ASSERT(extension_map); BT_ASSERT(array); - status = bt_value_map_insert_bool(base_map, "file", BT_TRUE); + status = bt_private_value_map_insert_bool_entry(base_map, "file", + BT_TRUE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_value_map_insert_bool(base_map, "edit", BT_FALSE); + status = bt_private_value_map_insert_bool_entry(base_map, "edit", + BT_FALSE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_value_map_insert_integer(base_map, "selection", 17); + status = bt_private_value_map_insert_integer_entry(base_map, + "selection", 17); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_value_map_insert_integer(base_map, "find", -34); + status = bt_private_value_map_insert_integer_entry(base_map, "find", + -34); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_value_map_insert_bool(extension_map, "edit", BT_TRUE); + status = bt_private_value_map_insert_bool_entry(extension_map, "edit", + BT_TRUE); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_value_map_insert_integer(extension_map, "find", 101); + status = bt_private_value_map_insert_integer_entry(extension_map, + "find", 101); BT_ASSERT(status == BT_VALUE_STATUS_OK); - status = bt_value_map_insert_float(extension_map, "project", -404); + status = bt_private_value_map_insert_real_entry(extension_map, + "project", -404); BT_ASSERT(status == BT_VALUE_STATUS_OK); - extended_map = bt_value_map_extend(base_map, extension_map); + extended_map = bt_value_map_extend( + bt_value_borrow_from_private(base_map), + bt_value_borrow_from_private(extension_map)); ok(extended_map, "bt_value_map_extend() succeeds"); - ok(bt_value_map_size(extended_map) == 5, + ok(bt_value_map_get_size( + bt_value_borrow_from_private(extended_map)) == 5, "bt_value_map_extend() returns a map object with the correct size"); - ok(compare_map_elements(base_map, extended_map, "file"), + ok(compare_map_elements(bt_value_borrow_from_private(base_map), + bt_value_borrow_from_private(extended_map), "file"), "bt_value_map_extend() picks the appropriate element (file)"); - ok(compare_map_elements(extension_map, extended_map, "edit"), + ok(compare_map_elements(bt_value_borrow_from_private(extension_map), + bt_value_borrow_from_private(extended_map), "edit"), "bt_value_map_extend() picks the appropriate element (edit)"); - ok(compare_map_elements(base_map, extended_map, "selection"), + ok(compare_map_elements(bt_value_borrow_from_private(base_map), + bt_value_borrow_from_private(extended_map), "selection"), "bt_value_map_extend() picks the appropriate element (selection)"); - ok(compare_map_elements(extension_map, extended_map, "find"), + ok(compare_map_elements(bt_value_borrow_from_private(extension_map), + bt_value_borrow_from_private(extended_map), "find"), "bt_value_map_extend() picks the appropriate element (find)"); - ok(compare_map_elements(extension_map, extended_map, "project"), + ok(compare_map_elements(bt_value_borrow_from_private(extension_map), + bt_value_borrow_from_private(extended_map), "project"), "bt_value_map_extend() picks the appropriate element (project)"); - BT_PUT(array); - BT_PUT(base_map); - BT_PUT(extension_map); - BT_PUT(extended_map); + 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); } int main(void)