#include <babeltrace/ctf-writer/event-types.h>
#include <babeltrace/ctf-writer/event-fields.h>
#include <babeltrace/ctf-ir/stream-class.h>
+#include <babeltrace/ctf-ir/ref.h>
#include <babeltrace/ctf/events.h>
#include <babeltrace/objects.h>
#include <unistd.h>
copy_event_class = bt_ctf_event_get_class(copy);
ok(orig_event_class == copy_event_class,
"original and copied events share the same event class pointer");
- bt_ctf_event_class_put(orig_event_class);
- bt_ctf_event_class_put(copy_event_class);
+ bt_ctf_put(orig_event_class);
+ bt_ctf_put(copy_event_class);
/* validate stream */
orig_stream = bt_ctf_event_get_stream(event);
ok(orig_stream == copy_stream,
"original and copied events share the same stream pointer");
}
- bt_ctf_stream_put(orig_stream);
- bt_ctf_stream_put(copy_stream);
+ bt_ctf_put(orig_stream);
+ bt_ctf_put(copy_stream);
/* header */
orig_field = bt_ctf_event_get_header(event);
"original and copied events headers are different pointers");
}
- bt_ctf_field_put(orig_field);
- bt_ctf_field_put(copy_field);
+ bt_ctf_put(orig_field);
+ bt_ctf_put(copy_field);
/* context */
orig_field = bt_ctf_event_get_event_context(event);
"original and copied events contexts are different pointers");
}
- bt_ctf_field_put(orig_field);
- bt_ctf_field_put(copy_field);
+ bt_ctf_put(orig_field);
+ bt_ctf_put(copy_field);
/* payload */
orig_field = bt_ctf_event_get_payload_field(event);
"original and copied events payloads are different pointers");
}
- bt_ctf_field_put(orig_field);
- bt_ctf_field_put(copy_field);
+ bt_ctf_put(orig_field);
+ bt_ctf_put(copy_field);
- bt_ctf_event_put(copy);
+ bt_ctf_put(copy);
}
void append_simple_event(struct bt_ctf_stream_class *stream_class,
ok(!bt_ctf_field_type_enumeration_get_container_type(NULL), "bt_ctf_field_type_enumeration_get_container_type handles NULL correctly");
ok(!bt_ctf_field_type_enumeration_create(enum_type),
"bt_ctf_field_enumeration_type_create rejects non-integer container field types");
- bt_ctf_field_type_put(returned_type);
+ bt_ctf_put(returned_type);
bt_ctf_field_type_set_alignment(float_type, 32);
ok(bt_ctf_field_type_get_alignment(NULL) < 0,
returned_type = bt_ctf_event_class_get_context_type(simple_event_class);
ok(returned_type == event_context_type,
"bt_ctf_event_class_get_context_type returns the appropriate type");
- bt_ctf_field_type_put(returned_type);
+ bt_ctf_put(returned_type);
bt_ctf_stream_class_add_event_class(stream_class, simple_event_class);
ret_event_class = bt_ctf_stream_class_get_event_class(stream_class, 0);
ok(ret_event_class == simple_event_class,
"bt_ctf_stream_class_get_event_class returns the correct event class");
- bt_ctf_event_class_put(ret_event_class);
+ bt_ctf_put(ret_event_class);
ok(!bt_ctf_stream_class_get_event_class_by_id(NULL, 0),
"bt_ctf_stream_class_get_event_class_by_id handles NULL correctly");
ok(!bt_ctf_stream_class_get_event_class_by_id(stream_class, 2),
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_ctf_event_class_put(ret_event_class);
+ bt_ctf_put(ret_event_class);
ok(bt_ctf_stream_class_get_event_class_by_name(NULL, "some event name") == NULL,
"bt_ctf_stream_class_get_event_class_by_name handles a NULL stream class correctly");
ret_event_class = bt_ctf_stream_class_get_event_class_by_name(stream_class, "Simple Event");
ok(ret_event_class == simple_event_class,
"bt_ctf_stream_class_get_event_class_by_name returns a correct event class");
- bt_ctf_event_class_put(ret_event_class);
+ bt_ctf_put(ret_event_class);
simple_event = bt_ctf_event_create(simple_event_class);
ok(simple_event,
ret_clock = bt_ctf_event_get_clock(simple_event);
ok(ret_clock == clock,
"bt_ctf_event_get_clock returns a correct clock");
- bt_ctf_clock_put(clock);
+ bt_ctf_put(clock);
integer_field = bt_ctf_field_create(uint_12_type);
bt_ctf_field_unsigned_integer_set_value(integer_field, 42);
"packet_size");
ok(packet_context_field,
"Packet context contains the default packet_size field.");
- bt_ctf_field_put(packet_context_field);
+ bt_ctf_put(packet_context_field);
packet_context_field = bt_ctf_field_structure_get_field(packet_context,
"custom_packet_context_field");
ok(bt_ctf_field_unsigned_integer_set_value(packet_context_field, 8) == 0,
ok(bt_ctf_stream_flush(stream) == 0,
"Flush trace stream with one event");
- bt_ctf_event_class_put(simple_event_class);
- bt_ctf_event_put(simple_event);
- bt_ctf_field_type_put(uint_12_type);
- bt_ctf_field_type_put(int_64_type);
- bt_ctf_field_type_put(float_type);
- bt_ctf_field_type_put(enum_type);
- bt_ctf_field_type_put(enum_type_unsigned);
- bt_ctf_field_type_put(returned_type);
- bt_ctf_field_type_put(event_context_type);
- bt_ctf_field_put(integer_field);
- bt_ctf_field_put(float_field);
- bt_ctf_field_put(enum_field);
- bt_ctf_field_put(enum_field_unsigned);
- bt_ctf_field_put(enum_container_field);
- bt_ctf_field_put(enum_container_field_unsigned);
- bt_ctf_field_put(packet_context);
- bt_ctf_field_put(packet_context_field);
- bt_ctf_field_put(stream_event_context);
- bt_ctf_field_put(stream_event_context_field);
- bt_ctf_field_put(event_context);
- bt_ctf_field_put(event_context_field);
+ bt_ctf_put(simple_event_class);
+ bt_ctf_put(simple_event);
+ bt_ctf_put(uint_12_type);
+ bt_ctf_put(int_64_type);
+ bt_ctf_put(float_type);
+ bt_ctf_put(enum_type);
+ bt_ctf_put(enum_type_unsigned);
+ bt_ctf_put(returned_type);
+ bt_ctf_put(event_context_type);
+ bt_ctf_put(integer_field);
+ bt_ctf_put(float_field);
+ bt_ctf_put(enum_field);
+ bt_ctf_put(enum_field_unsigned);
+ bt_ctf_put(enum_container_field);
+ bt_ctf_put(enum_container_field_unsigned);
+ bt_ctf_put(packet_context);
+ bt_ctf_put(packet_context_field);
+ bt_ctf_put(stream_event_context);
+ bt_ctf_put(stream_event_context_field);
+ bt_ctf_put(event_context);
+ bt_ctf_put(event_context_field);
}
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_type returns the correct type");
- bt_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(ret_field_type);
ok(bt_ctf_field_type_array_get_length(NULL) < 0,
"bt_ctf_field_type_array_get_length handles NULL correctly");
ret_field_type = bt_ctf_field_type_variant_get_tag_type(variant_type);
ok(ret_field_type == enum_variant_type,
"bt_ctf_field_type_variant_get_tag_type returns a correct tag type");
- bt_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(ret_field_type);
ok(bt_ctf_field_type_variant_get_tag_name(NULL) == NULL,
"bt_ctf_field_type_variant_get_tag_name handles NULL correctly");
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_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(ret_field_type);
ok(bt_ctf_field_type_variant_get_field_count(NULL) < 0,
"bt_ctf_field_type_variant_get_field_count handles NULL correctly");
"bt_ctf_field_type_variant_get_field handles a NULL type correctly");
ok(bt_ctf_field_type_variant_get_field(variant_type, NULL, &ret_field_type, 0) == 0,
"bt_ctf_field_type_variant_get_field handles a NULL field name correctly");
- bt_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(ret_field_type);
ok(bt_ctf_field_type_variant_get_field(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(variant_type, &ret_string, &ret_field_type, 200) < 0,
"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_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(ret_field_type);
bt_ctf_field_type_structure_add_field(complex_structure_type,
enum_variant_type, "variant_selector");
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_ctf_stream_class_put(ret_stream_class);
+ bt_ctf_put(ret_stream_class);
ok(bt_ctf_event_class_get_field_count(NULL) < 0,
"bt_ctf_event_class_get_field_count handles NULL correctly");
ok(bt_ctf_event_class_get_field(event_class, NULL,
&ret_field_type, 0) == 0,
"bt_ctf_event_class_get_field handles a NULL field name correctly");
- bt_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(ret_field_type);
ok(bt_ctf_event_class_get_field(event_class, &ret_string,
NULL, 0) == 0,
"bt_ctf_event_class_get_field handles a NULL field type correctly");
"bt_ctf_event_class_get_field returns a field");
ok(ret_field_type == uint_35_type,
"bt_ctf_event_class_get_field returns a correct field type");
- bt_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(ret_field_type);
ok(!strcmp(ret_string, "uint_35"),
"bt_ctf_event_class_get_field returns a correct field name");
ok(bt_ctf_event_class_get_field_by_name(NULL, "") == NULL,
"complex_structure");
ok(ret_field_type == complex_structure_type,
"bt_ctf_event_class_get_field_by_name returns a correct field type");
- bt_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(ret_field_type);
event = bt_ctf_event_create(event_class);
ok(event, "Instanciate a complex event");
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_ctf_event_class_put(ret_event_class);
+ bt_ctf_put(ret_event_class);
uint_35_field = bt_ctf_event_get_payload(event, "uint_35");
if (!uint_35_field) {
ok(bt_ctf_field_signed_integer_get_value(uint_35_field,
&ret_signed_int) < 0,
"bt_ctf_field_signed_integer_get_value fails on an unsigned field");
- bt_ctf_field_put(uint_35_field);
+ bt_ctf_put(uint_35_field);
int_16_field = bt_ctf_event_get_payload(event, "int_16");
bt_ctf_field_signed_integer_set_value(int_16_field, -12345);
ok(bt_ctf_field_unsigned_integer_get_value(int_16_field,
&ret_unsigned_int) < 0,
"bt_ctf_field_unsigned_integer_get_value fails on a signed field");
- bt_ctf_field_put(int_16_field);
+ bt_ctf_put(int_16_field);
complex_structure_field = bt_ctf_event_get_payload(event,
"complex_structure");
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_ctf_field_put(inner_structure_field);
+ bt_ctf_put(inner_structure_field);
ok(ret_field_type == inner_structure_type,
"bt_ctf_field_structure_get_field_by_index returns a correct field");
- bt_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(ret_field_type);
inner_structure_field = bt_ctf_field_structure_get_field(
complex_structure_field, "inner_structure");
int_16_field = bt_ctf_field_variant_get_field(variant_field,
enum_variant_field);
bt_ctf_field_signed_integer_set_value(int_16_field, -200);
- bt_ctf_field_put(int_16_field);
+ bt_ctf_put(int_16_field);
ok(!bt_ctf_field_string_get_value(a_string_field),
"bt_ctf_field_string_get_value returns NULL on an unset field");
bt_ctf_field_string_set_value(a_string_field,
int_16_field = bt_ctf_field_sequence_get_field(
a_sequence_field, i);
bt_ctf_field_signed_integer_set_value(int_16_field, 4 - i);
- bt_ctf_field_put(int_16_field);
+ bt_ctf_put(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_signed_integer_set_value(int_16_field, i);
- bt_ctf_field_put(int_16_field);
+ bt_ctf_put(int_16_field);
}
bt_ctf_clock_set_time(clock, ++current_time);
ok(bt_ctf_stream_flush(stream) == 0,
"Flush a stream containing a complex event");
- bt_ctf_field_put(uint_35_field);
- bt_ctf_field_put(a_string_field);
- bt_ctf_field_put(inner_structure_field);
- bt_ctf_field_put(complex_structure_field);
- bt_ctf_field_put(a_sequence_field);
- bt_ctf_field_put(an_array_field);
- bt_ctf_field_put(enum_variant_field);
- bt_ctf_field_put(enum_container_field);
- bt_ctf_field_put(variant_field);
- bt_ctf_field_put(ret_field);
- bt_ctf_field_put(packet_context_field);
- bt_ctf_field_put(packet_context);
- bt_ctf_field_type_put(uint_35_type);
- bt_ctf_field_type_put(int_16_type);
- bt_ctf_field_type_put(string_type);
- bt_ctf_field_type_put(sequence_type);
- bt_ctf_field_type_put(array_type);
- bt_ctf_field_type_put(inner_structure_type);
- bt_ctf_field_type_put(complex_structure_type);
- bt_ctf_field_type_put(uint_3_type);
- bt_ctf_field_type_put(enum_variant_type);
- bt_ctf_field_type_put(variant_type);
- bt_ctf_field_type_put(ret_field_type);
- bt_ctf_event_class_put(event_class);
- bt_ctf_event_put(event);
+ bt_ctf_put(uint_35_field);
+ bt_ctf_put(a_string_field);
+ bt_ctf_put(inner_structure_field);
+ bt_ctf_put(complex_structure_field);
+ bt_ctf_put(a_sequence_field);
+ bt_ctf_put(an_array_field);
+ bt_ctf_put(enum_variant_field);
+ bt_ctf_put(enum_container_field);
+ bt_ctf_put(variant_field);
+ bt_ctf_put(ret_field);
+ bt_ctf_put(packet_context_field);
+ bt_ctf_put(packet_context);
+ bt_ctf_put(uint_35_type);
+ bt_ctf_put(int_16_type);
+ bt_ctf_put(string_type);
+ bt_ctf_put(sequence_type);
+ bt_ctf_put(array_type);
+ bt_ctf_put(inner_structure_type);
+ bt_ctf_put(complex_structure_type);
+ bt_ctf_put(uint_3_type);
+ bt_ctf_put(enum_variant_type);
+ bt_ctf_put(variant_type);
+ bt_ctf_put(ret_field_type);
+ bt_ctf_put(event_class);
+ bt_ctf_put(event);
}
static void field_copy_tests_validate_same_type(struct bt_ctf_field *field,
copy_type = bt_ctf_field_get_type(field);
ok(copy_type == expected_type,
"bt_ctf_field_copy does not copy the type (%s)", name);
- bt_ctf_field_type_put(copy_type);
+ bt_ctf_put(copy_type);
}
static void field_copy_tests_validate_diff_ptrs(struct bt_ctf_field *field_a,
v_selected_cur = bt_ctf_field_variant_get_current_field(v);
ok(v_selected_cur == v_selected,
"bt_ctf_field_variant_get_current_field returns the current field");
- bt_ctf_field_put(v_selected_cur);
+ bt_ctf_put(v_selected_cur);
/* set selected v field */
ret = bt_ctf_field_sequence_set_length(v_selected, len);
assert(!ret);
ok(uint64_t_val == 7,
"bt_ctf_field_copy creates a sequence field copy with the proper length");
- bt_ctf_field_put(v_selected_copy_len);
+ bt_ctf_put(v_selected_copy_len);
v_selected_copy_len = NULL;
/* validate v_selected copy fields */
"bt_ctf_field_copy creates a valid array field element copy (a_4)");
/* put everything */
- bt_ctf_field_type_put(len_type);
- bt_ctf_field_type_put(fp_type);
- bt_ctf_field_type_put(s_type);
- bt_ctf_field_type_put(e_int_type);
- bt_ctf_field_type_put(e_type);
- bt_ctf_field_type_put(v_type);
- bt_ctf_field_type_put(v_label1_type);
- bt_ctf_field_type_put(v_label1_array_type);
- bt_ctf_field_type_put(v_label2_type);
- bt_ctf_field_type_put(v_label2_seq_type);
- bt_ctf_field_type_put(strct_type);
- bt_ctf_field_put(len);
- bt_ctf_field_put(fp);
- bt_ctf_field_put(s);
- bt_ctf_field_put(e_int);
- bt_ctf_field_put(e);
- bt_ctf_field_put(v);
- bt_ctf_field_put(v_selected);
- bt_ctf_field_put(v_selected_0);
- bt_ctf_field_put(v_selected_1);
- bt_ctf_field_put(v_selected_2);
- bt_ctf_field_put(v_selected_3);
- bt_ctf_field_put(v_selected_4);
- bt_ctf_field_put(v_selected_5);
- bt_ctf_field_put(v_selected_6);
- bt_ctf_field_put(a);
- bt_ctf_field_put(a_0);
- bt_ctf_field_put(a_1);
- bt_ctf_field_put(a_2);
- bt_ctf_field_put(a_3);
- bt_ctf_field_put(a_4);
- bt_ctf_field_put(strct);
- bt_ctf_field_put(len_copy);
- bt_ctf_field_put(fp_copy);
- bt_ctf_field_put(s_copy);
- bt_ctf_field_put(e_int_copy);
- bt_ctf_field_put(e_copy);
- bt_ctf_field_put(v_copy);
- bt_ctf_field_put(v_selected_copy);
- bt_ctf_field_put(v_selected_0_copy);
- bt_ctf_field_put(v_selected_1_copy);
- bt_ctf_field_put(v_selected_2_copy);
- bt_ctf_field_put(v_selected_3_copy);
- bt_ctf_field_put(v_selected_4_copy);
- bt_ctf_field_put(v_selected_5_copy);
- bt_ctf_field_put(v_selected_6_copy);
- bt_ctf_field_put(a_copy);
- bt_ctf_field_put(a_0_copy);
- bt_ctf_field_put(a_1_copy);
- bt_ctf_field_put(a_2_copy);
- bt_ctf_field_put(a_3_copy);
- bt_ctf_field_put(a_4_copy);
- bt_ctf_field_put(strct_copy);
+ bt_ctf_put(len_type);
+ bt_ctf_put(fp_type);
+ bt_ctf_put(s_type);
+ bt_ctf_put(e_int_type);
+ bt_ctf_put(e_type);
+ bt_ctf_put(v_type);
+ bt_ctf_put(v_label1_type);
+ bt_ctf_put(v_label1_array_type);
+ bt_ctf_put(v_label2_type);
+ bt_ctf_put(v_label2_seq_type);
+ bt_ctf_put(strct_type);
+ bt_ctf_put(len);
+ bt_ctf_put(fp);
+ bt_ctf_put(s);
+ bt_ctf_put(e_int);
+ bt_ctf_put(e);
+ bt_ctf_put(v);
+ bt_ctf_put(v_selected);
+ bt_ctf_put(v_selected_0);
+ bt_ctf_put(v_selected_1);
+ bt_ctf_put(v_selected_2);
+ bt_ctf_put(v_selected_3);
+ bt_ctf_put(v_selected_4);
+ bt_ctf_put(v_selected_5);
+ bt_ctf_put(v_selected_6);
+ bt_ctf_put(a);
+ bt_ctf_put(a_0);
+ bt_ctf_put(a_1);
+ bt_ctf_put(a_2);
+ bt_ctf_put(a_3);
+ bt_ctf_put(a_4);
+ bt_ctf_put(strct);
+ bt_ctf_put(len_copy);
+ bt_ctf_put(fp_copy);
+ bt_ctf_put(s_copy);
+ bt_ctf_put(e_int_copy);
+ bt_ctf_put(e_copy);
+ bt_ctf_put(v_copy);
+ bt_ctf_put(v_selected_copy);
+ bt_ctf_put(v_selected_0_copy);
+ bt_ctf_put(v_selected_1_copy);
+ bt_ctf_put(v_selected_2_copy);
+ bt_ctf_put(v_selected_3_copy);
+ bt_ctf_put(v_selected_4_copy);
+ bt_ctf_put(v_selected_5_copy);
+ bt_ctf_put(v_selected_6_copy);
+ bt_ctf_put(a_copy);
+ bt_ctf_put(a_0_copy);
+ bt_ctf_put(a_1_copy);
+ bt_ctf_put(a_2_copy);
+ bt_ctf_put(a_3_copy);
+ bt_ctf_put(a_4_copy);
+ bt_ctf_put(strct_copy);
}
void type_field_tests()
sequence_type);
ok(returned_type == int_16_type,
"bt_ctf_field_type_sequence_get_element_type returns the correct type");
- bt_ctf_field_type_put(returned_type);
+ bt_ctf_put(returned_type);
string_type = bt_ctf_field_type_string_create();
ok(string_type, "Create a string type");
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_ctf_field_type_put(returned_type);
+ bt_ctf_put(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");
"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_ctf_field_type_put(returned_type);
+ bt_ctf_put(returned_type);
ok(bt_ctf_field_type_structure_get_field_type_by_name(NULL, "a_sequence") == NULL,
"bt_ctf_field_type_structure_get_field_type_by_name handles a NULL structure correctly");
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_ctf_field_type_put(returned_type);
+ bt_ctf_put(returned_type);
composite_structure_type = bt_ctf_field_type_structure_create();
ok(bt_ctf_field_type_structure_add_field(composite_structure_type,
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_ctf_field_type_put(returned_type);
+ bt_ctf_put(returned_type);
int_16 = bt_ctf_field_create(int_16_type);
ok(int_16, "Instanciate a signed 16-bit integer");
ok(!enumeration,
"Check enumeration types are validated before instantiation");
- bt_ctf_field_put(string);
- bt_ctf_field_put(uint_12);
- bt_ctf_field_put(int_16);
- bt_ctf_field_put(enumeration);
- bt_ctf_field_type_put(composite_structure_type);
- bt_ctf_field_type_put(structure_seq_type);
- bt_ctf_field_type_put(string_type);
- bt_ctf_field_type_put(sequence_type);
- bt_ctf_field_type_put(uint_8_type);
- bt_ctf_field_type_put(int_16_type);
- bt_ctf_field_type_put(uint_12_type);
- bt_ctf_field_type_put(enumeration_type);
- bt_ctf_field_type_put(enumeration_sequence_type);
- bt_ctf_field_type_put(enumeration_array_type);
- bt_ctf_field_type_put(returned_type);
+ bt_ctf_put(string);
+ bt_ctf_put(uint_12);
+ bt_ctf_put(int_16);
+ bt_ctf_put(enumeration);
+ bt_ctf_put(composite_structure_type);
+ bt_ctf_put(structure_seq_type);
+ bt_ctf_put(string_type);
+ bt_ctf_put(sequence_type);
+ bt_ctf_put(uint_8_type);
+ bt_ctf_put(int_16_type);
+ bt_ctf_put(uint_12_type);
+ bt_ctf_put(enumeration_type);
+ bt_ctf_put(enumeration_sequence_type);
+ bt_ctf_put(enumeration_array_type);
+ bt_ctf_put(returned_type);
}
void packet_resize_test(struct bt_ctf_stream_class *stream_class,
ret_field_type = bt_ctf_field_get_type(ret_field);
ok(ret_field_type == integer_type,
"bt_ctf_event_get_payload_by_index returns a correct field");
- bt_ctf_field_type_put(ret_field_type);
- bt_ctf_field_put(ret_field);
+ bt_ctf_put(ret_field_type);
+ bt_ctf_put(ret_field);
ok(bt_ctf_event_get_payload_by_index(NULL, 0) == NULL,
"bt_ctf_event_get_payload_by_index handles NULL correctly");
ok(bt_ctf_event_get_payload_by_index(event, 4) == NULL,
"bt_ctf_event_get_payload_by_index handles an invalid index correctly");
- bt_ctf_event_put(event);
+ bt_ctf_put(event);
ok(bt_ctf_stream_get_event_context(NULL) == NULL,
"bt_ctf_stream_get_event_context handles NULL correctly");
ret_field = bt_ctf_field_create(integer_type);
ok(bt_ctf_stream_set_event_context(stream, ret_field) < 0,
"bt_ctf_stream_set_event_context rejects an event context of incorrect type");
- bt_ctf_field_put(ret_field);
+ bt_ctf_put(ret_field);
for (i = 0; i < PACKET_RESIZE_TEST_LENGTH; i++) {
event = bt_ctf_event_create(event_class);
ret |= bt_ctf_field_unsigned_integer_set_value(integer, i);
ret |= bt_ctf_event_set_payload(event, "field_1",
integer);
- bt_ctf_field_put(integer);
+ bt_ctf_put(integer);
ret |= bt_ctf_field_string_set_value(string, "This is a test");
ret |= bt_ctf_event_set_payload(event, "a_string",
string);
- bt_ctf_field_put(string);
+ bt_ctf_put(string);
/* Populate stream event context */
integer = bt_ctf_field_structure_get_field(event_context,
"common_event_context");
ret |= bt_ctf_field_unsigned_integer_set_value(integer,
i % 42);
- bt_ctf_field_put(integer);
+ bt_ctf_put(integer);
ret |= bt_ctf_stream_append_event(stream, event);
- bt_ctf_event_put(event);
+ bt_ctf_put(event);
if (ret) {
break;
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_ctf_field_type_put(integer_type);
- bt_ctf_field_type_put(string_type);
- bt_ctf_field_put(packet_context);
- bt_ctf_field_put(packet_context_field);
- bt_ctf_field_put(event_context);
- bt_ctf_event_class_put(event_class);
+ bt_ctf_put(integer_type);
+ bt_ctf_put(string_type);
+ bt_ctf_put(packet_context);
+ bt_ctf_put(packet_context_field);
+ bt_ctf_put(event_context);
+ bt_ctf_put(event_class);
}
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_ctf_trace_put(trace);
- bt_ctf_trace_put(ret_trace);
- bt_ctf_stream_put(stream);
- bt_ctf_stream_class_put(stream_class);
+ bt_ctf_put(trace);
+ bt_ctf_put(ret_trace);
+ bt_ctf_put(stream);
+ bt_ctf_put(stream_class);
}
void test_custom_event_header_stream(struct bt_ctf_writer *writer)
fail("Failed to set custom_trace_packet_header_field value");
goto end;
}
- bt_ctf_field_put(integer);
+ bt_ctf_put(integer);
event = bt_ctf_event_create(event_class);
if (!event) {
fail("Failed to set sequence length");
goto end;
}
- bt_ctf_field_put(integer);
+ bt_ctf_put(integer);
for (i = 0; i < 2; i++) {
integer = bt_ctf_field_sequence_get_field(sequence, i);
goto end;
}
- bt_ctf_field_put(integer);
+ bt_ctf_put(integer);
integer = NULL;
}
fail("Failed to flush custom_event_header stream");
}
end:
- bt_ctf_clock_put(clock);
- bt_ctf_trace_put(trace);
- bt_ctf_stream_put(stream);
- bt_ctf_stream_class_put(stream_class);
- bt_ctf_event_class_put(event_class);
- bt_ctf_event_put(event);
- bt_ctf_field_put(integer);
- bt_ctf_field_put(sequence);
- bt_ctf_field_put(event_header);
- bt_ctf_field_put(packet_header);
- bt_ctf_field_type_put(sequence_type);
- bt_ctf_field_type_put(integer_type);
- bt_ctf_field_type_put(event_header_type);
+ bt_ctf_put(clock);
+ bt_ctf_put(trace);
+ bt_ctf_put(stream);
+ bt_ctf_put(stream_class);
+ bt_ctf_put(event_class);
+ bt_ctf_put(event);
+ bt_ctf_put(integer);
+ bt_ctf_put(sequence);
+ bt_ctf_put(event_header);
+ bt_ctf_put(packet_header);
+ bt_ctf_put(sequence_type);
+ bt_ctf_put(integer_type);
+ bt_ctf_put(event_header_type);
}
void test_instanciate_event_before_stream(struct bt_ctf_writer *writer)
end:
ok(ret == 0,
"Create an event before instanciating its associated stream");
- bt_ctf_trace_put(trace);
- bt_ctf_stream_put(stream);
- bt_ctf_stream_put(ret_stream);
- bt_ctf_stream_class_put(stream_class);
- bt_ctf_event_class_put(event_class);
- bt_ctf_event_put(event);
- bt_ctf_field_type_put(integer_type);
- bt_ctf_field_put(integer);
- bt_ctf_clock_put(clock);
+ bt_ctf_put(trace);
+ bt_ctf_put(stream);
+ bt_ctf_put(ret_stream);
+ bt_ctf_put(stream_class);
+ bt_ctf_put(event_class);
+ bt_ctf_put(event);
+ bt_ctf_put(integer_type);
+ bt_ctf_put(integer);
+ bt_ctf_put(clock);
}
void append_existing_event_class(struct bt_ctf_stream_class *stream_class)
assert(event_class = bt_ctf_event_class_create("Simple Event"));
ok(bt_ctf_stream_class_add_event_class(stream_class, event_class),
"two event classes with the same name cannot cohabit within the same stream class");
- bt_ctf_event_class_put(event_class);
+ bt_ctf_put(event_class);
event_class = bt_ctf_event_class_create("different name, ok");
assert(event_class);
assert(!bt_ctf_event_class_set_id(event_class, 11));
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_ctf_event_class_put(event_class);
+ bt_ctf_put(event_class);
}
int main(int argc, char **argv)
ret_clock = bt_ctf_trace_get_clock(trace, 0);
ok(ret_clock == clock,
"bt_ctf_trace_get_clock returns the right clock instance");
- bt_ctf_clock_put(ret_clock);
+ bt_ctf_put(ret_clock);
ok(!bt_ctf_trace_get_clock_by_name(trace, NULL),
"bt_ctf_trace_get_clock_by_name correctly handles NULL (trace)");
ok(!bt_ctf_trace_get_clock_by_name(NULL, clock_name),
ret_clock = bt_ctf_trace_get_clock_by_name(trace, clock_name);
ok(ret_clock == clock,
"bt_ctf_trace_get_clock_by_name returns the right clock instance");
- bt_ctf_clock_put(ret_clock);
+ bt_ctf_put(ret_clock);
ok(!bt_ctf_trace_get_clock_by_name(trace, "random"),
"bt_ctf_trace_get_clock_by_name fails when the requested clock doesn't exist");
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_ctf_clock_put(ret_clock);
+ bt_ctf_put(ret_clock);
/* Test the event fields and event types APIs */
type_field_tests();
ok(bt_ctf_field_type_get_type_id(
event_header_field_type) == CTF_TYPE_INTEGER,
"Default event header \"id\" field is an integer");
- bt_ctf_field_type_put(event_header_field_type);
+ bt_ctf_put(event_header_field_type);
event_header_field_type =
bt_ctf_field_type_structure_get_field_type_by_name(
ret_field_type, "timestamp");
ok(bt_ctf_field_type_get_type_id(
event_header_field_type) == CTF_TYPE_INTEGER,
"Default event header \"timestamp\" field is an integer");
- bt_ctf_field_type_put(event_header_field_type);
- bt_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(event_header_field_type);
+ bt_ctf_put(ret_field_type);
/* Add a custom trace packet header field */
ok(bt_ctf_trace_get_packet_header_type(NULL) == NULL,
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_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(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_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(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_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(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,
stream_class);
ok(ret_field_type == stream_event_context_type,
"bt_ctf_stream_class_get_event_context_type returns the correct field type.");
- bt_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(ret_field_type);
/* Instantiate a stream and append events */
stream1 = bt_ctf_writer_create_stream(writer, stream_class);
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_ctf_field_type_put(ret_field_type);
+ bt_ctf_put(ret_field_type);
packet_header_field = bt_ctf_field_structure_get_field(packet_header,
"custom_trace_packet_header_field");
ok(packet_header_field,
validate_metadata(argv[1], metadata_path);
validate_trace(argv[2], trace_path);
- bt_ctf_clock_put(clock);
- bt_ctf_stream_class_put(ret_stream_class);
- bt_ctf_writer_put(writer);
- bt_ctf_stream_put(stream1);
- bt_ctf_field_type_put(packet_context_type);
- bt_ctf_field_type_put(packet_context_field_type);
- bt_ctf_field_type_put(integer_type);
- bt_ctf_field_type_put(stream_event_context_type);
- bt_ctf_field_type_put(ret_field_type);
- bt_ctf_field_type_put(packet_header_type);
- bt_ctf_field_type_put(packet_header_field_type);
- bt_ctf_field_put(packet_header);
- bt_ctf_field_put(packet_header_field);
- bt_ctf_trace_put(trace);
+ bt_ctf_put(clock);
+ bt_ctf_put(ret_stream_class);
+ bt_ctf_put(writer);
+ bt_ctf_put(stream1);
+ bt_ctf_put(packet_context_type);
+ bt_ctf_put(packet_context_field_type);
+ bt_ctf_put(integer_type);
+ bt_ctf_put(stream_event_context_type);
+ bt_ctf_put(ret_field_type);
+ bt_ctf_put(packet_header_type);
+ bt_ctf_put(packet_header_field_type);
+ bt_ctf_put(packet_header);
+ bt_ctf_put(packet_header_field);
+ bt_ctf_put(trace);
free(metadata_string);
ok(bt_ctf_stream_class_get_trace(stream_class) == NULL,
"bt_ctf_stream_class_get_trace returns NULL after its trace has been reclaimed");
- bt_ctf_stream_class_put(stream_class);
+ bt_ctf_put(stream_class);
/* Remove all trace files and delete temporary trace directory */
DIR *trace_dir = opendir(trace_path);
projects / babeltrace.git / commitdiff
