* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#define _GNU_SOURCE
#include <babeltrace/ctf-writer/writer.h>
#include <babeltrace/ctf-writer/clock.h>
#include <babeltrace/ctf-writer/stream.h>
#include <babeltrace/ctf-writer/event-types.h>
#include <babeltrace/ctf-writer/event-fields.h>
#include <babeltrace/ctf-ir/stream-class.h>
+#include <babeltrace/ref.h>
#include <babeltrace/ctf/events.h>
-#include <babeltrace/objects.h>
+#include <babeltrace/values.h>
#include <unistd.h>
-#include <stdlib.h>
+#include <babeltrace/compat/stdlib.h>
#include <stdio.h>
#include <sys/utsname.h>
#include <babeltrace/compat/limits.h>
#include <assert.h>
#include <sys/wait.h>
#include <fcntl.h>
-#include <dirent.h>
+#include <babeltrace/compat/dirent.h>
#include "tap/tap.h"
#include <math.h>
#include <float.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_put(orig_event_class);
+ bt_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_put(orig_stream);
+ bt_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_put(orig_field);
+ bt_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_put(orig_field);
+ bt_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_put(orig_field);
+ bt_put(copy_field);
- bt_ctf_event_put(copy);
+ bt_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_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_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_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_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_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_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_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_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);
}
void append_complex_event(struct bt_ctf_stream_class *stream_class,
struct bt_ctf_stream_class *ret_stream_class;
struct bt_ctf_event_class *ret_event_class;
struct bt_ctf_field *packet_context, *packet_context_field;
- struct bt_object *obj;
+ struct bt_value *obj;
ok(bt_ctf_field_type_set_alignment(int_16_type, 0),
"bt_ctf_field_type_set_alignment handles 0-alignment correctly");
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_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_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_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_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_put(ret_field_type);
bt_ctf_field_type_structure_add_field(complex_structure_type,
enum_variant_type, "variant_selector");
"bt_ctf_event_class_get_id returns the correct value");
/* Test event class attributes */
- assert(obj = bt_object_integer_create_init(15));
+ obj = bt_value_integer_create_init(15);
+ assert(obj);
ok(bt_ctf_event_class_set_attribute(NULL, "id", obj),
"bt_ctf_event_class_set_attribute handles a NULL event class correctly");
ok(bt_ctf_event_class_set_attribute(event_class, NULL, obj),
"bt_ctf_event_class_set_attribute handles a NULL name correctly");
ok(bt_ctf_event_class_set_attribute(event_class, "id", NULL),
"bt_ctf_event_class_set_attribute handles a NULL value correctly");
- assert(!bt_object_integer_set(obj, -3));
+ assert(!bt_value_integer_set(obj, -3));
ok(bt_ctf_event_class_set_attribute(event_class, "id", obj),
"bt_ctf_event_class_set_attribute fails with a negative \"id\" attribute");
- assert(!bt_object_integer_set(obj, 11));
+ assert(!bt_value_integer_set(obj, 11));
ret = bt_ctf_event_class_set_attribute(event_class, "id", obj);
ok(!ret && bt_ctf_event_class_get_id(event_class) == 11,
"bt_ctf_event_class_set_attribute succeeds in replacing the existing \"id\" attribute");
ret &= bt_ctf_event_class_set_attribute(event_class, "model.emf.uri", obj);
ok(ret,
"bt_ctf_event_class_set_attribute cannot set \"name\" or \"model.emf.uri\" to an integer value");
- BT_OBJECT_PUT(obj);
+ BT_PUT(obj);
- obj = bt_object_integer_create_init(5);
+ obj = bt_value_integer_create_init(5);
assert(obj);
ok(!bt_ctf_event_class_set_attribute(event_class, "loglevel", obj),
"bt_ctf_event_class_set_attribute succeeds in setting the \"loglevel\" attribute");
- BT_OBJECT_PUT(obj);
+ BT_PUT(obj);
ok(!bt_ctf_event_class_get_attribute_value_by_name(NULL, "loglevel"),
"bt_ctf_event_class_get_attribute_value_by_name handles a NULL event class correctly");
ok(!bt_ctf_event_class_get_attribute_value_by_name(event_class, NULL),
obj = bt_ctf_event_class_get_attribute_value_by_name(event_class,
"loglevel");
int64_value = 0;
- ret = bt_object_integer_get(obj, &int64_value);
+ ret = bt_value_integer_get(obj, &int64_value);
ok(obj && !ret && int64_value == 5,
"bt_ctf_event_class_get_attribute_value_by_name returns the correct value");
- BT_OBJECT_PUT(obj);
+ BT_PUT(obj);
- assert(obj = bt_object_string_create_init("nu name"));
+ obj = bt_value_string_create_init("nu name");
+ assert(obj);
assert(!bt_ctf_event_class_set_attribute(event_class, "name", obj));
ret_string = bt_ctf_event_class_get_name(event_class);
ok(!strcmp(ret_string, "nu name"),
ret &= bt_ctf_event_class_set_attribute(event_class, "loglevel", obj);
ok(ret,
"bt_ctf_event_class_set_attribute cannot set \"id\" or \"loglevel\" to a string value");
- BT_OBJECT_PUT(obj);
- obj = bt_object_string_create_init("http://kernel.org/");
+ BT_PUT(obj);
+ obj = bt_value_string_create_init("http://kernel.org/");
assert(obj);
assert(!bt_ctf_event_class_set_attribute(event_class, "model.emf.uri", obj));
- BT_OBJECT_PUT(obj);
+ BT_PUT(obj);
ok(bt_ctf_event_class_get_attribute_count(NULL),
"bt_ctf_event_class_get_attribute_count handles a NULL event class");
if (!strcmp(ret_string, "id")) {
attrs_count.id++;
- ok(bt_object_is_integer(obj),
+ ok(bt_value_is_integer(obj),
"bt_ctf_event_class_get_attribute_value returns the correct type (\"%s\")",
ret_string);
} else if (!strcmp(ret_string, "name")) {
attrs_count.name++;
- ok(bt_object_is_string(obj),
+ ok(bt_value_is_string(obj),
"bt_ctf_event_class_get_attribute_value returns the correct type (\"%s\")",
ret_string);
} else if (!strcmp(ret_string, "loglevel")) {
attrs_count.loglevel++;
- ok(bt_object_is_integer(obj),
+ ok(bt_value_is_integer(obj),
"bt_ctf_event_class_get_attribute_value returns the correct type (\"%s\")",
ret_string);
} else if (!strcmp(ret_string, "model.emf.uri")) {
attrs_count.modelemfuri++;
- ok(bt_object_is_string(obj),
+ ok(bt_value_is_string(obj),
"bt_ctf_event_class_get_attribute_value returns the correct type (\"%s\")",
ret_string);
} else {
attrs_count.unknown++;
}
- BT_OBJECT_PUT(obj);
+ BT_PUT(obj);
}
ok(attrs_count.unknown == 0, "event class has no unknown attributes");
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_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_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_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_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_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_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_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_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_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_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_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_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_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(ret_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);
}
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_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_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_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_put(len_type);
+ bt_put(fp_type);
+ bt_put(s_type);
+ bt_put(e_int_type);
+ bt_put(e_type);
+ bt_put(v_type);
+ bt_put(v_label1_type);
+ bt_put(v_label1_array_type);
+ bt_put(v_label2_type);
+ bt_put(v_label2_seq_type);
+ bt_put(strct_type);
+ bt_put(len);
+ bt_put(fp);
+ bt_put(s);
+ bt_put(e_int);
+ bt_put(e);
+ bt_put(v);
+ bt_put(v_selected);
+ bt_put(v_selected_0);
+ bt_put(v_selected_1);
+ bt_put(v_selected_2);
+ bt_put(v_selected_3);
+ bt_put(v_selected_4);
+ bt_put(v_selected_5);
+ bt_put(v_selected_6);
+ bt_put(a);
+ bt_put(a_0);
+ bt_put(a_1);
+ bt_put(a_2);
+ bt_put(a_3);
+ bt_put(a_4);
+ bt_put(strct);
+ bt_put(len_copy);
+ bt_put(fp_copy);
+ bt_put(s_copy);
+ bt_put(e_int_copy);
+ bt_put(e_copy);
+ bt_put(v_copy);
+ bt_put(v_selected_copy);
+ bt_put(v_selected_0_copy);
+ bt_put(v_selected_1_copy);
+ bt_put(v_selected_2_copy);
+ bt_put(v_selected_3_copy);
+ bt_put(v_selected_4_copy);
+ bt_put(v_selected_5_copy);
+ bt_put(v_selected_6_copy);
+ bt_put(a_copy);
+ bt_put(a_0_copy);
+ bt_put(a_1_copy);
+ bt_put(a_2_copy);
+ bt_put(a_3_copy);
+ bt_put(a_4_copy);
+ bt_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_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_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_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_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_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_put(string);
+ bt_put(uint_12);
+ bt_put(int_16);
+ bt_put(enumeration);
+ 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(enumeration_sequence_type);
+ bt_put(enumeration_array_type);
+ bt_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_put(ret_field_type);
+ bt_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_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_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_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_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_put(integer);
ret |= bt_ctf_stream_append_event(stream, event);
- bt_ctf_event_put(event);
+ bt_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_put(integer_type);
+ bt_put(string_type);
+ bt_put(packet_context);
+ bt_put(packet_context_field);
+ bt_put(event_context);
+ bt_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_put(trace);
+ bt_put(ret_trace);
+ bt_put(stream);
+ bt_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_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_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_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_put(clock);
+ bt_put(trace);
+ 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);
}
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_put(trace);
+ 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(clock);
}
void append_existing_event_class(struct bt_ctf_stream_class *stream_class)
{
struct bt_ctf_event_class *event_class;
- assert(event_class = bt_ctf_event_class_create("Simple Event"));
+ event_class = bt_ctf_event_class_create("Simple Event");
+ assert(event_class);
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_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_put(event_class);
}
int main(int argc, char **argv)
struct bt_ctf_trace *trace;
int ret;
int64_t ret_int64_t;
- struct bt_object *obj;
+ struct bt_value *obj;
if (argc < 3) {
printf("Usage: tests-ctf-writer path_to_ctf_parser_test path_to_babeltrace\n");
plan_no_plan();
- if (!mkdtemp(trace_path)) {
+ if (!bt_mkdtemp(trace_path)) {
perror("# perror");
}
"bt_ctf_writer_add_environment_field error with NULL field value");
/* Test bt_ctf_trace_set_environment_field with an integer object */
- obj = bt_object_integer_create_init(23);
+ obj = bt_value_integer_create_init(23);
assert(obj);
ok(bt_ctf_trace_set_environment_field(NULL, "test_env_int_obj", obj),
"bt_ctf_trace_set_environment_field handles a NULL trace correctly");
"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_OBJECT_PUT(obj);
+ BT_PUT(obj);
/* Test bt_ctf_trace_set_environment_field with a string object */
- obj = bt_object_string_create_init("the value");
+ obj = bt_value_string_create_init("the value");
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_OBJECT_PUT(obj);
+ BT_PUT(obj);
/* Test bt_ctf_trace_set_environment_field_integer */
ok(bt_ctf_trace_set_environment_field_integer(NULL, "test_env_int",
ok(bt_ctf_trace_get_environment_field_value(trace, 5) == NULL,
"bt_ctf_trace_get_environment_field_value handles an invalid index correctly (too large)");
obj = bt_ctf_trace_get_environment_field_value(trace, 1);
- ret = bt_object_integer_get(obj, &ret_int64_t);
+ 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_OBJECT_PUT(obj);
+ BT_PUT(obj);
obj = bt_ctf_trace_get_environment_field_value(trace, 2);
- ret = bt_object_string_get(obj, &ret_string);
+ 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_OBJECT_PUT(obj);
+ BT_PUT(obj);
/* Test bt_ctf_trace_get_environment_field_value_by_name */
ok(!bt_ctf_trace_get_environment_field_value_by_name(NULL,
"bt_ctf_trace_get_environment_field_value_by_name returns NULL or an unknown field name");
obj = bt_ctf_trace_get_environment_field_value_by_name(trace,
"test_env_str");
- ret = bt_object_string_get(obj, &ret_string);
+ 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_OBJECT_PUT(obj);
+ BT_PUT(obj);
/* Test environment field replacement */
ok(!bt_ctf_trace_set_environment_field_integer(trace, "test_env_int",
ok(bt_ctf_trace_get_environment_field_count(trace) == 5,
"bt_ctf_trace_set_environment_field_integer with an existing key does not increase the environment size");
obj = bt_ctf_trace_get_environment_field_value(trace, 3);
- ret = bt_object_integer_get(obj, &ret_int64_t);
+ 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_OBJECT_PUT(obj);
+ BT_PUT(obj);
- if (uname(&name)) {
+ /* On Solaris, uname() can return any positive value on success */
+ if (uname(&name) < 0) {
perror("uname");
return -1;
}
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_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_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_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_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_put(event_header_field_type);
+ bt_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_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_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_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_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_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_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);
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_put(stream_class);
/* Remove all trace files and delete temporary trace directory */
DIR *trace_dir = opendir(trace_path);
struct dirent *entry;
while ((entry = readdir(trace_dir))) {
if (entry->d_type == DT_REG) {
- unlinkat(dirfd(trace_dir), entry->d_name, 0);
+ unlinkat(bt_dirfd(trace_dir), entry->d_name, 0);
}
}