X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=tests%2Flib%2Ftest_ctf_writer.c;fp=tests%2Flib%2Ftest_ctf_writer.c;h=39cc888edbb1a75c0dcdcee3d67eaf5d0afa9cfd;hp=97c11cd38c2ecb055ddb0c6b0079372e21fc3878;hb=65300d60e4b4f167e5fc8f584677757ce09a3844;hpb=07208d85d16704b304b371897bb7acc995fcc481 diff --git a/tests/lib/test_ctf_writer.c b/tests/lib/test_ctf_writer.c index 97c11cd3..39cc888e 100644 --- a/tests/lib/test_ctf_writer.c +++ b/tests/lib/test_ctf_writer.c @@ -27,7 +27,7 @@ #include #include #include -#include +#include #include #include #include @@ -193,7 +193,7 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, ok(returned_type == int_64_type, "bt_ctf_field_type_enumeration_get_container_field_type returns the right type"); ok(!bt_ctf_field_type_enumeration_create(enum_type), "bt_ctf_field_enumeration_type_create rejects non-integer container field types"); - bt_put(returned_type); + bt_object_put_ref(returned_type); bt_ctf_field_type_set_alignment(float_type, 32); ok(bt_ctf_field_type_get_alignment(float_type) == 32, @@ -316,7 +316,7 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, returned_type = bt_ctf_event_class_get_context_field_type(simple_event_class); ok(returned_type == event_context_type, "bt_ctf_event_class_get_context_field_type returns the appropriate type"); - bt_put(returned_type); + bt_object_put_ref(returned_type); ok(!bt_ctf_stream_class_add_event_class(stream_class, simple_event_class), "Adding simple event class to stream class"); @@ -326,8 +326,8 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, * of simple_event_class, so we retrieve the new ones to create * the appropriate fields. */ - BT_PUT(event_context_type); - BT_PUT(event_payload_type); + BT_OBJECT_PUT_REF_AND_RESET(event_context_type); + BT_OBJECT_PUT_REF_AND_RESET(event_payload_type); event_payload_type = bt_ctf_event_class_get_payload_field_type( simple_event_class); BT_ASSERT(event_payload_type); @@ -352,14 +352,14 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, ret_event_class = bt_ctf_stream_class_get_event_class_by_index(stream_class, 0); ok(ret_event_class == simple_event_class, "bt_ctf_stream_class_get_event_class returns the correct event class"); - bt_put(ret_event_class); + bt_object_put_ref(ret_event_class); ok(!bt_ctf_stream_class_get_event_class_by_id(stream_class, 2), "bt_ctf_stream_class_get_event_class_by_id returns NULL when the requested ID doesn't exist"); ret_event_class = bt_ctf_stream_class_get_event_class_by_id(stream_class, 13); ok(ret_event_class == simple_event_class, "bt_ctf_stream_class_get_event_class_by_id returns a correct event class"); - bt_put(ret_event_class); + bt_object_put_ref(ret_event_class); simple_event = bt_ctf_event_create(simple_event_class); ok(simple_event, @@ -386,7 +386,7 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, "Set signed enumeration container value"); ret = bt_ctf_event_set_payload(simple_event, "enum_field", enum_field); BT_ASSERT(!ret); - BT_PUT(iter); + BT_OBJECT_PUT_REF_AND_RESET(iter); enum_field_unsigned = bt_ctf_field_create(ep_enum_field_unsigned_type); BT_ASSERT(enum_field_unsigned); @@ -434,7 +434,7 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, "packet_size"); ok(packet_context_field, "Packet context contains the default packet_size field."); - bt_put(packet_context_field); + bt_object_put_ref(packet_context_field); packet_context_field = bt_ctf_field_structure_get_field_by_name(packet_context, "custom_packet_context_field"); ok(bt_ctf_field_integer_unsigned_set_value(packet_context_field, 8) == 0, @@ -446,32 +446,32 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, ok(bt_ctf_stream_flush(stream) == 0, "Flush trace stream with one event"); - bt_put(simple_event_class); - bt_put(simple_event); - bt_put(uint_12_type); - bt_put(int_64_type); - bt_put(float_type); - bt_put(enum_type); - bt_put(enum_type_unsigned); - bt_put(returned_type); - bt_put(event_context_type); - bt_put(integer_field); - bt_put(float_field); - bt_put(enum_field); - bt_put(enum_field_unsigned); - bt_put(enum_container_field); - bt_put(enum_container_field_unsigned); - bt_put(packet_context); - bt_put(packet_context_field); - bt_put(stream_event_context); - bt_put(stream_event_context_field); - bt_put(event_context); - bt_put(event_context_field); - bt_put(event_payload_type); - bt_put(ep_integer_field_type); - bt_put(ep_enum_field_type); - bt_put(ep_enum_field_unsigned_type); - bt_put(iter); + bt_object_put_ref(simple_event_class); + bt_object_put_ref(simple_event); + bt_object_put_ref(uint_12_type); + bt_object_put_ref(int_64_type); + bt_object_put_ref(float_type); + bt_object_put_ref(enum_type); + bt_object_put_ref(enum_type_unsigned); + bt_object_put_ref(returned_type); + bt_object_put_ref(event_context_type); + bt_object_put_ref(integer_field); + bt_object_put_ref(float_field); + bt_object_put_ref(enum_field); + bt_object_put_ref(enum_field_unsigned); + bt_object_put_ref(enum_container_field); + bt_object_put_ref(enum_container_field_unsigned); + bt_object_put_ref(packet_context); + bt_object_put_ref(packet_context_field); + bt_object_put_ref(stream_event_context); + bt_object_put_ref(stream_event_context_field); + bt_object_put_ref(event_context); + bt_object_put_ref(event_context_field); + bt_object_put_ref(event_payload_type); + bt_object_put_ref(ep_integer_field_type); + bt_object_put_ref(ep_enum_field_type); + bt_object_put_ref(ep_enum_field_unsigned_type); + bt_object_put_ref(iter); } static @@ -544,7 +544,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, array_type); ok(ret_field_type == int_16_type, "bt_ctf_field_type_array_get_element_field_type returns the correct type"); - bt_put(ret_field_type); + bt_object_put_ref(ret_field_type); ok(bt_ctf_field_type_array_get_length(array_type) == ARRAY_TEST_LENGTH, "bt_ctf_field_type_array_get_length returns the correct length"); @@ -577,7 +577,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, ret_field_type = bt_ctf_field_type_variant_get_tag_field_type(variant_type); ok(ret_field_type == enum_variant_type, "bt_ctf_field_type_variant_get_tag_field_type returns a correct tag type"); - bt_put(ret_field_type); + bt_object_put_ref(ret_field_type); ret_string = bt_ctf_field_type_variant_get_tag_name(variant_type); ok(ret_string ? !strcmp(ret_string, "variant_selector") : 0, @@ -586,14 +586,14 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, variant_type, "INT16_TYPE"); ok(ret_field_type == int_16_type, "bt_ctf_field_type_variant_get_field_type_by_name returns a correct field type"); - bt_put(ret_field_type); + bt_object_put_ref(ret_field_type); ok(bt_ctf_field_type_variant_get_field_count(variant_type) == 3, "bt_ctf_field_type_variant_get_field_count returns the correct count"); ok(bt_ctf_field_type_variant_get_field_by_index(variant_type, NULL, &ret_field_type, 0) == 0, "bt_ctf_field_type_variant_get_field handles a NULL field name correctly"); - bt_put(ret_field_type); + bt_object_put_ref(ret_field_type); ok(bt_ctf_field_type_variant_get_field_by_index(variant_type, &ret_string, NULL, 0) == 0, "bt_ctf_field_type_variant_get_field handles a NULL field type correctly"); ok(bt_ctf_field_type_variant_get_field_by_index(variant_type, &ret_string, &ret_field_type, 1) == 0, @@ -602,7 +602,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, "bt_ctf_field_type_variant_get_field returns a correct field name"); ok(ret_field_type == int_16_type, "bt_ctf_field_type_variant_get_field returns a correct field type"); - bt_put(ret_field_type); + bt_object_put_ref(ret_field_type); ok(!bt_ctf_field_type_structure_add_field(complex_structure_type, enum_variant_type, "variant_selector"), @@ -679,13 +679,13 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, ret_stream_class = bt_ctf_event_class_get_stream_class(event_class); ok(ret_stream_class == stream_class, "bt_ctf_event_class_get_stream_class returns the correct stream class"); - bt_put(ret_stream_class); + bt_object_put_ref(ret_stream_class); ok(bt_ctf_event_class_get_field_by_name(event_class, "truie") == NULL, "bt_ctf_event_class_get_field_by_name handles an invalid field name correctly"); ret_field_type = bt_ctf_event_class_get_field_by_name(event_class, "complex_structure"); - bt_put(ret_field_type); + bt_object_put_ref(ret_field_type); event = bt_ctf_event_create(event_class); ok(event, "Instanciate a complex event"); @@ -693,7 +693,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, ret_event_class = bt_ctf_event_get_class(event); ok(ret_event_class == event_class, "bt_ctf_event_get_class returns the correct event class"); - bt_put(ret_event_class); + bt_object_put_ref(ret_event_class); uint_35_field = bt_ctf_event_get_payload(event, "uint_35"); ok(uint_35_field, "Use bt_ctf_event_get_payload to get a field instance "); @@ -703,7 +703,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, "bt_ctf_field_integer_unsigned_get_value succeeds after setting a value"); ok(ret_unsigned_int == 0x0DDF00D, "bt_ctf_field_integer_unsigned_get_value returns the correct value"); - bt_put(uint_35_field); + bt_object_put_ref(uint_35_field); int_16_field = bt_ctf_event_get_payload(event, "int_16"); bt_ctf_field_integer_signed_set_value(int_16_field, -12345); @@ -712,7 +712,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, "bt_ctf_field_integer_signed_get_value succeeds after setting a value"); ok(ret_signed_int == -12345, "bt_ctf_field_integer_signed_get_value returns the correct value"); - bt_put(int_16_field); + bt_object_put_ref(int_16_field); complex_structure_field = bt_ctf_event_get_payload(event, "complex_structure"); @@ -720,8 +720,8 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, inner_structure_field = bt_ctf_field_structure_get_field_by_index( complex_structure_field, 3); ret_field_type = bt_ctf_field_get_type(inner_structure_field); - bt_put(inner_structure_field); - bt_put(ret_field_type); + bt_object_put_ref(inner_structure_field); + bt_object_put_ref(ret_field_type); inner_structure_field = bt_ctf_field_structure_get_field_by_name( complex_structure_field, "inner_structure"); @@ -744,7 +744,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, int_16_field = bt_ctf_field_variant_get_field(variant_field, enum_variant_field); bt_ctf_field_integer_signed_set_value(int_16_field, -200); - bt_put(int_16_field); + bt_object_put_ref(int_16_field); bt_ctf_field_string_set_value(a_string_field, test_string_1); ok(!bt_ctf_field_string_append(a_string_field, test_string_2), @@ -775,23 +775,23 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, int_16_field = bt_ctf_field_sequence_get_field( a_sequence_field, i); bt_ctf_field_integer_signed_set_value(int_16_field, 4 - i); - bt_put(int_16_field); + bt_object_put_ref(int_16_field); } for (i = 0; i < ARRAY_TEST_LENGTH; i++) { int_16_field = bt_ctf_field_array_get_field( an_array_field, i); bt_ctf_field_integer_signed_set_value(int_16_field, i); - bt_put(int_16_field); + bt_object_put_ref(int_16_field); } stream_event_ctx_field = bt_ctf_event_get_stream_event_context(event); BT_ASSERT(stream_event_ctx_field); stream_event_ctx_int_field = bt_ctf_field_structure_get_field_by_name( stream_event_ctx_field, "common_event_context"); - BT_PUT(stream_event_ctx_field); + BT_OBJECT_PUT_REF_AND_RESET(stream_event_ctx_field); bt_ctf_field_integer_unsigned_set_value(stream_event_ctx_int_field, 17); - BT_PUT(stream_event_ctx_int_field); + BT_OBJECT_PUT_REF_AND_RESET(stream_event_ctx_int_field); bt_ctf_clock_set_time(clock, ++current_time); ok(bt_ctf_stream_append_event(stream, event) == 0, @@ -809,30 +809,30 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, ok(bt_ctf_stream_flush(stream) == 0, "Flush a stream containing a complex event"); - bt_put(uint_35_field); - bt_put(a_string_field); - bt_put(inner_structure_field); - bt_put(complex_structure_field); - bt_put(a_sequence_field); - bt_put(an_array_field); - bt_put(enum_variant_field); - bt_put(enum_container_field); - bt_put(variant_field); - bt_put(packet_context_field); - bt_put(packet_context); - bt_put(uint_35_type); - bt_put(int_16_type); - bt_put(string_type); - bt_put(sequence_type); - bt_put(array_type); - bt_put(inner_structure_type); - bt_put(complex_structure_type); - bt_put(uint_3_type); - bt_put(enum_variant_type); - bt_put(variant_type); - bt_put(ret_field_type); - bt_put(event_class); - bt_put(event); + bt_object_put_ref(uint_35_field); + bt_object_put_ref(a_string_field); + bt_object_put_ref(inner_structure_field); + bt_object_put_ref(complex_structure_field); + bt_object_put_ref(a_sequence_field); + bt_object_put_ref(an_array_field); + bt_object_put_ref(enum_variant_field); + bt_object_put_ref(enum_container_field); + bt_object_put_ref(variant_field); + bt_object_put_ref(packet_context_field); + bt_object_put_ref(packet_context); + bt_object_put_ref(uint_35_type); + bt_object_put_ref(int_16_type); + bt_object_put_ref(string_type); + bt_object_put_ref(sequence_type); + bt_object_put_ref(array_type); + bt_object_put_ref(inner_structure_type); + bt_object_put_ref(complex_structure_type); + bt_object_put_ref(uint_3_type); + bt_object_put_ref(enum_variant_type); + bt_object_put_ref(variant_type); + bt_object_put_ref(ret_field_type); + bt_object_put_ref(event_class); + bt_object_put_ref(event); } static @@ -939,7 +939,7 @@ void type_field_tests() sequence_type); ok(returned_type == int_16_type, "bt_ctf_field_type_sequence_get_element_field_type returns the correct type"); - bt_put(returned_type); + bt_object_put_ref(returned_type); string_type = bt_ctf_field_type_string_create(); ok(string_type, "Create a string type"); @@ -975,7 +975,7 @@ void type_field_tests() ok(bt_ctf_field_type_structure_get_field(structure_seq_type, NULL, &returned_type, 1) == 0, "bt_ctf_field_type_structure_get_field handles a NULL name correctly"); - bt_put(returned_type); + bt_object_put_ref(returned_type); ok(bt_ctf_field_type_structure_get_field(structure_seq_type, &ret_string, NULL, 1) == 0, "bt_ctf_field_type_structure_get_field handles a NULL return type correctly"); @@ -986,13 +986,13 @@ void type_field_tests() "bt_ctf_field_type_structure_get_field returns a correct field name"); ok(returned_type == sequence_type, "bt_ctf_field_type_structure_get_field returns a correct field type"); - bt_put(returned_type); + bt_object_put_ref(returned_type); returned_type = bt_ctf_field_type_structure_get_field_type_by_name( structure_seq_type, "a_sequence"); ok(returned_type == sequence_type, "bt_ctf_field_type_structure_get_field_type_by_name returns the correct field type"); - bt_put(returned_type); + bt_object_put_ref(returned_type); composite_structure_type = bt_ctf_field_type_structure_create(); ok(bt_ctf_field_type_structure_add_field(composite_structure_type, @@ -1006,7 +1006,7 @@ void type_field_tests() structure_seq_type, "a_sequence"); ok(returned_type == sequence_type, "bt_ctf_field_type_structure_get_field_type_by_name returns a correct type"); - bt_put(returned_type); + bt_object_put_ref(returned_type); int_16 = bt_ctf_field_create(int_16_type); ok(int_16, "Instanciate a signed 16-bit integer"); @@ -1045,18 +1045,18 @@ void type_field_tests() ok(enumeration_type, "Create an enumeration type with an unsigned 12-bit integer as container"); - bt_put(string); - bt_put(uint_12); - bt_put(int_16); - bt_put(composite_structure_type); - bt_put(structure_seq_type); - bt_put(string_type); - bt_put(sequence_type); - bt_put(uint_8_type); - bt_put(int_16_type); - bt_put(uint_12_type); - bt_put(enumeration_type); - bt_put(returned_type); + bt_object_put_ref(string); + bt_object_put_ref(uint_12); + bt_object_put_ref(int_16); + bt_object_put_ref(composite_structure_type); + bt_object_put_ref(structure_seq_type); + bt_object_put_ref(string_type); + bt_object_put_ref(sequence_type); + bt_object_put_ref(uint_8_type); + bt_object_put_ref(int_16_type); + bt_object_put_ref(uint_12_type); + bt_object_put_ref(enumeration_type); + bt_object_put_ref(returned_type); } static @@ -1114,9 +1114,9 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class, event = bt_ctf_event_create(event_class); ret_field = bt_ctf_event_get_payload(event, 0); ret_field_type = bt_ctf_field_get_type(ret_field); - bt_put(ret_field_type); - bt_put(ret_field); - bt_put(event); + bt_object_put_ref(ret_field_type); + bt_object_put_ref(ret_field); + bt_object_put_ref(event); for (i = 0; i < packet_resize_test_length; i++) { event = bt_ctf_event_create(event_class); @@ -1129,24 +1129,24 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class, ret |= bt_ctf_field_integer_unsigned_set_value(integer, i); ret |= bt_ctf_event_set_payload(event, "field_1", integer); - bt_put(integer); + bt_object_put_ref(integer); ret |= bt_ctf_field_string_set_value(string, "This is a test"); ret |= bt_ctf_event_set_payload(event, "a_string", string); - bt_put(string); + bt_object_put_ref(string); /* Populate stream event context */ stream_event_context = bt_ctf_event_get_stream_event_context(event); integer = bt_ctf_field_structure_get_field_by_name(stream_event_context, "common_event_context"); - BT_PUT(stream_event_context); + BT_OBJECT_PUT_REF_AND_RESET(stream_event_context); ret |= bt_ctf_field_integer_unsigned_set_value(integer, i % 42); - bt_put(integer); + bt_object_put_ref(integer); ret |= bt_ctf_stream_append_event(stream, event); - bt_put(event); + bt_object_put_ref(event); if (ret) { break; @@ -1179,15 +1179,15 @@ end: ret = bt_ctf_stream_get_discarded_events_count(stream, &ret_uint64); ok(ret == 0 && ret_uint64 == 1000, "bt_ctf_stream_get_discarded_events_count returns a correct number of discarded events after a flush"); - bt_put(integer_type); - bt_put(string_type); - bt_put(packet_context); - bt_put(packet_context_field); - bt_put(stream_event_context); - bt_put(event_class); - bt_put(ep_field_1_type); - bt_put(ep_a_string_type); - bt_put(ep_type); + bt_object_put_ref(integer_type); + bt_object_put_ref(string_type); + bt_object_put_ref(packet_context); + bt_object_put_ref(packet_context_field); + bt_object_put_ref(stream_event_context); + bt_object_put_ref(event_class); + bt_object_put_ref(ep_field_1_type); + bt_object_put_ref(ep_a_string_type); + bt_object_put_ref(ep_type); } static @@ -1233,10 +1233,10 @@ void test_empty_stream(struct bt_ctf_writer *writer) end: ok(ret == 0, "Created a stream class with default attributes and an empty stream"); - bt_put(trace); - bt_put(ret_trace); - bt_put(stream); - bt_put(stream_class); + bt_object_put_ref(trace); + bt_object_put_ref(ret_trace); + bt_object_put_ref(stream); + bt_object_put_ref(stream_class); } static @@ -1348,7 +1348,7 @@ void test_custom_event_header_stream(struct bt_ctf_writer *writer, fail("Failed to set custom_trace_packet_header_field value"); goto end; } - bt_put(integer); + bt_object_put_ref(integer); event = bt_ctf_event_create(event_class); if (!event) { @@ -1387,7 +1387,7 @@ void test_custom_event_header_stream(struct bt_ctf_writer *writer, fail("Failed to set sequence length"); goto end; } - bt_put(integer); + bt_object_put_ref(integer); for (i = 0; i < 2; i++) { integer = bt_ctf_field_sequence_get_field(sequence, i); @@ -1402,7 +1402,7 @@ void test_custom_event_header_stream(struct bt_ctf_writer *writer, goto end; } - bt_put(integer); + bt_object_put_ref(integer); integer = NULL; } @@ -1417,17 +1417,17 @@ void test_custom_event_header_stream(struct bt_ctf_writer *writer, fail("Failed to flush custom_event_header stream"); } end: - bt_put(stream); - bt_put(stream_class); - bt_put(event_class); - bt_put(event); - bt_put(integer); - bt_put(sequence); - bt_put(event_header); - bt_put(packet_header); - bt_put(sequence_type); - bt_put(integer_type); - bt_put(event_header_type); + bt_object_put_ref(stream); + bt_object_put_ref(stream_class); + bt_object_put_ref(event_class); + bt_object_put_ref(event); + bt_object_put_ref(integer); + bt_object_put_ref(sequence); + bt_object_put_ref(event_header); + bt_object_put_ref(packet_header); + bt_object_put_ref(sequence_type); + bt_object_put_ref(integer_type); + bt_object_put_ref(event_header_type); } static @@ -1524,14 +1524,14 @@ void test_instanciate_event_before_stream(struct bt_ctf_writer *writer, end: ok(ret == 0, "Create an event before instanciating its associated stream"); - bt_put(stream); - bt_put(ret_stream); - bt_put(stream_class); - bt_put(event_class); - bt_put(event); - bt_put(integer_type); - bt_put(integer); - bt_put(payload_field); + bt_object_put_ref(stream); + bt_object_put_ref(ret_stream); + bt_object_put_ref(stream_class); + bt_object_put_ref(event_class); + bt_object_put_ref(event); + bt_object_put_ref(integer_type); + bt_object_put_ref(integer); + bt_object_put_ref(payload_field); } static @@ -1544,7 +1544,7 @@ void append_existing_event_class(struct bt_ctf_stream_class *stream_class) BT_ASSERT(event_class); ok(bt_ctf_stream_class_add_event_class(stream_class, event_class) == 0, "two event classes with the same name may cohabit within the same stream class"); - bt_put(event_class); + bt_object_put_ref(event_class); event_class = bt_ctf_event_class_create("different name, ok"); BT_ASSERT(event_class); @@ -1552,7 +1552,7 @@ void append_existing_event_class(struct bt_ctf_stream_class *stream_class) BT_ASSERT(ret == 0); ok(bt_ctf_stream_class_add_event_class(stream_class, event_class), "two event classes with the same ID cannot cohabit within the same stream class"); - bt_put(event_class); + bt_object_put_ref(event_class); } static @@ -1572,7 +1572,7 @@ void test_clock_utils(void) ret = bt_ctf_clock_set_frequency(clock, 1534); BT_ASSERT(!ret); - BT_PUT(clock); + BT_OBJECT_PUT_REF_AND_RESET(clock); } int main(int argc, char **argv) @@ -1678,14 +1678,14 @@ int main(int argc, char **argv) "bt_ctf_trace_set_environment_field handles a NULL value correctly"); ok(!bt_ctf_trace_set_environment_field(trace, "test_env_int_obj", obj), "bt_ctf_trace_set_environment_field succeeds in adding an integer object"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); /* Test bt_ctf_trace_set_environment_field with a string object */ obj = bt_value_string_create_init("the value"); BT_ASSERT(obj); ok(!bt_ctf_trace_set_environment_field(trace, "test_env_str_obj", obj), "bt_ctf_trace_set_environment_field succeeds in adding a string object"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); /* Test bt_ctf_trace_set_environment_field_integer */ ok(bt_ctf_trace_set_environment_field_integer(NULL, "test_env_int", @@ -1736,12 +1736,12 @@ int main(int argc, char **argv) ret = bt_value_integer_get(obj, &ret_int64_t); ok(!ret && ret_int64_t == 23, "bt_ctf_trace_get_environment_field_value succeeds in getting an integer value"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); obj = bt_ctf_trace_get_environment_field_value_by_index(trace, 2); ret = bt_value_string_get(obj, &ret_string); ok(!ret && ret_string && !strcmp(ret_string, "the value"), "bt_ctf_trace_get_environment_field_value succeeds in getting a string value"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); /* Test bt_ctf_trace_get_environment_field_value_by_name */ ok(!bt_ctf_trace_get_environment_field_value_by_name(trace, "oh oh"), @@ -1751,7 +1751,7 @@ int main(int argc, char **argv) ret = bt_value_string_get(obj, &ret_string); ok(!ret && ret_string && !strcmp(ret_string, "oh yeah"), "bt_ctf_trace_get_environment_field_value_by_name succeeds in getting an existing field"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); /* Test environment field replacement */ ok(!bt_ctf_trace_set_environment_field_integer(trace, "test_env_int", @@ -1763,7 +1763,7 @@ int main(int argc, char **argv) ret = bt_value_integer_get(obj, &ret_int64_t); ok(!ret && ret_int64_t == 654321, "bt_ctf_trace_get_environment_field_value successfully replaces an existing field"); - BT_PUT(obj); + BT_OBJECT_PUT_REF_AND_RESET(obj); ok(bt_ctf_writer_add_environment_field(writer, "sysname", name.sysname) == 0, "Add sysname (%s) environment field to writer instance", @@ -1881,7 +1881,7 @@ int main(int argc, char **argv) ret_clock = bt_ctf_stream_class_get_clock(stream_class); ok(ret_clock == clock, "bt_ctf_stream_class_get_clock returns a correct clock"); - bt_put(ret_clock); + bt_object_put_ref(ret_clock); /* Test the event fields and event types APIs */ type_field_tests(); @@ -1910,7 +1910,7 @@ int main(int argc, char **argv) ok(bt_ctf_field_type_get_type_id( event_header_field_type) == BT_CTF_FIELD_TYPE_ID_INTEGER, "Default event header \"id\" field is an integer"); - bt_put(event_header_field_type); + bt_object_put_ref(event_header_field_type); event_header_field_type = bt_ctf_field_type_structure_get_field_type_by_name( ret_field_type, "timestamp"); @@ -1919,8 +1919,8 @@ int main(int argc, char **argv) ok(bt_ctf_field_type_get_type_id( event_header_field_type) == BT_CTF_FIELD_TYPE_ID_INTEGER, "Default event header \"timestamp\" field is an integer"); - bt_put(event_header_field_type); - bt_put(ret_field_type); + bt_object_put_ref(event_header_field_type); + bt_object_put_ref(ret_field_type); /* Add a custom trace packet header field */ packet_header_type = bt_ctf_trace_get_packet_header_field_type(trace); @@ -1931,15 +1931,15 @@ int main(int argc, char **argv) ret_field_type = bt_ctf_field_type_structure_get_field_type_by_name( packet_header_type, "magic"); ok(ret_field_type, "Default packet header type contains a \"magic\" field"); - bt_put(ret_field_type); + bt_object_put_ref(ret_field_type); ret_field_type = bt_ctf_field_type_structure_get_field_type_by_name( packet_header_type, "uuid"); ok(ret_field_type, "Default packet header type contains a \"uuid\" field"); - bt_put(ret_field_type); + bt_object_put_ref(ret_field_type); ret_field_type = bt_ctf_field_type_structure_get_field_type_by_name( packet_header_type, "stream_id"); ok(ret_field_type, "Default packet header type contains a \"stream_id\" field"); - bt_put(ret_field_type); + bt_object_put_ref(ret_field_type); packet_header_field_type = bt_ctf_field_type_integer_create(22); ok(!bt_ctf_field_type_structure_add_field(packet_header_type, @@ -1994,7 +1994,7 @@ int main(int argc, char **argv) stream_class); ok(ret_field_type == stream_event_context_type, "bt_ctf_stream_class_get_event_context_type returns the correct field type."); - bt_put(ret_field_type); + bt_object_put_ref(ret_field_type); /* Instantiate a stream and append events */ @@ -2010,7 +2010,7 @@ int main(int argc, char **argv) stream = bt_ctf_trace_get_stream_by_index(trace, 0); ok(stream == stream1, "bt_ctf_trace_get_stream_by_index() succeeds and returns the correct value"); - BT_PUT(stream); + BT_OBJECT_PUT_REF_AND_RESET(stream); /* * Creating a stream through a writer adds the given stream @@ -2029,9 +2029,9 @@ int main(int argc, char **argv) * event context types were copied for the resolving * process */ - BT_PUT(packet_header_type); - BT_PUT(packet_context_type); - BT_PUT(stream_event_context_type); + BT_OBJECT_PUT_REF_AND_RESET(packet_header_type); + BT_OBJECT_PUT_REF_AND_RESET(packet_context_type); + BT_OBJECT_PUT_REF_AND_RESET(stream_event_context_type); packet_header_type = bt_ctf_trace_get_packet_header_field_type(trace); BT_ASSERT(packet_header_type); packet_context_type = @@ -2081,7 +2081,7 @@ int main(int argc, char **argv) ret_field_type = bt_ctf_field_get_type(packet_header); ok(ret_field_type == packet_header_type, "Stream returns a packet header of the appropriate type"); - bt_put(ret_field_type); + bt_object_put_ref(ret_field_type); packet_header_field = bt_ctf_field_structure_get_field_by_name(packet_header, "custom_trace_packet_header_field"); ok(packet_header_field, @@ -2122,22 +2122,22 @@ int main(int argc, char **argv) bt_ctf_writer_flush_metadata(writer); - bt_put(clock); - bt_put(ret_stream_class); - bt_put(writer); - bt_put(stream1); - bt_put(packet_context_type); - bt_put(packet_context_field_type); - bt_put(integer_type); - bt_put(stream_event_context_type); - bt_put(ret_field_type); - bt_put(packet_header_type); - bt_put(packet_header_field_type); - bt_put(packet_header); - bt_put(packet_header_field); - bt_put(trace); + bt_object_put_ref(clock); + bt_object_put_ref(ret_stream_class); + bt_object_put_ref(writer); + bt_object_put_ref(stream1); + bt_object_put_ref(packet_context_type); + bt_object_put_ref(packet_context_field_type); + bt_object_put_ref(integer_type); + bt_object_put_ref(stream_event_context_type); + bt_object_put_ref(ret_field_type); + bt_object_put_ref(packet_header_type); + bt_object_put_ref(packet_header_field_type); + bt_object_put_ref(packet_header); + bt_object_put_ref(packet_header_field); + bt_object_put_ref(trace); free(metadata_string); - bt_put(stream_class); + bt_object_put_ref(stream_class); validate_trace(argv[1], trace_path);