X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=tests%2Flib%2Ftest_bt_values.c;h=39427f46e4b568fb2d03200a5c5dc672300e88bd;hp=4f563960333e1f4dc1c633e01c67fe941ad81285;hb=9b4f9b425f2efce9a6ccc25f7ae062ebc1116a7d;hpb=dac5c838a2e15f0da9acd223a119ae7962dbc79a diff --git a/tests/lib/test_bt_values.c b/tests/lib/test_bt_values.c index 4f563960..39427f46 100644 --- a/tests/lib/test_bt_values.c +++ b/tests/lib/test_bt_values.c @@ -1,7 +1,7 @@ /* * test_bt_values.c * - * Babeltrace value value objects tests + * Babeltrace value objects tests * * Copyright (c) 2015 EfficiOS Inc. and Linux Foundation * Copyright (c) 2015 Philippe Proulx @@ -20,630 +20,516 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE -#include -#include +#include +#include "common/assert.h" #include #include "tap/tap.h" +#define NR_TESTS 166 + static 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_value_get(bt_value_null); + bt_value_get_ref(bt_value_null); pass("getting bt_value_null does not cause a crash"); - bt_value_put(bt_value_null); + bt_value_put_ref(bt_value_null); pass("putting bt_value_null does not cause a crash"); - - bt_value_get(NULL); - pass("getting NULL does not cause a crash"); - bt_value_put(NULL); - pass("putting NULL does not cause a crash"); - - ok(bt_value_get_type(NULL) == BT_VALUE_TYPE_UNKNOWN, - "bt_value_get_type(NULL) returns BT_VALUE_TYPE_UNKNOWN"); } static void test_bool(void) { - int ret; - bool value; - struct bt_value *obj; + bt_bool value; + bt_value *obj; obj = bt_value_bool_create(); ok(obj && bt_value_is_bool(obj), "bt_value_bool_create() returns a boolean value object"); - value = true; - ret = bt_value_bool_get(obj, &value); - ok(!ret && !value, "default boolean value object value is false"); - - ret = bt_value_bool_set(NULL, true); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_bool_set() fails with an value object set to NULL"); - ret = bt_value_bool_get(NULL, &value); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_bool_get() fails with an value object set to NULL"); - ret = bt_value_bool_get(obj, NULL); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_bool_get() fails with a return value set to NULL"); - - assert(!bt_value_bool_set(obj, false)); - ret = bt_value_bool_set(obj, true); - ok(!ret, "bt_value_bool_set() succeeds"); - ret = bt_value_bool_get(obj, &value); - ok(!ret && value, "bt_value_bool_set() works"); - - BT_VALUE_PUT(obj); + value = BT_TRUE; + value = bt_value_bool_get(obj); + ok(!value, "default boolean value object value is BT_FALSE"); + + bt_value_bool_set(obj, BT_FALSE); + bt_value_bool_set(obj, BT_TRUE); + value = bt_value_bool_get(obj); + ok(value, "bt_value_bool_set() works"); + + BT_VALUE_PUT_REF_AND_RESET(obj); pass("putting an existing boolean value object does not cause a crash") - value = false; - obj = bt_value_bool_create_init(true); + value = BT_FALSE; + obj = bt_value_bool_create_init(BT_TRUE); ok(obj && bt_value_is_bool(obj), "bt_value_bool_create_init() returns a boolean value object"); - ret = bt_value_bool_get(obj, &value); - ok(!ret && value, + value = bt_value_bool_get(obj); + ok(value, "bt_value_bool_create_init() sets the appropriate initial value"); - assert(!bt_value_freeze(obj)); - ok(bt_value_bool_set(obj, false) == BT_VALUE_STATUS_FROZEN, - "bt_value_bool_set() cannot be called on a frozen boolean value object"); - value = false; - ret = bt_value_bool_get(obj, &value); - ok(!ret && value, - "bt_value_bool_set() does not alter a frozen floating point number value object"); + BT_VALUE_PUT_REF_AND_RESET(obj); +} + +static +void test_unsigned_integer(void) +{ + uint64_t value; + bt_value *obj; + + obj = bt_value_integer_unsigned_create(); + ok(obj && bt_value_is_unsigned_integer(obj), + "bt_value_integer_unsigned_create() returns an unsigned integer value object"); + + value = 1961; + value = bt_value_integer_unsigned_get(obj); + ok(value == 0, "default unsigned integer value object value is 0"); + + bt_value_integer_unsigned_set(obj, 98765); + value = bt_value_integer_unsigned_get(obj); + ok(value == 98765, "bt_value_integer_unsigned_bool_set() works"); + + BT_VALUE_PUT_REF_AND_RESET(obj); + pass("putting an existing unsigned integer value object does not cause a crash") - BT_VALUE_PUT(obj); + obj = bt_value_integer_unsigned_create_init(321456987); + ok(obj && bt_value_is_unsigned_integer(obj), + "bt_value_integer_unsigned_create_init() returns an unsigned integer value object"); + value = bt_value_integer_unsigned_get(obj); + ok(value == 321456987, + "bt_value_integer_unsigned_create_init() sets the appropriate initial value"); + + BT_VALUE_PUT_REF_AND_RESET(obj); } static -void test_integer(void) +void test_signed_integer(void) { - int ret; int64_t value; - struct bt_value *obj; - - obj = bt_value_integer_create(); - ok(obj && bt_value_is_integer(obj), - "bt_value_integer_create() returns an integer value object"); - - ret = bt_value_integer_set(NULL, -12345); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_integer_set() fails with an value object set to NULL"); - ret = bt_value_integer_get(NULL, &value); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_integer_get() fails with an value object set to NULL"); - ret = bt_value_integer_get(obj, NULL); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_integer_get() fails with a return value set to NULL"); + bt_value *obj; + + obj = bt_value_integer_signed_create(); + ok(obj && bt_value_is_signed_integer(obj), + "bt_value_integer_signed_create() returns a signed 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_value_integer_get(obj, &value); - ok(!ret && value == -98765, "bt_value_integer_set() works"); - - BT_VALUE_PUT(obj); - pass("putting an existing integer value object does not cause a crash") - - obj = bt_value_integer_create_init(321456987); - ok(obj && bt_value_is_integer(obj), - "bt_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"); - - assert(!bt_value_freeze(obj)); - ok(bt_value_integer_set(obj, 18276) == BT_VALUE_STATUS_FROZEN, - "bt_value_integer_set() cannot be called on a frozen integer value object"); - value = 17; - ret = bt_value_integer_get(obj, &value); - ok(!ret && value == 321456987, - "bt_value_integer_set() does not alter a frozen integer value object"); - - BT_VALUE_PUT(obj); + value = bt_value_integer_signed_get(obj); + ok(value == 0, "default signed integer value object value is 0"); + + bt_value_integer_signed_set(obj, 98765); + value = bt_value_integer_signed_get(obj); + ok(value == 98765, "bt_value_integer_signed_bool_set() works"); + + BT_VALUE_PUT_REF_AND_RESET(obj); + pass("putting an existing signed integer value object does not cause a crash") + + obj = bt_value_integer_signed_create_init(-321456987); + ok(obj && bt_value_is_signed_integer(obj), + "bt_value_integer_signed_create_init() returns a signed integer value object"); + value = bt_value_integer_signed_get(obj); + ok(value == -321456987, + "bt_value_integer_signed_create_init() sets the appropriate initial value"); + + BT_VALUE_PUT_REF_AND_RESET(obj); } static -void test_float(void) +void test_real(void) { - int ret; double value; - 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"); - - ret = bt_value_float_set(NULL, 1.2345); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_float_set() fails with an value object set to NULL"); - ret = bt_value_float_get(NULL, &value); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_float_get() fails with an value object set to NULL"); - ret = bt_value_float_get(obj, NULL); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_float_get() fails with a return value set to NULL"); + bt_value *obj; + + obj = bt_value_real_create(); + ok(obj && bt_value_is_real(obj), + "bt_value_real_create() returns a real number value object"); value = 17.34; - ret = bt_value_float_get(obj, &value); - ok(!ret && value == 0., - "default floating point 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"); - - BT_VALUE_PUT(obj); - pass("putting an existing floating point 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); - ok(!ret && value == 33.1649758, - "bt_value_float_create_init() sets the appropriate initial value"); - - assert(!bt_value_freeze(obj)); - ok(bt_value_float_set(obj, 17.88) == BT_VALUE_STATUS_FROZEN, - "bt_value_float_set() fails with a frozen floating point number value object"); - value = 1.2; - ret = bt_value_float_get(obj, &value); - ok(!ret && value == 33.1649758, - "bt_value_float_set() does not alter a frozen floating point number value object"); - - BT_VALUE_PUT(obj); + value = bt_value_real_get(obj); + ok(value == 0., + "default real number value object value is 0"); + + bt_value_real_set(obj, -3.1416); + value = bt_value_real_get(obj); + ok(value == -3.1416, "bt_value_real_set() works"); + + BT_VALUE_PUT_REF_AND_RESET(obj); + pass("putting an existing real number value object does not cause a crash") + + obj = bt_value_real_create_init(33.1649758); + ok(obj && bt_value_is_real(obj), + "bt_value_real_create_init() returns a real number value object"); + value = bt_value_real_get(obj); + ok(value == 33.1649758, + "bt_value_real_create_init() sets the appropriate initial value"); + + BT_VALUE_PUT_REF_AND_RESET(obj); } static void test_string(void) { - int ret; const char *value; - struct bt_value *obj; + bt_value *obj; obj = bt_value_string_create(); ok(obj && bt_value_is_string(obj), "bt_value_string_create() returns a string value object"); - ret = bt_value_string_set(NULL, "hoho"); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_string_set() fails with an value object set to NULL"); - ret = bt_value_string_set(obj, NULL); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_string_set() fails with a value set to NULL"); - ret = bt_value_string_get(NULL, &value); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_string_get() fails with an value object set to NULL"); - ret = bt_value_string_get(obj, NULL); - ok(ret == BT_VALUE_STATUS_INVAL, - "bt_value_string_get() fails with a return value set to NULL"); - - ret = bt_value_string_get(obj, &value); - ok(!ret && value && !strcmp(value, ""), + value = bt_value_string_get(obj); + ok(value && strcmp(value, "") == 0, "default string value object value is \"\""); - ret = bt_value_string_set(obj, "hello worldz"); - ok(!ret, "bt_value_string_set() succeeds"); - ret = bt_value_string_get(obj, &value); - ok(!ret && value && !strcmp(value, "hello worldz"), + bt_value_string_set(obj, "hello worldz"); + value = bt_value_string_get(obj); + ok(value && strcmp(value, "hello worldz") == 0, "bt_value_string_get() works"); - BT_VALUE_PUT(obj); + BT_VALUE_PUT_REF_AND_RESET(obj); pass("putting an existing string value object does not cause a crash") - obj = bt_value_string_create_init(NULL); - ok(!obj, "bt_value_string_create_init() fails with an initial value set to NULL"); obj = bt_value_string_create_init("initial value"); ok(obj && bt_value_is_string(obj), "bt_value_string_create_init() returns a string value object"); - ret = bt_value_string_get(obj, &value); - ok(!ret && value && !strcmp(value, "initial value"), + value = bt_value_string_get(obj); + ok(value && strcmp(value, "initial value") == 0, "bt_value_string_create_init() sets the appropriate initial value"); - assert(!bt_value_freeze(obj)); - ok(bt_value_string_set(obj, "new value") == BT_VALUE_STATUS_FROZEN, - "bt_value_string_set() fails with a frozen string value object"); - value = ""; - ret = bt_value_string_get(obj, &value); - ok(!ret && value && !strcmp(value, "initial value"), - "bt_value_string_set() does not alter a frozen string value object"); - - BT_VALUE_PUT(obj); + BT_VALUE_PUT_REF_AND_RESET(obj); } static void test_array(void) { int ret; - bool bool_value; + bt_bool bool_value; int64_t int_value; - double float_value; - struct bt_value *obj; + double real_value; + bt_value *obj; const char *string_value; - struct bt_value *array_obj; + bt_value *array_obj; array_obj = bt_value_array_create(); ok(array_obj && bt_value_is_array(array_obj), "bt_value_array_create() returns an array value object"); - ok(bt_value_array_is_empty(NULL) == false, - "bt_value_array_is_empty() returns false with an value object set to NULL"); ok(bt_value_array_is_empty(array_obj), "initial array value object size is 0"); - ok(bt_value_array_size(NULL) == BT_VALUE_STATUS_INVAL, - "bt_value_array_size() fails with an array value object set to NULL"); - - ok(bt_value_array_append(NULL, bt_value_null) - == BT_VALUE_STATUS_INVAL, - "bt_value_array_append() fails with an array value object set to NULL"); - ok(bt_value_array_append(array_obj, NULL) == BT_VALUE_STATUS_INVAL, - "bt_value_array_append() fails with a value set to NULL"); - - obj = bt_value_integer_create_init(345); - ret = bt_value_array_append(array_obj, obj); - BT_VALUE_PUT(obj); - obj = bt_value_float_create_init(-17.45); - ret |= bt_value_array_append(array_obj, obj); - BT_VALUE_PUT(obj); - obj = bt_value_bool_create_init(true); - ret |= bt_value_array_append(array_obj, obj); - BT_VALUE_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, + + obj = bt_value_integer_unsigned_create_init(345); + ret = bt_value_array_append_element(array_obj, obj); + BT_VALUE_PUT_REF_AND_RESET(obj); + obj = bt_value_integer_signed_create_init(-507); + ret |= bt_value_array_append_element(array_obj, obj); + BT_VALUE_PUT_REF_AND_RESET(obj); + obj = bt_value_real_create_init(-17.45); + ret |= bt_value_array_append_element(array_obj, obj); + BT_VALUE_PUT_REF_AND_RESET(obj); + obj = bt_value_bool_create_init(BT_TRUE); + ret |= bt_value_array_append_element(array_obj, obj); + BT_VALUE_PUT_REF_AND_RESET(obj); + ret |= bt_value_array_append_element(array_obj, + bt_value_null); + ok(!ret, "bt_value_array_append_element() succeeds"); + ok(bt_value_array_get_size(array_obj) == 5, "appending an element to an array value object increment its size"); - obj = bt_value_array_get(array_obj, 4); - ok(!obj, "getting an array value object's element at an index equal to its size fails"); - obj = bt_value_array_get(array_obj, 5); - ok(!obj, "getting an array value object's element at a larger index fails"); - - obj = bt_value_array_get(NULL, 2); - ok(!obj, "bt_value_array_get() fails with an array value object set to NULL"); - - obj = bt_value_array_get(array_obj, 0); - ok(obj && bt_value_is_integer(obj), - "bt_value_array_get() 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_VALUE_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_VALUE_PUT(obj); - obj = bt_value_array_get(array_obj, 2); + obj = bt_value_array_borrow_element_by_index(array_obj, 0); + ok(obj && bt_value_is_unsigned_integer(obj), + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (unsigned integer)"); + int_value = bt_value_integer_unsigned_get(obj); + ok(int_value == 345, + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate value (unsigned integer)"); + obj = bt_value_array_borrow_element_by_index(array_obj, 1); + ok(obj && bt_value_is_signed_integer(obj), + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (signed integer)"); + int_value = bt_value_integer_signed_get(obj); + ok(int_value == -507, + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate value (signed integer)"); + obj = bt_value_array_borrow_element_by_index(array_obj, 2); + ok(obj && bt_value_is_real(obj), + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (real number)"); + real_value = bt_value_real_get(obj); + ok(real_value == -17.45, + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate value (real number)"); + obj = bt_value_array_borrow_element_by_index(array_obj, 3); ok(obj && bt_value_is_bool(obj), - "bt_value_array_get() 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_VALUE_PUT(obj); - obj = bt_value_array_get(array_obj, 3); + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (boolean)"); + bool_value = bt_value_bool_get(obj); + ok(bool_value, + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate value (boolean)"); + obj = bt_value_array_borrow_element_by_index(array_obj, 4); ok(obj == bt_value_null, - "bt_value_array_get() returns an value object with the appropriate type (null)"); - - ok(bt_value_array_set(NULL, 0, bt_value_null) == - BT_VALUE_STATUS_INVAL, - "bt_value_array_set() fails with an array value object set to NULL"); - ok(bt_value_array_set(array_obj, 0, NULL) == BT_VALUE_STATUS_INVAL, - "bt_value_array_set() fails with an element value object set to NULL"); - ok(bt_value_array_set(array_obj, 4, bt_value_null) == - BT_VALUE_STATUS_INVAL, - "bt_value_array_set() fails with an invalid index"); - obj = bt_value_integer_create_init(1001); - assert(obj); - ok(!bt_value_array_set(array_obj, 2, obj), - "bt_value_array_set() succeeds"); - BT_VALUE_PUT(obj); - obj = bt_value_array_get(array_obj, 2); - ok(obj && bt_value_is_integer(obj), - "bt_value_array_set() inserts an value object with the appropriate type"); - ret = bt_value_integer_get(obj, &int_value); - assert(!ret); + "bt_value_array_borrow_element_by_index() returns an value object with the appropriate type (null)"); + + obj = bt_value_integer_signed_create_init(1001); + BT_ASSERT(obj); + ok(!bt_value_array_set_element_by_index(array_obj, 2, obj), + "bt_value_array_set_element_by_index() succeeds"); + BT_VALUE_PUT_REF_AND_RESET(obj); + obj = bt_value_array_borrow_element_by_index(array_obj, 2); + ok(obj && bt_value_is_signed_integer(obj), + "bt_value_array_set_element_by_index() inserts an value object with the appropriate type"); + int_value = bt_value_integer_signed_get(obj); + BT_ASSERT(!ret); ok(int_value == 1001, - "bt_value_array_set() inserts an value object with the appropriate value"); - BT_VALUE_PUT(obj); - - ret = bt_value_array_append_bool(array_obj, false); - ok(!ret, "bt_value_array_append_bool() succeeds"); - ok(bt_value_array_append_bool(NULL, true) == BT_VALUE_STATUS_INVAL, - "bt_value_array_append_bool() fails with an array value object set to NULL"); - ret = bt_value_array_append_integer(array_obj, 98765); - ok(!ret, "bt_value_array_append_integer() succeeds"); - ok(bt_value_array_append_integer(NULL, 18765) == - BT_VALUE_STATUS_INVAL, - "bt_value_array_append_integer() fails with an array value object set to NULL"); - ret = bt_value_array_append_float(array_obj, 2.49578); - ok(!ret, "bt_value_array_append_float() succeeds"); - ok(bt_value_array_append_float(NULL, 1.49578) == - BT_VALUE_STATUS_INVAL, - "bt_value_array_append_float() fails with an array value object set to NULL"); - ret = bt_value_array_append_string(array_obj, "bt_value"); - ok(!ret, "bt_value_array_append_string() succeeds"); - ok(bt_value_array_append_string(NULL, "bt_obj") == - BT_VALUE_STATUS_INVAL, - "bt_value_array_append_string() fails with an array value object set to NULL"); - ret = bt_value_array_append_array(array_obj); - ok(!ret, "bt_value_array_append_array() succeeds"); - ok(bt_value_array_append_array(NULL) == BT_VALUE_STATUS_INVAL, - "bt_value_array_append_array() fails with an array value object set to NULL"); - ret = bt_value_array_append_map(array_obj); - ok(!ret, "bt_value_array_append_map() succeeds"); - ok(bt_value_array_append_map(NULL) == BT_VALUE_STATUS_INVAL, - "bt_value_array_append_map() fails with an array value object set to NULL"); - - 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_value_array_append_bool_element(array_obj, + BT_FALSE); + ok(!ret, "bt_value_array_append_bool_element() succeeds"); + ret = bt_value_array_append_unsigned_integer_element(array_obj, + 98765); + ok(!ret, "bt_value_array_append_unsigned_integer_element() succeeds"); + ret = bt_value_array_append_signed_integer_element(array_obj, + -10101); + ok(!ret, "bt_value_array_append_signed_integer_element() succeeds"); + ret = bt_value_array_append_real_element(array_obj, + 2.49578); + ok(!ret, "bt_value_array_append_real_element() succeeds"); + ret = bt_value_array_append_string_element(array_obj, + "bt_value"); + ok(!ret, "bt_value_array_append_string_element() succeeds"); + ret = bt_value_array_append_empty_array_element(array_obj); + 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) == 12, + "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_get(array_obj, 4); + obj = bt_value_array_borrow_element_by_index(array_obj, 5); ok(obj && bt_value_is_bool(obj), - "bt_value_array_append_bool() 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_VALUE_PUT(obj); - obj = bt_value_array_get(array_obj, 5); - ok(obj && bt_value_is_integer(obj), - "bt_value_array_append_integer() 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_VALUE_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_VALUE_PUT(obj); - obj = bt_value_array_get(array_obj, 7); + "bt_value_array_append_bool_element() appends a boolean value object"); + bool_value = bt_value_bool_get(obj); + ok(!bool_value, + "bt_value_array_append_bool_element() appends the appropriate value"); + obj = bt_value_array_borrow_element_by_index(array_obj, 6); + ok(obj && bt_value_is_unsigned_integer(obj), + "bt_value_array_append_unsigned_integer_element() appends an unsigned integer value object"); + int_value = bt_value_integer_unsigned_get(obj); + ok(int_value == 98765, + "bt_value_array_append_unsigned_integer_element() appends the appropriate value"); + obj = bt_value_array_borrow_element_by_index(array_obj, 7); + ok(obj && bt_value_is_signed_integer(obj), + "bt_value_array_append_signed_integer_element() appends a signed integer value object"); + int_value = bt_value_integer_signed_get(obj); + ok(int_value == -10101, + "bt_value_array_append_signed_integer_element() appends the appropriate value"); + obj = bt_value_array_borrow_element_by_index(array_obj, 8); + ok(obj && bt_value_is_real(obj), + "bt_value_array_append_real_element() appends a real number value object"); + real_value = bt_value_real_get(obj); + ok(real_value == 2.49578, + "bt_value_array_append_real_element() appends the appropriate value"); + obj = bt_value_array_borrow_element_by_index(array_obj, 9); ok(obj && bt_value_is_string(obj), - "bt_value_array_append_string() 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_VALUE_PUT(obj); - obj = bt_value_array_get(array_obj, 8); + "bt_value_array_append_string_element() appends a string value object"); + string_value = bt_value_string_get(obj); + ok(!ret && string_value && strcmp(string_value, "bt_value") == 0, + "bt_value_array_append_string_element() appends the appropriate value"); + obj = bt_value_array_borrow_element_by_index(array_obj, 10); ok(obj && bt_value_is_array(obj), - "bt_value_array_append_array() 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_value_array_append_array() an empty array value object"); - BT_VALUE_PUT(obj); - obj = bt_value_array_get(array_obj, 9); + "bt_value_array_append_empty_array_element() an empty array value object"); + obj = bt_value_array_borrow_element_by_index(array_obj, 11); ok(obj && bt_value_is_map(obj), - "bt_value_array_append_map() 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_value_array_append_map() an empty map value object"); - BT_VALUE_PUT(obj); - - assert(!bt_value_freeze(array_obj)); - ok(bt_value_array_append(array_obj, bt_value_null) == - BT_VALUE_STATUS_FROZEN, - "bt_value_array_append() fails with a frozen array value object"); - ok(bt_value_array_append_bool(array_obj, false) == - BT_VALUE_STATUS_FROZEN, - "bt_value_array_append_bool() fails with a frozen array value object"); - ok(bt_value_array_append_integer(array_obj, 23) == - BT_VALUE_STATUS_FROZEN, - "bt_value_array_append_integer() fails with a frozen array value object"); - ok(bt_value_array_append_float(array_obj, 2.34) == - BT_VALUE_STATUS_FROZEN, - "bt_value_array_append_float() fails with a frozen array value object"); - ok(bt_value_array_append_string(array_obj, "yayayayaya") == - BT_VALUE_STATUS_FROZEN, - "bt_value_array_append_string() fails with a frozen array value object"); - ok(bt_value_array_append_array(array_obj) == - BT_VALUE_STATUS_FROZEN, - "bt_value_array_append_array() fails with a frozen array value object"); - ok(bt_value_array_append_map(array_obj) == - BT_VALUE_STATUS_FROZEN, - "bt_value_array_append_map() fails with a frozen array value object"); - ok(bt_value_array_set(array_obj, 2, bt_value_null) == - BT_VALUE_STATUS_FROZEN, - "bt_value_array_set() fails with a frozen array value object"); - ok(bt_value_array_size(array_obj) == 10, - "appending to a frozen array value object does not change its size"); - - obj = bt_value_array_get(array_obj, 1); - assert(obj); - ok(bt_value_float_set(obj, 14.52) == BT_VALUE_STATUS_FROZEN, - "freezing an array value object also freezes its elements"); - BT_VALUE_PUT(obj); - - BT_VALUE_PUT(array_obj); + "bt_value_array_append_empty_map_element() an empty map value object"); + + BT_VALUE_PUT_REF_AND_RESET(array_obj); pass("putting an existing array value object does not cause a crash") } static -bool test_map_foreach_cb_count(const char *key, struct bt_value *object, +bt_bool test_map_foreach_cb_count(const char *key, bt_value *object, void *data) { int *count = data; if (*count == 3) { - return false; + return BT_FALSE; } (*count)++; - return true; + return BT_TRUE; } struct map_foreach_checklist { - bool bool1; - bool int1; - bool float1; - bool null1; - bool bool2; - bool int2; - bool float2; - bool string2; - bool array2; - bool map2; + bt_bool bool1; + bt_bool uint; + bt_bool int1; + bt_bool real1; + bt_bool null1; + bt_bool bool2; + bt_bool int2; + bt_bool real2; + bt_bool string2; + bt_bool array2; + bt_bool map2; }; static -bool test_map_foreach_cb_check(const char *key, struct bt_value *object, +bt_bool test_map_foreach_cb_check(const char *key, bt_value *object, void *data) { - int ret; struct map_foreach_checklist *checklist = data; - if (!strcmp(key, "bool")) { + if (strcmp(key, "bt_bool") == 0) { if (checklist->bool1) { - fail("test_map_foreach_cb_check(): duplicate key \"bool\""); + fail("test_map_foreach_cb_check(): duplicate key \"bt_bool\""); } else { - bool val = false; + bt_bool val = BT_FALSE; - ret = bt_value_bool_get(object, &val); - ok(!ret, "test_map_foreach_cb_check(): success getting \"bool\" value"); + val = bt_value_bool_get(object); if (val) { - pass("test_map_foreach_cb_check(): \"bool\" value object has the right value"); - checklist->bool1 = true; + pass("test_map_foreach_cb_check(): \"bt_bool\" value object has the right value"); + checklist->bool1 = BT_TRUE; } else { - fail("test_map_foreach_cb_check(): \"bool\" value object has the wrong value"); + fail("test_map_foreach_cb_check(): \"bt_bool\" value object has the wrong value"); } } - } else if (!strcmp(key, "int")) { + } else if (strcmp(key, "uint") == 0) { + if (checklist->uint) { + fail("test_map_foreach_cb_check(): duplicate key \"uint\""); + } else { + uint64_t val = 0; + + val = bt_value_integer_unsigned_get(object); + + if (val == 19457) { + pass("test_map_foreach_cb_check(): \"uint\" value object has the right value"); + checklist->uint = BT_TRUE; + } else { + fail("test_map_foreach_cb_check(): \"uint\" value object has the wrong value"); + } + } + } else if (strcmp(key, "int") == 0) { if (checklist->int1) { fail("test_map_foreach_cb_check(): duplicate key \"int\""); } else { int64_t val = 0; - ret = bt_value_integer_get(object, &val); - ok(!ret, "test_map_foreach_cb_check(): success getting \"int\" value"); + val = bt_value_integer_signed_get(object); - if (val == 19457) { + if (val == -12345) { pass("test_map_foreach_cb_check(): \"int\" value object has the right value"); - checklist->int1 = true; + checklist->int1 = BT_TRUE; } else { 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") == 0) { + 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"); + val = bt_value_real_get(object); if (val == 5.444) { - pass("test_map_foreach_cb_check(): \"float\" value object has the right value"); - checklist->float1 = 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")) { + } else if (strcmp(key, "null") == 0) { if (checklist->null1) { - fail("test_map_foreach_cb_check(): duplicate key \"bool\""); + fail("test_map_foreach_cb_check(): duplicate key \"bt_bool\""); } else { ok(bt_value_is_null(object), "test_map_foreach_cb_check(): success getting \"null\" value object"); - checklist->null1 = true; + checklist->null1 = BT_TRUE; } - } else if (!strcmp(key, "bool2")) { + } else if (strcmp(key, "bool2") == 0) { if (checklist->bool2) { fail("test_map_foreach_cb_check(): duplicate key \"bool2\""); } else { - bool val = false; + bt_bool val = BT_FALSE; - ret = bt_value_bool_get(object, &val); - ok(!ret, "test_map_foreach_cb_check(): success getting \"bool2\" value"); + val = bt_value_bool_get(object); if (val) { pass("test_map_foreach_cb_check(): \"bool2\" value object has the right value"); - checklist->bool2 = true; + checklist->bool2 = BT_TRUE; } else { fail("test_map_foreach_cb_check(): \"bool2\" value object has the wrong value"); } } - } else if (!strcmp(key, "int2")) { + } else if (strcmp(key, "int2") == 0) { if (checklist->int2) { fail("test_map_foreach_cb_check(): duplicate key \"int2\""); } else { int64_t val = 0; - ret = bt_value_integer_get(object, &val); - ok(!ret, "test_map_foreach_cb_check(): success getting \"int2\" value"); + val = bt_value_integer_signed_get(object); if (val == 98765) { pass("test_map_foreach_cb_check(): \"int2\" value object has the right value"); - checklist->int2 = true; + checklist->int2 = BT_TRUE; } else { 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") == 0) { + 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"); + val = bt_value_real_get(object); if (val == -49.0001) { - pass("test_map_foreach_cb_check(): \"float2\" value object has the right value"); - checklist->float2 = 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")) { + } else if (strcmp(key, "string2") == 0) { if (checklist->string2) { fail("test_map_foreach_cb_check(): duplicate key \"string2\""); } else { const char *val; - ret = bt_value_string_get(object, &val); - ok(!ret, "test_map_foreach_cb_check(): success getting \"string2\" value"); + val = bt_value_string_get(object); - if (val && !strcmp(val, "bt_value")) { + if (val && strcmp(val, "bt_value") == 0) { pass("test_map_foreach_cb_check(): \"string2\" value object has the right value"); - checklist->string2 = true; + checklist->string2 = BT_TRUE; } else { fail("test_map_foreach_cb_check(): \"string2\" value object has the wrong value"); } } - } else if (!strcmp(key, "array2")) { + } else if (strcmp(key, "array2") == 0) { if (checklist->array2) { fail("test_map_foreach_cb_check(): duplicate key \"array2\""); } else { ok(bt_value_is_array(object), "test_map_foreach_cb_check(): success getting \"array2\" value object"); ok(bt_value_array_is_empty(object), "test_map_foreach_cb_check(): \"array2\" value object is empty"); - checklist->array2 = true; + checklist->array2 = BT_TRUE; } - } else if (!strcmp(key, "map2")) { + } else if (strcmp(key, "map2") == 0) { if (checklist->map2) { fail("test_map_foreach_cb_check(): duplicate key \"map2\""); } else { ok(bt_value_is_map(object), "test_map_foreach_cb_check(): success getting \"map2\" value object"); ok(bt_value_map_is_empty(object), "test_map_foreach_cb_check(): \"map2\" value object is empty"); - checklist->map2 = true; + 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 true; + return BT_TRUE; } static @@ -651,184 +537,135 @@ void test_map(void) { int ret; int count = 0; - bool bool_value; + bt_bool bool_value; int64_t int_value; - double float_value; - struct bt_value *obj; - struct bt_value *map_obj; + double real_value; + bt_value *obj; + bt_value *map_obj; struct map_foreach_checklist checklist; map_obj = bt_value_map_create(); 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, + ok(bt_value_map_get_size(map_obj) == 0, "initial map value object size is 0"); - ok(bt_value_map_size(NULL) == BT_VALUE_STATUS_INVAL, - "bt_value_map_size() fails with a map value object set to NULL"); - - ok(bt_value_map_insert(NULL, "hello", bt_value_null) == - BT_VALUE_STATUS_INVAL, - "bt_value_array_insert() fails with a map value object set to NULL"); - ok(bt_value_map_insert(map_obj, NULL, bt_value_null) == - BT_VALUE_STATUS_INVAL, - "bt_value_array_insert() fails with a key set to NULL"); - ok(bt_value_map_insert(map_obj, "yeah", NULL) == - BT_VALUE_STATUS_INVAL, - "bt_value_array_insert() fails with an element value object set to NULL"); - - obj = bt_value_integer_create_init(19457); - ret = bt_value_map_insert(map_obj, "int", obj); - BT_VALUE_PUT(obj); - obj = bt_value_float_create_init(5.444); - ret |= bt_value_map_insert(map_obj, "float", obj); - BT_VALUE_PUT(obj); + + obj = bt_value_integer_unsigned_create_init(19457); + ret = bt_value_map_insert_entry(map_obj, "uint", obj); + BT_VALUE_PUT_REF_AND_RESET(obj); + obj = bt_value_integer_signed_create_init(-12345); + ret |= bt_value_map_insert_entry(map_obj, "int", obj); + BT_VALUE_PUT_REF_AND_RESET(obj); + obj = bt_value_real_create_init(5.444); + ret |= bt_value_map_insert_entry(map_obj, "real", obj); + BT_VALUE_PUT_REF_AND_RESET(obj); obj = bt_value_bool_create(); - ret |= bt_value_map_insert(map_obj, "bool", obj); - BT_VALUE_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, + ret |= bt_value_map_insert_entry(map_obj, "bt_bool", obj); + BT_VALUE_PUT_REF_AND_RESET(obj); + ret |= bt_value_map_insert_entry(map_obj, "null", + bt_value_null); + ok(!ret, "bt_value_map_insert_entry() succeeds"); + ok(bt_value_map_get_size(map_obj) == 5, "inserting an element into a map value object increment its size"); - obj = bt_value_bool_create_init(true); - ret = bt_value_map_insert(map_obj, "bool", obj); - BT_VALUE_PUT(obj); - ok(!ret, "bt_value_map_insert() accepts an existing key"); - - obj = bt_value_map_get(map_obj, NULL); - ok(!obj, "bt_value_map_get() fails with a key set to NULL"); - obj = bt_value_map_get(NULL, "bool"); - ok(!obj, "bt_value_map_get() fails with a map value object set to NULL"); - - obj = bt_value_map_get(map_obj, "life"); - ok(!obj, "bt_value_map_get() fails 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_VALUE_PUT(obj); - obj = bt_value_map_get(map_obj, "int"); - ok(obj && bt_value_is_integer(obj), - "bt_value_map_get() 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_VALUE_PUT(obj); - obj = bt_value_map_get(map_obj, "null"); + obj = bt_value_bool_create_init(BT_TRUE); + ret = bt_value_map_insert_entry(map_obj, "bt_bool", obj); + BT_VALUE_PUT_REF_AND_RESET(obj); + ok(!ret, "bt_value_map_insert_entry() accepts an existing key"); + + obj = bt_value_map_borrow_entry_value(map_obj, "life"); + 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)"); + real_value = bt_value_real_get(obj); + ok(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, "uint"); + ok(obj && bt_value_is_unsigned_integer(obj), + "bt_value_map_borrow_entry_value() returns an value object with the appropriate type (unsigned integer)"); + int_value = bt_value_integer_unsigned_get(obj); + ok(int_value == 19457, + "bt_value_map_borrow_entry_value() returns an value object with the appropriate value (unsigned integer)"); + obj = bt_value_map_borrow_entry_value(map_obj, "int"); + ok(obj && bt_value_is_signed_integer(obj), + "bt_value_map_borrow_entry_value() returns an value object with the appropriate type (signed integer)"); + int_value = bt_value_integer_signed_get(obj); + ok(int_value == -12345, + "bt_value_map_borrow_entry_value() returns an value object with the appropriate value (signed 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, "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)"); - 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_VALUE_PUT(obj); - - ret = bt_value_map_insert_bool(map_obj, "bool2", true); - ok(!ret, "bt_value_map_insert_bool() succeeds"); - ok(bt_value_map_insert_bool(NULL, "bool2", false) == - BT_VALUE_STATUS_INVAL, - "bt_value_map_insert_bool() fails with a map value object set to NULL"); - ret = bt_value_map_insert_integer(map_obj, "int2", 98765); - ok(!ret, "bt_value_map_insert_integer() succeeds"); - ok(bt_value_map_insert_integer(NULL, "int2", 1001) == - BT_VALUE_STATUS_INVAL, - "bt_value_map_insert_integer() fails with a map value object set to NULL"); - ret = bt_value_map_insert_float(map_obj, "float2", -49.0001); - ok(!ret, "bt_value_map_insert_float() succeeds"); - ok(bt_value_map_insert_float(NULL, "float2", 495) == - BT_VALUE_STATUS_INVAL, - "bt_value_map_insert_float() fails with a map value object set to NULL"); - ret = bt_value_map_insert_string(map_obj, "string2", "bt_value"); - ok(!ret, "bt_value_map_insert_string() succeeds"); - ok(bt_value_map_insert_string(NULL, "string2", "bt_obj") == - BT_VALUE_STATUS_INVAL, - "bt_value_map_insert_string() fails with a map value object set to NULL"); - ret = bt_value_map_insert_array(map_obj, "array2"); - ok(!ret, "bt_value_map_insert_array() succeeds"); - ok(bt_value_map_insert_array(NULL, "array2") == BT_VALUE_STATUS_INVAL, - "bt_value_map_insert_array() fails with a map value object set to NULL"); - ret = bt_value_map_insert_map(map_obj, "map2"); - ok(!ret, "bt_value_map_insert_map() succeeds"); - ok(bt_value_map_insert_map(NULL, "map2") == BT_VALUE_STATUS_INVAL, - "bt_value_map_insert_map() fails with a map value object set to NULL"); - - ok(bt_value_map_size(map_obj) == 10, + "bt_value_map_borrow_entry_value() returns an value object with the appropriate type (boolean)"); + bool_value = bt_value_bool_get(obj); + ok(bool_value, + "bt_value_map_borrow_entry_value() returns an value object with the appropriate value (boolean)"); + + ret = bt_value_map_insert_bool_entry(map_obj, "bool2", + BT_TRUE); + ok(!ret, "bt_value_map_insert_bool_entry() succeeds"); + ret = bt_value_map_insert_signed_integer_entry(map_obj, "int2", + 98765); + ok(!ret, "bt_value_map_insert_signed_integer_entry() succeeds"); + ret = bt_value_map_insert_real_entry(map_obj, "real2", + -49.0001); + ok(!ret, "bt_value_map_insert_real_entry() succeeds"); + ret = bt_value_map_insert_string_entry(map_obj, "string2", + "bt_value"); + ok(!ret, "bt_value_map_insert_string_entry() succeeds"); + ret = bt_value_map_insert_empty_array_entry(map_obj, + "array2"); + 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) == 11, "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, "bool"), - "map value object has key \"bool\""); - ok(bt_value_map_has_key(map_obj, "int"), + ok(bt_value_map_has_entry(map_obj, "bt_bool"), + "map value object has key \"bt_bool\""); + ok(bt_value_map_has_entry(map_obj, "uint"), + "map value object has key \"uint\""); + 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\""); - ok(bt_value_map_foreach(NULL, test_map_foreach_cb_count, &count) == - BT_VALUE_STATUS_INVAL, - "bt_value_map_foreach() fails with a map value object set to NULL"); - ok(bt_value_map_foreach(map_obj, NULL, &count) == - BT_VALUE_STATUS_INVAL, - "bt_value_map_foreach() fails with a user function set to NULL"); - ret = bt_value_map_foreach(map_obj, test_map_foreach_cb_count, &count); - ok(ret == BT_VALUE_STATUS_CANCELLED && count == 3, - "bt_value_map_foreach() breaks the loop when the user function returns false"); + ret = bt_value_map_foreach_entry(map_obj, test_map_foreach_cb_count, + &count); + ok(ret == BT_VALUE_MAP_FOREACH_ENTRY_STATUS_INTERRUPTED && count == 3, + "bt_value_map_foreach_entry() breaks the loop when the user function returns BT_FALSE"); 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 && - checklist.null1 && checklist.bool2 && checklist.int2 && - checklist.float2 && checklist.string2 && + ok(ret == BT_VALUE_MAP_FOREACH_ENTRY_STATUS_OK, + "bt_value_map_foreach_entry() succeeds with test_map_foreach_cb_check()"); + ok(checklist.bool1 && checklist.uint && checklist.int1 && + checklist.real1 && checklist.null1 && checklist.bool2 && + checklist.int2 && checklist.real2 && checklist.string2 && checklist.array2 && checklist.map2, - "bt_value_map_foreach() iterates over all the map value object's elements"); - - assert(!bt_value_freeze(map_obj)); - ok(bt_value_map_insert(map_obj, "allo", bt_value_null) == - BT_VALUE_STATUS_FROZEN, - "bt_value_map_insert() fails with a frozen map value object"); - ok(bt_value_map_insert_bool(map_obj, "duh", false) == - BT_VALUE_STATUS_FROZEN, - "bt_value_map_insert_bool() fails with a frozen array value object"); - ok(bt_value_map_insert_integer(map_obj, "duh", 23) == - BT_VALUE_STATUS_FROZEN, - "bt_value_map_insert_integer() fails with a frozen array value object"); - ok(bt_value_map_insert_float(map_obj, "duh", 2.34) == - BT_VALUE_STATUS_FROZEN, - "bt_value_map_insert_float() fails with a frozen array value object"); - ok(bt_value_map_insert_string(map_obj, "duh", "yayayayaya") == - BT_VALUE_STATUS_FROZEN, - "bt_value_map_insert_string() fails with a frozen array value object"); - ok(bt_value_map_insert_array(map_obj, "duh") == - BT_VALUE_STATUS_FROZEN, - "bt_value_map_insert_array() fails with a frozen array value object"); - ok(bt_value_map_insert_map(map_obj, "duh") == - BT_VALUE_STATUS_FROZEN, - "bt_value_map_insert_map() fails with a frozen array value object"); - ok(bt_value_map_size(map_obj) == 10, - "appending to a frozen map value object does not change its size"); - - BT_VALUE_PUT(map_obj); + "bt_value_map_foreach_entry() iterates over all the map value object's elements"); + + BT_VALUE_PUT_REF_AND_RESET(map_obj); pass("putting an existing map value object does not cause a crash") } @@ -837,8 +674,9 @@ void test_types(void) { test_null(); test_bool(); - test_integer(); - test_float(); + test_unsigned_integer(); + test_signed_integer(); + test_real(); test_string(); test_array(); test_map(); @@ -847,10 +685,6 @@ void test_types(void) static void test_compare_null(void) { - ok(!bt_value_compare(bt_value_null, NULL), - "cannot compare null value object and NULL"); - ok(!bt_value_compare(NULL, bt_value_null), - "cannot compare NULL and null value object"); ok(bt_value_compare(bt_value_null, bt_value_null), "null value objects are equivalent"); } @@ -858,167 +692,243 @@ void test_compare_null(void) static void test_compare_bool(void) { - struct bt_value *bool1 = bt_value_bool_create_init(false); - struct bt_value *bool2 = bt_value_bool_create_init(true); - struct bt_value *bool3 = bt_value_bool_create_init(false); - - assert(bool1 && bool2 && bool3); - ok(!bt_value_compare(bt_value_null, bool1), - "cannot compare null value object and bool value object"); - ok(!bt_value_compare(bool1, bool2), - "integer value objects are not equivalent (false and true)"); - ok(bt_value_compare(bool1, bool3), - "integer value objects are equivalent (false and false)"); - - BT_VALUE_PUT(bool1); - BT_VALUE_PUT(bool2); - BT_VALUE_PUT(bool3); + bt_value *bool1 = + bt_value_bool_create_init(BT_FALSE); + bt_value *bool2 = + bt_value_bool_create_init(BT_TRUE); + bt_value *bool3 = + bt_value_bool_create_init(BT_FALSE); + + BT_ASSERT(bool1 && bool2 && bool3); + ok(!bt_value_compare(bt_value_null, + bool1), + "cannot compare null value object and bt_bool value object"); + ok(!bt_value_compare(bool1, + bool2), + "boolean value objects are not equivalent (BT_FALSE and BT_TRUE)"); + ok(bt_value_compare(bool1, + bool3), + "boolean value objects are equivalent (BT_FALSE and BT_FALSE)"); + + BT_VALUE_PUT_REF_AND_RESET(bool1); + BT_VALUE_PUT_REF_AND_RESET(bool2); + BT_VALUE_PUT_REF_AND_RESET(bool3); } static -void test_compare_integer(void) +void test_compare_unsigned_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); + bt_value *int1 = + bt_value_integer_unsigned_create_init(10); + bt_value *int2 = + bt_value_integer_unsigned_create_init(23); + bt_value *int3 = + bt_value_integer_unsigned_create_init(10); + + BT_ASSERT(int1 && int2 && int3); + ok(!bt_value_compare(bt_value_null, + int1), + "cannot compare null value object and unsigned integer value object"); + ok(!bt_value_compare(int1, int2), + "unsigned integer value objects are not equivalent (10 and 23)"); + ok(bt_value_compare(int1, int3), + "unsigned integer value objects are equivalent (10 and 10)"); + + BT_VALUE_PUT_REF_AND_RESET(int1); + BT_VALUE_PUT_REF_AND_RESET(int2); + BT_VALUE_PUT_REF_AND_RESET(int3); +} - assert(int1 && int2 && int3); - ok(!bt_value_compare(bt_value_null, int1), - "cannot compare null value object and integer value object"); +void test_compare_signed_integer(void) +{ + bt_value *int1 = + bt_value_integer_signed_create_init(10); + bt_value *int2 = + bt_value_integer_signed_create_init(-23); + bt_value *int3 = + bt_value_integer_signed_create_init(10); + + BT_ASSERT(int1 && int2 && int3); + ok(!bt_value_compare(bt_value_null, + int1), + "cannot compare null value object and signed integer value object"); ok(!bt_value_compare(int1, int2), - "integer value objects are not equivalent (10 and -23)"); + "signed integer value objects are not equivalent (10 and -23)"); ok(bt_value_compare(int1, int3), - "integer value objects are equivalent (10 and 10)"); + "signed integer value objects are equivalent (10 and 10)"); - BT_VALUE_PUT(int1); - BT_VALUE_PUT(int2); - BT_VALUE_PUT(int3); + BT_VALUE_PUT_REF_AND_RESET(int1); + BT_VALUE_PUT_REF_AND_RESET(int2); + BT_VALUE_PUT_REF_AND_RESET(int3); } static -void test_compare_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); - - 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_VALUE_PUT(float1); - BT_VALUE_PUT(float2); - BT_VALUE_PUT(float3); + bt_value *real1 = + bt_value_real_create_init(17.38); + bt_value *real2 = + bt_value_real_create_init(-14.23); + bt_value *real3 = + bt_value_real_create_init(17.38); + + BT_ASSERT(real1 && real2 && real3); + + ok(!bt_value_compare(bt_value_null, + real1), + "cannot compare null value object and real number value object"); + ok(!bt_value_compare(real1, + real2), + "real number value objects are not equivalent (17.38 and -14.23)"); + ok(bt_value_compare(real1, + real3), + "real number value objects are equivalent (17.38 and 17.38)"); + + BT_VALUE_PUT_REF_AND_RESET(real1); + BT_VALUE_PUT_REF_AND_RESET(real2); + BT_VALUE_PUT_REF_AND_RESET(real3); } static void test_compare_string(void) { - struct bt_value *string1 = bt_value_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_value *string1 = + bt_value_string_create_init("hello"); + bt_value *string2 = + bt_value_string_create_init("bt_value"); + bt_value *string3 = + bt_value_string_create_init("hello"); - assert(string1 && string2 && string3); + BT_ASSERT(string1 && string2 && string3); - ok(!bt_value_compare(bt_value_null, string1), + ok(!bt_value_compare(bt_value_null, + string1), "cannot compare null value object and string value object"); - ok(!bt_value_compare(string1, string2), + ok(!bt_value_compare(string1, + string2), "string value objects are not equivalent (\"hello\" and \"bt_value\")"); - ok(bt_value_compare(string1, string3), + ok(bt_value_compare(string1, + string3), "string value objects are equivalent (\"hello\" and \"hello\")"); - BT_VALUE_PUT(string1); - BT_VALUE_PUT(string2); - BT_VALUE_PUT(string3); + BT_VALUE_PUT_REF_AND_RESET(string1); + BT_VALUE_PUT_REF_AND_RESET(string2); + BT_VALUE_PUT_REF_AND_RESET(string3); } static void test_compare_array(void) { - struct bt_value *array1 = bt_value_array_create(); - struct bt_value *array2 = bt_value_array_create(); - struct bt_value *array3 = bt_value_array_create(); + bt_value *array1 = bt_value_array_create(); + bt_value *array2 = bt_value_array_create(); + bt_value *array3 = bt_value_array_create(); + bt_value_array_append_element_status append_status; - assert(array1 && array2 && array3); + BT_ASSERT(array1 && array2 && array3); ok(bt_value_compare(array1, array2), "empty array value objects are equivalent"); - assert(!bt_value_array_append_integer(array1, 23)); - assert(!bt_value_array_append_float(array1, 14.2)); - assert(!bt_value_array_append_bool(array1, false)); - assert(!bt_value_array_append_float(array2, 14.2)); - assert(!bt_value_array_append_integer(array2, 23)); - assert(!bt_value_array_append_bool(array2, false)); - assert(!bt_value_array_append_integer(array3, 23)); - assert(!bt_value_array_append_float(array3, 14.2)); - assert(!bt_value_array_append_bool(array3, false)); - assert(bt_value_array_size(array1) == 3); - assert(bt_value_array_size(array2) == 3); - assert(bt_value_array_size(array3) == 3); - - ok(!bt_value_compare(bt_value_null, array1), + append_status = bt_value_array_append_signed_integer_element(array1, 23); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_real_element(array1, 14.2); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_bool_element(array1, BT_FALSE); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_real_element(array2, 14.2); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_signed_integer_element(array2, 23); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_bool_element(array2, BT_FALSE); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_signed_integer_element(array3, 23); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_real_element(array3, 14.2); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_bool_element(array3, BT_FALSE); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + BT_ASSERT(bt_value_array_get_size(array1) == 3); + BT_ASSERT(bt_value_array_get_size(array2) == 3); + BT_ASSERT(bt_value_array_get_size(array3) == 3); + + ok(!bt_value_compare(bt_value_null, + array1), "cannot compare null value object and array value object"); - ok(!bt_value_compare(array1, array2), - "array value objects are not equivalent ([23, 14.2, false] and [14.2, 23, false])"); - ok(bt_value_compare(array1, array3), - "array value objects are equivalent ([23, 14.2, false] and [23, 14.2, false])"); - - BT_VALUE_PUT(array1); - BT_VALUE_PUT(array2); - BT_VALUE_PUT(array3); + 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(array1, + array3), + "array value objects are equivalent ([23, 14.2, BT_FALSE] and [23, 14.2, BT_FALSE])"); + + BT_VALUE_PUT_REF_AND_RESET(array1); + BT_VALUE_PUT_REF_AND_RESET(array2); + BT_VALUE_PUT_REF_AND_RESET(array3); } static void test_compare_map(void) { - struct bt_value *map1 = bt_value_map_create(); - struct bt_value *map2 = bt_value_map_create(); - struct bt_value *map3 = bt_value_map_create(); + bt_value *map1 = bt_value_map_create(); + bt_value *map2 = bt_value_map_create(); + bt_value *map3 = bt_value_map_create(); + bt_value_map_insert_entry_status insert_status; - assert(map1 && map2 && map3); + BT_ASSERT(map1 && map2 && map3); - ok(bt_value_compare(map1, map2), + ok(bt_value_compare(map1, + map2), "empty map value objects are equivalent"); - assert(!bt_value_map_insert_integer(map1, "one", 23)); - assert(!bt_value_map_insert_float(map1, "two", 14.2)); - assert(!bt_value_map_insert_bool(map1, "three", false)); - assert(!bt_value_map_insert_float(map2, "one", 14.2)); - assert(!bt_value_map_insert_integer(map2, "two", 23)); - assert(!bt_value_map_insert_bool(map2, "three", false)); - assert(!bt_value_map_insert_bool(map3, "three", false)); - assert(!bt_value_map_insert_integer(map3, "one", 23)); - assert(!bt_value_map_insert_float(map3, "two", 14.2)); - assert(bt_value_map_size(map1) == 3); - assert(bt_value_map_size(map2) == 3); - assert(bt_value_map_size(map3) == 3); - - ok(!bt_value_compare(bt_value_null, map1), + + insert_status = bt_value_map_insert_signed_integer_entry(map1, "one", 23); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_real_entry(map1, "two", 14.2); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_bool_entry(map1, "three", + BT_FALSE); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_real_entry(map2, "one", 14.2); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_signed_integer_entry(map2, "two", 23); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_bool_entry(map2, "three", + BT_FALSE); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_bool_entry(map3, "three", + BT_FALSE); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_signed_integer_entry(map3, "one", 23); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_real_entry(map3, "two", 14.2); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + 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, + map1), "cannot compare null value object and map value object"); - ok(!bt_value_compare(map1, map2), + ok(!bt_value_compare(map1, + map2), "map value objects are not equivalent"); - ok(bt_value_compare(map1, map3), + ok(bt_value_compare(map1, + map3), "map value objects are equivalent"); - BT_VALUE_PUT(map1); - BT_VALUE_PUT(map2); - BT_VALUE_PUT(map3); + BT_VALUE_PUT_REF_AND_RESET(map1); + BT_VALUE_PUT_REF_AND_RESET(map2); + BT_VALUE_PUT_REF_AND_RESET(map3); } static void test_compare(void) { - ok(!bt_value_compare(NULL, NULL), "cannot compare NULL and NULL"); test_compare_null(); test_compare_bool(); - test_compare_integer(); - test_compare_float(); + test_compare_unsigned_integer(); + test_compare_signed_integer(); + test_compare_real(); test_compare_string(); test_compare_array(); test_compare_map(); @@ -1029,139 +939,179 @@ void test_copy(void) { /* * Here's the deal here. If we make sure that each value object - * of our deep copy has a different address than its source, - * and that bt_value_compare() returns true for the top-level - * value object, taking into account that we test the correctness of - * bt_value_compare() elsewhere, then the deep copy is a - * success. + * of our deep copy has a different address than its source, and + * that bt_value_compare() returns BT_TRUE for the top-level + * value object, taking into account that we test the + * correctness of bt_value_compare() elsewhere, then the deep + * 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(true); - integer_obj = bt_value_integer_create_init(23); - float_obj = bt_value_float_create_init(-3.1416); + bt_value *null_copy_obj; + bt_value *bool_obj, *bool_copy_obj; + bt_value *unsigned_integer_obj, *unsigned_integer_copy_obj; + bt_value *signed_integer_obj, *signed_integer_copy_obj; + bt_value *real_obj, *real_copy_obj; + bt_value *string_obj, *string_copy_obj; + bt_value *array_obj, *array_copy_obj; + bt_value *map_obj, *map_copy_obj; + bt_value_array_append_element_status append_status; + bt_value_map_insert_entry_status insert_status; + bt_value_copy_status copy_status; + + bool_obj = bt_value_bool_create_init(BT_TRUE); + unsigned_integer_obj = bt_value_integer_unsigned_create_init(23); + signed_integer_obj = bt_value_integer_signed_create_init(-47); + 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(); - assert(bool_obj && integer_obj && float_obj && string_obj && - array_obj && map_obj); - - assert(!bt_value_array_append(array_obj, bool_obj)); - assert(!bt_value_array_append(array_obj, integer_obj)); - assert(!bt_value_array_append(array_obj, float_obj)); - assert(!bt_value_array_append(array_obj, bt_value_null)); - assert(!bt_value_map_insert(map_obj, "array", array_obj)); - assert(!bt_value_map_insert(map_obj, "string", string_obj)); - - map_copy_obj = bt_value_copy(NULL); - ok(!map_copy_obj, - "bt_value_copy() fails with a source value object set to NULL"); - - map_copy_obj = bt_value_copy(map_obj); - ok(map_copy_obj, + BT_ASSERT(bool_obj && unsigned_integer_obj && signed_integer_obj && + real_obj && string_obj && array_obj && map_obj); + + append_status = bt_value_array_append_element(array_obj, bool_obj); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_element(array_obj, unsigned_integer_obj); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_element(array_obj, signed_integer_obj); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_element(array_obj, real_obj); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + append_status = bt_value_array_append_element(array_obj, bt_value_null); + BT_ASSERT(append_status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK); + insert_status = bt_value_map_insert_entry(map_obj, "array", array_obj); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_entry(map_obj, "string", string_obj); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + + copy_status = bt_value_copy(map_obj, &map_copy_obj); + ok(copy_status == BT_VALUE_COPY_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_value_map_get(map_copy_obj, "string"); + 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_value_map_get(map_copy_obj, "array"); + 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_value_array_get(array_copy_obj, 0); + 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 (bool)"); - integer_copy_obj = bt_value_array_get(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); + unsigned_integer_copy_obj = bt_value_array_borrow_element_by_index( + array_copy_obj, 1); + ok(unsigned_integer_copy_obj != unsigned_integer_obj, + "bt_value_copy() returns a different pointer (unsigned integer)"); + signed_integer_copy_obj = bt_value_array_borrow_element_by_index( + array_copy_obj, 2); + ok(signed_integer_copy_obj != signed_integer_obj, + "bt_value_copy() returns a different pointer (signed integer)"); + real_copy_obj = bt_value_array_borrow_element_by_index( + array_copy_obj, 3); + ok(real_copy_obj != real_obj, + "bt_value_copy() returns a different pointer (real)"); + null_copy_obj = bt_value_array_borrow_element_by_index( + array_copy_obj, 4); ok(null_copy_obj == bt_value_null, "bt_value_copy() returns the same pointer (null)"); ok(bt_value_compare(map_obj, map_copy_obj), "source and destination value objects have the same content"); - BT_VALUE_PUT(bool_copy_obj); - BT_VALUE_PUT(integer_copy_obj); - BT_VALUE_PUT(float_copy_obj); - BT_VALUE_PUT(string_copy_obj); - BT_VALUE_PUT(array_copy_obj); - BT_VALUE_PUT(map_copy_obj); - BT_VALUE_PUT(bool_obj); - BT_VALUE_PUT(integer_obj); - BT_VALUE_PUT(float_obj); - BT_VALUE_PUT(string_obj); - BT_VALUE_PUT(array_obj); - BT_VALUE_PUT(map_obj); + BT_VALUE_PUT_REF_AND_RESET(map_copy_obj); + BT_VALUE_PUT_REF_AND_RESET(bool_obj); + BT_VALUE_PUT_REF_AND_RESET(unsigned_integer_obj); + BT_VALUE_PUT_REF_AND_RESET(signed_integer_obj); + BT_VALUE_PUT_REF_AND_RESET(real_obj); + BT_VALUE_PUT_REF_AND_RESET(string_obj); + BT_VALUE_PUT_REF_AND_RESET(array_obj); + BT_VALUE_PUT_REF_AND_RESET(map_obj); } static -void test_macros(void) +bt_bool compare_map_elements(const bt_value *map_a, const bt_value *map_b, + const char *key) { - struct bt_value *obj = bt_value_bool_create(); - struct bt_value *src; - struct bt_value *dst; - - assert(obj); - BT_VALUE_PUT(obj); - ok(!obj, "BT_VALUE_PUT() resets the variable to NULL"); - - obj = bt_value_bool_create(); - assert(obj); - src = obj; - BT_VALUE_MOVE(dst, src); - ok(!src, "BT_VALUE_MOVE() resets the source variable to NULL"); - ok(dst == obj, "BT_VALUE_MOVE() moves the ownership"); - - BT_VALUE_PUT(dst); + const bt_value *elem_a = NULL; + const bt_value *elem_b = NULL; + bt_bool equal; + + elem_a = bt_value_map_borrow_entry_value_const(map_a, key); + elem_b = bt_value_map_borrow_entry_value_const(map_b, key); + equal = bt_value_compare(elem_a, elem_b); + return equal; } static -void test_freeze(void) +void test_extend(void) { - struct bt_value *obj; - - ok(bt_value_freeze(NULL) == BT_VALUE_STATUS_INVAL, - "bt_value_freeze() fails with an value object set to NULL"); - ok(!bt_value_freeze(bt_value_null), - "bt_value_freeze() succeeds with a null value object"); - - ok(!bt_value_is_frozen(NULL), "NULL is not frozen"); - ok(bt_value_is_frozen(bt_value_null), - "the null singleton is frozen"); - obj = bt_value_integer_create(); - assert(obj); - ok(!bt_value_is_frozen(obj), - "bt_value_is_frozen() returns false with a fresh value object"); - assert(!bt_value_freeze(obj)); - ok(!bt_value_freeze(obj), - "bt_value_freeze() passes with a frozen value object"); - ok(bt_value_is_frozen(obj), - "bt_value_is_frozen() returns true with a frozen value object"); - - BT_VALUE_PUT(obj); + bt_value *base_map = bt_value_map_create(); + bt_value *extension_map = bt_value_map_create(); + bt_value *extended_map = NULL; + bt_value *array = bt_value_array_create(); + bt_value_map_insert_entry_status insert_status; + bt_value_map_extend_status extend_status; + + BT_ASSERT(base_map); + BT_ASSERT(extension_map); + BT_ASSERT(array); + insert_status = bt_value_map_insert_bool_entry(base_map, "file", + BT_TRUE); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_bool_entry(base_map, "edit", + BT_FALSE); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_signed_integer_entry(base_map, + "selection", 17); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_signed_integer_entry(base_map, "find", + -34); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_bool_entry(extension_map, "edit", + BT_TRUE); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_signed_integer_entry(extension_map, + "find", 101); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + insert_status = bt_value_map_insert_real_entry(extension_map, + "project", -404); + BT_ASSERT(insert_status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK); + extend_status = bt_value_map_extend(base_map, extension_map, &extended_map); + ok(extend_status == BT_VALUE_MAP_EXTEND_STATUS_OK && + extended_map, "bt_value_map_extend() succeeds"); + ok(bt_value_map_get_size(extended_map) == 5, + "bt_value_map_extend() returns a map object with the correct size"); + ok(compare_map_elements(base_map, + extended_map, "file"), + "bt_value_map_extend() picks the appropriate element (file)"); + ok(compare_map_elements(extension_map, + extended_map, "edit"), + "bt_value_map_extend() picks the appropriate element (edit)"); + ok(compare_map_elements(base_map, + extended_map, "selection"), + "bt_value_map_extend() picks the appropriate element (selection)"); + ok(compare_map_elements(extension_map, + extended_map, "find"), + "bt_value_map_extend() picks the appropriate element (find)"); + ok(compare_map_elements(extension_map, + extended_map, "project"), + "bt_value_map_extend() picks the appropriate element (project)"); + + BT_VALUE_PUT_REF_AND_RESET(array); + BT_VALUE_PUT_REF_AND_RESET(base_map); + BT_VALUE_PUT_REF_AND_RESET(extension_map); + BT_VALUE_PUT_REF_AND_RESET(extended_map); } int main(void) { - plan_no_plan(); - - test_macros(); - test_freeze(); + plan_tests(NR_TESTS); test_types(); test_compare(); test_copy(); - + test_extend(); return 0; }