X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Flib%2Ftest_ctf_writer.c;h=ae0f9705e273b204fb3bd1cae7ab9452469ec649;hb=6f01055683febfdf081fe0758ebd8564aace0f70;hp=d246510e9fae0e88564cd9bdf5b76f193d4ecd2e;hpb=8bbe269d7275dfa1331b571bbe1cf8a7036be0c9;p=babeltrace.git diff --git a/tests/lib/test_ctf_writer.c b/tests/lib/test_ctf_writer.c index d246510e..ae0f9705 100644 --- a/tests/lib/test_ctf_writer.c +++ b/tests/lib/test_ctf_writer.c @@ -25,7 +25,8 @@ #include #include #include -#include +#include +#include #include #include #include @@ -43,7 +44,7 @@ #include "tap/tap.h" #include #include -#include +#include "common.h" #define METADATA_LINE_SIZE 512 #define SEQUENCE_TEST_LENGTH 10 @@ -56,12 +57,14 @@ #define DEFAULT_CLOCK_OFFSET_S 0 #define DEFAULT_CLOCK_IS_ABSOLUTE 0 #define DEFAULT_CLOCK_TIME 0 +#define DEFAULT_CLOCK_VALUE 0 -#define NR_TESTS 588 +#define NR_TESTS 609 -static uint64_t current_time = 42; +static int64_t current_time = 42; /* Return 1 if uuids match, zero if different. */ +static int uuid_match(const unsigned char *uuid_a, const unsigned char *uuid_b) { int ret = 0; @@ -82,6 +85,7 @@ end: return ret; } +static void validate_metadata(char *parser_path, char *metadata_path) { int ret = 0; @@ -198,6 +202,7 @@ close_fp: } } +static void validate_trace(char *parser_path, char *trace_path) { int ret = 0; @@ -280,89 +285,7 @@ close_fp: } } -void event_copy_tests(struct bt_ctf_event *event) -{ - struct bt_ctf_event *copy; - struct bt_ctf_event_class *orig_event_class; - struct bt_ctf_event_class *copy_event_class; - struct bt_ctf_stream *orig_stream; - struct bt_ctf_stream *copy_stream; - struct bt_ctf_field *orig_field; - struct bt_ctf_field *copy_field; - - /* copy */ - ok(!bt_ctf_event_copy(NULL), - "bt_ctf_event_copy handles NULL correctly"); - copy = bt_ctf_event_copy(event); - ok(copy, "bt_ctf_event_copy returns a valid pointer"); - - /* validate event class */ - orig_event_class = bt_ctf_event_get_class(event); - assert(orig_event_class); - 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_put(orig_event_class); - bt_put(copy_event_class); - - /* validate stream */ - orig_stream = bt_ctf_event_get_stream(event); - copy_stream = bt_ctf_event_get_stream(copy); - - if (!orig_stream) { - ok(!copy_stream, "original and copied events have no stream"); - } else { - ok(orig_stream == copy_stream, - "original and copied events share the same stream pointer"); - } - bt_put(orig_stream); - bt_put(copy_stream); - - /* header */ - orig_field = bt_ctf_event_get_header(event); - copy_field = bt_ctf_event_get_header(copy); - - if (!orig_field) { - ok(!copy_field, "original and copied events have no header"); - } else { - ok(orig_field != copy_field, - "original and copied events headers are different pointers"); - } - - bt_put(orig_field); - bt_put(copy_field); - - /* context */ - orig_field = bt_ctf_event_get_event_context(event); - copy_field = bt_ctf_event_get_event_context(copy); - - if (!orig_field) { - ok(!copy_field, "original and copied events have no context"); - } else { - ok(orig_field != copy_field, - "original and copied events contexts are different pointers"); - } - - bt_put(orig_field); - bt_put(copy_field); - - /* payload */ - orig_field = bt_ctf_event_get_payload_field(event); - copy_field = bt_ctf_event_get_payload_field(copy); - - if (!orig_field) { - ok(!copy_field, "original and copied events have no payload"); - } else { - ok(orig_field != copy_field, - "original and copied events payloads are different pointers"); - } - - bt_put(orig_field); - bt_put(copy_field); - - bt_put(copy); -} - +static void append_simple_event(struct bt_ctf_stream_class *stream_class, struct bt_ctf_stream *stream, struct bt_ctf_clock *clock) { @@ -380,6 +303,7 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, bt_ctf_field_type_enumeration_create(uint_12_type); struct bt_ctf_field_type *event_context_type = bt_ctf_field_type_structure_create(); + struct bt_ctf_field_type *event_payload_type = NULL; struct bt_ctf_field_type *returned_type; struct bt_ctf_event *simple_event; struct bt_ctf_field *integer_field; @@ -403,6 +327,10 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, struct bt_ctf_field *stream_event_context_field; struct bt_ctf_field *event_context; struct bt_ctf_field *event_context_field; + struct bt_ctf_field_type *ep_integer_field_type = NULL; + struct bt_ctf_field_type *ep_enum_field_type = NULL; + struct bt_ctf_field_type *ep_enum_field_unsigned_type = NULL; + int ret; ok(uint_12_type, "Create an unsigned integer type"); @@ -565,7 +493,34 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, "bt_ctf_event_class_get_context_type returns the appropriate type"); bt_put(returned_type); - bt_ctf_stream_class_add_event_class(stream_class, simple_event_class); + ok(!bt_ctf_stream_class_add_event_class(stream_class, simple_event_class), + "Adding simple event class to stream class"); + + /* + * bt_ctf_stream_class_add_event_class() copies the field types + * 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); + event_payload_type = bt_ctf_event_class_get_payload_type( + simple_event_class); + assert(event_payload_type); + event_context_type = bt_ctf_event_class_get_context_type( + simple_event_class); + assert(event_context_type); + ep_integer_field_type = + bt_ctf_field_type_structure_get_field_type_by_name( + event_payload_type, "integer_field"); + assert(ep_integer_field_type); + ep_enum_field_type = + bt_ctf_field_type_structure_get_field_type_by_name( + event_payload_type, "enum_field"); + assert(ep_enum_field_type); + ep_enum_field_unsigned_type = + bt_ctf_field_type_structure_get_field_type_by_name( + event_payload_type, "enum_field_unsigned"); + assert(ep_enum_field_unsigned_type); ok(bt_ctf_stream_class_get_event_class_count(NULL) < 0, "bt_ctf_stream_class_get_event_class_count handles NULL correctly"); @@ -611,7 +566,7 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, "bt_ctf_event_get_clock returns a correct clock"); bt_put(clock); - integer_field = bt_ctf_field_create(uint_12_type); + integer_field = bt_ctf_field_create(ep_integer_field_type); bt_ctf_field_unsigned_integer_set_value(integer_field, 42); ok(bt_ctf_event_set_payload(simple_event, "integer_field", integer_field) == 0, "Use bt_ctf_event_set_payload to set a manually allocated field"); @@ -629,7 +584,8 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, ok(fabs(ret_double - double_test_value) <= DBL_EPSILON, "bt_ctf_field_floating_point_get_value returns a correct value"); - enum_field = bt_ctf_field_create(enum_type); + enum_field = bt_ctf_field_create(ep_enum_field_type); + assert(enum_field); ret_char = bt_ctf_field_enumeration_get_mapping_name(NULL); ok(!ret_char, "bt_ctf_field_enumeration_get_mapping_name handles NULL correctly"); ret_char = bt_ctf_field_enumeration_get_mapping_name(enum_field); @@ -642,16 +598,19 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, ret_char = bt_ctf_field_enumeration_get_mapping_name(enum_field); ok(!strcmp(ret_char, mapping_name_negative_test), "bt_ctf_field_enumeration_get_mapping_name returns the correct mapping name with an signed container"); - bt_ctf_event_set_payload(simple_event, "enum_field", enum_field); + ret = bt_ctf_event_set_payload(simple_event, "enum_field", enum_field); + assert(!ret); - enum_field_unsigned = bt_ctf_field_create(enum_type_unsigned); + enum_field_unsigned = bt_ctf_field_create(ep_enum_field_unsigned_type); + assert(enum_field_unsigned); enum_container_field_unsigned = bt_ctf_field_enumeration_get_container( enum_field_unsigned); ok(bt_ctf_field_unsigned_integer_set_value( enum_container_field_unsigned, 42) == 0, "Set unsigned enumeration container value"); - bt_ctf_event_set_payload(simple_event, "enum_field_unsigned", + ret = bt_ctf_event_set_payload(simple_event, "enum_field_unsigned", enum_field_unsigned); + assert(!ret); ret_char = bt_ctf_field_enumeration_get_mapping_name(enum_field_unsigned); ok(ret_char && !strcmp(ret_char, mapping_name_test), "bt_ctf_field_enumeration_get_mapping_name returns the correct mapping name with an unsigned container"); @@ -659,7 +618,9 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, ok(bt_ctf_clock_set_time(clock, current_time) == 0, "Set clock time"); /* Populate stream event context */ - stream_event_context = bt_ctf_stream_get_event_context(stream); + stream_event_context = + bt_ctf_event_get_stream_event_context(simple_event); + assert(stream_event_context); stream_event_context_field = bt_ctf_field_structure_get_field( stream_event_context, "common_event_context"); bt_ctf_field_unsigned_integer_set_value(stream_event_context_field, 42); @@ -686,7 +647,6 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, ok(!bt_ctf_event_set_event_context(simple_event, event_context), "Set an event context successfully"); - event_copy_tests(simple_event); ok(bt_ctf_stream_append_event(stream, simple_event) == 0, "Append simple event to trace stream"); @@ -737,8 +697,13 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, 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); } +static void append_complex_event(struct bt_ctf_stream_class *stream_class, struct bt_ctf_stream *stream, struct bt_ctf_clock *clock) { @@ -785,7 +750,8 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, struct bt_ctf_field *uint_35_field, *int_16_field, *a_string_field, *inner_structure_field, *complex_structure_field, *a_sequence_field, *enum_variant_field, *enum_container_field, - *variant_field, *an_array_field, *ret_field; + *variant_field, *an_array_field, *stream_event_ctx_field, + *stream_event_ctx_int_field, *ret_field; uint64_t ret_unsigned_int; int64_t ret_signed_int; const char *ret_string; @@ -802,10 +768,13 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, "bt_ctf_field_type_set_alignment handles wrong alignment correctly (24)"); ok(!bt_ctf_field_type_set_alignment(int_16_type, 4), "bt_ctf_field_type_set_alignment handles correct alignment correctly (4)"); - bt_ctf_field_type_set_alignment(int_16_type, 32); - bt_ctf_field_type_integer_set_signed(int_16_type, 1); - bt_ctf_field_type_integer_set_base(uint_35_type, - BT_CTF_INTEGER_BASE_HEXADECIMAL); + ok(!bt_ctf_field_type_set_alignment(int_16_type, 32), + "Set alignment of signed 16 bit integer to 32"); + ok(!bt_ctf_field_type_integer_set_signed(int_16_type, 1), + "Set integer signedness to true"); + ok(!bt_ctf_field_type_integer_set_base(uint_35_type, + BT_CTF_INTEGER_BASE_HEXADECIMAL), + "Set signed 16 bit integer base to hexadecimal"); array_type = bt_ctf_field_type_array_create(int_16_type, ARRAY_TEST_LENGTH); sequence_type = bt_ctf_field_type_sequence_create(int_16_type, @@ -1099,7 +1068,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, ok(bt_ctf_event_class_get_field(event_class, &ret_string, &ret_field_type, 0) == 0, "bt_ctf_event_class_get_field returns a field"); - ok(ret_field_type == uint_35_type, + ok(bt_ctf_field_type_compare(ret_field_type, uint_35_type) == 0, "bt_ctf_event_class_get_field returns a correct field type"); bt_put(ret_field_type); ok(!strcmp(ret_string, "uint_35"), @@ -1112,7 +1081,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, "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"); - ok(ret_field_type == complex_structure_type, + ok(bt_ctf_field_type_compare(ret_field_type, complex_structure_type) == 0, "bt_ctf_event_class_get_field_by_name returns a correct field type"); bt_put(ret_field_type); @@ -1174,7 +1143,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, complex_structure_field, 3); ret_field_type = bt_ctf_field_get_type(inner_structure_field); bt_put(inner_structure_field); - ok(ret_field_type == inner_structure_type, + ok(bt_ctf_field_type_compare(ret_field_type, inner_structure_type) == 0, "bt_ctf_field_structure_get_field_by_index returns a correct field"); bt_put(ret_field_type); @@ -1267,6 +1236,14 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, bt_put(int_16_field); } + stream_event_ctx_field = bt_ctf_event_get_stream_event_context(event); + assert(stream_event_ctx_field); + stream_event_ctx_int_field = bt_ctf_field_structure_get_field( + stream_event_ctx_field, "common_event_context"); + BT_PUT(stream_event_ctx_field); + bt_ctf_field_unsigned_integer_set_value(stream_event_ctx_int_field, 17); + BT_PUT(stream_event_ctx_int_field); + bt_ctf_clock_set_time(clock, ++current_time); ok(bt_ctf_stream_append_event(stream, event) == 0, "Append a complex event to a stream"); @@ -1310,8 +1287,9 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, bt_put(event); } -static void field_copy_tests_validate_same_type(struct bt_ctf_field *field, - struct bt_ctf_field_type *expected_type, const char *name) +static +void field_copy_tests_validate_same_type(struct bt_ctf_field *field, + struct bt_ctf_field_type *expected_type, const char *name) { struct bt_ctf_field_type *copy_type; @@ -1321,13 +1299,15 @@ static void field_copy_tests_validate_same_type(struct bt_ctf_field *field, bt_put(copy_type); } -static void field_copy_tests_validate_diff_ptrs(struct bt_ctf_field *field_a, - struct bt_ctf_field *field_b, const char *name) +static +void field_copy_tests_validate_diff_ptrs(struct bt_ctf_field *field_a, + struct bt_ctf_field *field_b, const char *name) { ok(field_a != field_b, "bt_ctf_field_copy creates different pointers (%s)", name); } +static void field_copy_tests() { struct bt_ctf_field_type *len_type = NULL; @@ -1837,6 +1817,7 @@ void field_copy_tests() bt_put(strct_copy); } +static void type_field_tests() { struct bt_ctf_field *uint_12; @@ -1852,8 +1833,6 @@ void type_field_tests() struct bt_ctf_field_type *uint_12_type = bt_ctf_field_type_integer_create(12); struct bt_ctf_field_type *enumeration_type; - struct bt_ctf_field_type *enumeration_sequence_type; - struct bt_ctf_field_type *enumeration_array_type; struct bt_ctf_field_type *returned_type; const char *ret_string; @@ -1911,10 +1890,10 @@ void type_field_tests() "bt_ctf_field_type_get_byte_order handles NULL correctly"); ok(bt_ctf_field_type_get_type_id(NULL) == - CTF_TYPE_UNKNOWN, + BT_CTF_TYPE_ID_UNKNOWN, "bt_ctf_field_type_get_type_id handles NULL correctly"); ok(bt_ctf_field_type_get_type_id(uint_12_type) == - CTF_TYPE_INTEGER, + BT_CTF_TYPE_ID_INTEGER, "bt_ctf_field_type_get_type_id returns a correct value with an integer type"); ok(bt_ctf_field_type_integer_get_base(NULL) == @@ -1924,17 +1903,20 @@ void type_field_tests() BT_CTF_INTEGER_BASE_HEXADECIMAL, "bt_ctf_field_type_integer_get_base returns a correct value"); - ok(bt_ctf_field_type_integer_set_encoding(NULL, CTF_STRING_ASCII) < 0, + ok(bt_ctf_field_type_integer_set_encoding(NULL, + BT_CTF_STRING_ENCODING_ASCII) < 0, "bt_ctf_field_type_integer_set_encoding handles NULL correctly"); ok(bt_ctf_field_type_integer_set_encoding(uint_12_type, - (enum ctf_string_encoding) 123) < 0, + (enum bt_ctf_string_encoding) 123) < 0, "bt_ctf_field_type_integer_set_encoding handles invalid encodings correctly"); ok(bt_ctf_field_type_integer_set_encoding(uint_12_type, - CTF_STRING_UTF8) == 0, + BT_CTF_STRING_ENCODING_UTF8) == 0, "Set integer type encoding to UTF8"); - ok(bt_ctf_field_type_integer_get_encoding(NULL) == CTF_STRING_UNKNOWN, + ok(bt_ctf_field_type_integer_get_encoding(NULL) == + BT_CTF_STRING_ENCODING_UNKNOWN, "bt_ctf_field_type_integer_get_encoding handles NULL correctly"); - ok(bt_ctf_field_type_integer_get_encoding(uint_12_type) == CTF_STRING_UTF8, + ok(bt_ctf_field_type_integer_get_encoding(uint_12_type) == + BT_CTF_STRING_ENCODING_UTF8, "bt_ctf_field_type_integer_get_encoding returns a correct value"); int_16_type = bt_ctf_field_type_integer_create(16); @@ -1946,7 +1928,7 @@ void type_field_tests() bt_ctf_field_type_sequence_create(int_16_type, "seq_len"); ok(sequence_type, "Create a sequence of int16_t type"); ok(bt_ctf_field_type_get_type_id(sequence_type) == - CTF_TYPE_SEQUENCE, + BT_CTF_TYPE_ID_SEQUENCE, "bt_ctf_field_type_get_type_id returns a correct value with a sequence type"); ok(bt_ctf_field_type_sequence_get_length_field_name(NULL) == NULL, @@ -1966,25 +1948,25 @@ void type_field_tests() string_type = bt_ctf_field_type_string_create(); ok(string_type, "Create a string type"); ok(bt_ctf_field_type_string_set_encoding(string_type, - CTF_STRING_NONE), + BT_CTF_STRING_ENCODING_NONE), "Reject invalid \"None\" string encoding"); ok(bt_ctf_field_type_string_set_encoding(string_type, 42), "Reject invalid string encoding"); ok(bt_ctf_field_type_string_set_encoding(string_type, - CTF_STRING_ASCII) == 0, + BT_CTF_STRING_ENCODING_ASCII) == 0, "Set string encoding to ASCII"); ok(bt_ctf_field_type_string_get_encoding(NULL) == - CTF_STRING_UNKNOWN, + BT_CTF_STRING_ENCODING_UNKNOWN, "bt_ctf_field_type_string_get_encoding handles NULL correctly"); ok(bt_ctf_field_type_string_get_encoding(string_type) == - CTF_STRING_ASCII, + BT_CTF_STRING_ENCODING_ASCII, "bt_ctf_field_type_string_get_encoding returns the correct value"); structure_seq_type = bt_ctf_field_type_structure_create(); ok(bt_ctf_field_type_get_type_id(structure_seq_type) == - CTF_TYPE_STRUCT, + BT_CTF_TYPE_ID_STRUCT, "bt_ctf_field_type_get_type_id returns a correct value with a structure type"); ok(structure_seq_type, "Create a structure type"); ok(bt_ctf_field_type_structure_add_field(structure_seq_type, @@ -2099,17 +2081,6 @@ void type_field_tests() enumeration_type = bt_ctf_field_type_enumeration_create(uint_12_type); ok(enumeration_type, "Create an enumeration type with an unsigned 12-bit integer as container"); - enumeration_sequence_type = bt_ctf_field_type_sequence_create( - enumeration_type, "count"); - ok(!enumeration_sequence_type, - "Check enumeration types are validated when creating a sequence"); - enumeration_array_type = bt_ctf_field_type_array_create( - enumeration_type, 10); - ok(!enumeration_array_type, - "Check enumeration types are validated when creating an array"); - ok(bt_ctf_field_type_structure_add_field(composite_structure_type, - enumeration_type, "enumeration"), - "Check enumeration types are validated when adding them as structure members"); enumeration = bt_ctf_field_create(enumeration_type); ok(!enumeration, "Check enumeration types are validated before instantiation"); @@ -2126,11 +2097,10 @@ void type_field_tests() 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); } +static void packet_resize_test(struct bt_ctf_stream_class *stream_class, struct bt_ctf_stream *stream, struct bt_ctf_clock *clock) { @@ -2153,7 +2123,10 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class, uint64_t ret_uint64; int events_appended = 0; struct bt_ctf_field *packet_context = NULL, - *packet_context_field = NULL, *event_context = NULL; + *packet_context_field = NULL, *stream_event_context = NULL; + struct bt_ctf_field_type *ep_field_1_type = NULL; + struct bt_ctf_field_type *ep_a_string_type = NULL; + struct bt_ctf_field_type *ep_type = NULL; ret |= bt_ctf_event_class_add_field(event_class, integer_type, "field_1"); @@ -2165,10 +2138,24 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class, goto end; } + /* + * bt_ctf_stream_class_add_event_class() copies the field types + * of event_class, so we retrieve the new ones to create the + * appropriate fields. + */ + ep_type = bt_ctf_event_class_get_payload_type(event_class); + assert(ep_type); + ep_field_1_type = bt_ctf_field_type_structure_get_field_type_by_name( + ep_type, "field_1"); + assert(ep_field_1_type); + ep_a_string_type = bt_ctf_field_type_structure_get_field_type_by_name( + ep_type, "a_string"); + assert(ep_a_string_type); + event = bt_ctf_event_create(event_class); ret_field = bt_ctf_event_get_payload_by_index(event, 0); ret_field_type = bt_ctf_field_get_type(ret_field); - ok(ret_field_type == integer_type, + ok(bt_ctf_field_type_compare(ret_field_type, integer_type) == 0, "bt_ctf_event_get_payload_by_index returns a correct field"); bt_put(ret_field_type); bt_put(ret_field); @@ -2179,28 +2166,12 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class, "bt_ctf_event_get_payload_by_index handles an invalid index correctly"); bt_put(event); - ok(bt_ctf_stream_get_event_context(NULL) == NULL, - "bt_ctf_stream_get_event_context handles NULL correctly"); - event_context = bt_ctf_stream_get_event_context(stream); - ok(event_context, - "bt_ctf_stream_get_event_context returns a stream event context"); - ok(bt_ctf_stream_set_event_context(NULL, event_context) < 0, - "bt_ctf_stream_set_event_context handles a NULL stream correctly"); - ok(bt_ctf_stream_set_event_context(stream, NULL) < 0, - "bt_ctf_stream_set_event_context handles a NULL stream event context correctly"); - ok(!bt_ctf_stream_set_event_context(stream, event_context), - "bt_ctf_stream_set_event_context correctly set a stream event context"); - 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_put(ret_field); - for (i = 0; i < PACKET_RESIZE_TEST_LENGTH; i++) { event = bt_ctf_event_create(event_class); struct bt_ctf_field *integer = - bt_ctf_field_create(integer_type); + bt_ctf_field_create(ep_field_1_type); struct bt_ctf_field *string = - bt_ctf_field_create(string_type); + bt_ctf_field_create(ep_a_string_type); ret |= bt_ctf_clock_set_time(clock, ++current_time); ret |= bt_ctf_field_unsigned_integer_set_value(integer, i); @@ -2213,8 +2184,11 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class, bt_put(string); /* Populate stream event context */ - integer = bt_ctf_field_structure_get_field(event_context, + stream_event_context = + bt_ctf_event_get_stream_event_context(event); + integer = bt_ctf_field_structure_get_field(stream_event_context, "common_event_context"); + BT_PUT(stream_event_context); ret |= bt_ctf_field_unsigned_integer_set_value(integer, i % 42); bt_put(integer); @@ -2261,10 +2235,14 @@ end: bt_put(string_type); bt_put(packet_context); bt_put(packet_context_field); - bt_put(event_context); + 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); } +static void test_empty_stream(struct bt_ctf_writer *writer) { int ret = 0; @@ -2310,6 +2288,7 @@ end: bt_put(stream_class); } +static void test_custom_event_header_stream(struct bt_ctf_writer *writer) { int i, ret; @@ -2515,6 +2494,7 @@ end: bt_put(event_header_type); } +static void test_instanciate_event_before_stream(struct bt_ctf_writer *writer) { int ret = 0; @@ -2631,6 +2611,7 @@ end: bt_put(clock); } +static void append_existing_event_class(struct bt_ctf_stream_class *stream_class) { struct bt_ctf_event_class *event_class; @@ -2649,6 +2630,293 @@ void append_existing_event_class(struct bt_ctf_stream_class *stream_class) bt_put(event_class); } +static +void test_trace_stream_class_clock(void) +{ + struct bt_ctf_trace *trace = NULL; + struct bt_ctf_stream_class *sc1 = NULL; + struct bt_ctf_stream_class *sc2 = NULL; + struct bt_ctf_clock *sc1_clock = NULL; + struct bt_ctf_clock *sc2_clock = NULL; + const char *clock_name = "hello"; + + trace = bt_ctf_trace_create(); + assert(trace); + sc1 = bt_ctf_stream_class_create(NULL); + assert(sc1); + sc2 = bt_ctf_stream_class_create(NULL); + assert(sc2); + sc1_clock = bt_ctf_clock_create(clock_name); + assert(sc1_clock); + sc2_clock = bt_ctf_clock_create(clock_name); + assert(sc2_clock); + + ok(!bt_ctf_stream_class_set_clock(sc1, sc1_clock), + "bt_ctf_stream_class_set_clock() succeeds for sc1"); + ok(!bt_ctf_stream_class_set_clock(sc2, sc2_clock), + "bt_ctf_stream_class_set_clock() succeeds for sc2"); + ok(!bt_ctf_trace_add_stream_class(trace, sc1), + "bt_ctf_trace_add_stream_class() succeeds with sc1"); + ok(bt_ctf_trace_add_stream_class(trace, sc2), + "bt_ctf_trace_add_stream_class() fails with sc2 (different clock, same name)"); + + BT_PUT(trace); + BT_PUT(sc1); + BT_PUT(sc2); + BT_PUT(sc1_clock); + BT_PUT(sc2_clock); +} + +static +struct bt_ctf_event_class *create_minimal_event_class(void) +{ + struct bt_ctf_event_class *ec = NULL; + struct bt_ctf_field_type *int_ft = NULL; + int ret; + + int_ft = bt_ctf_field_type_integer_create(23); + assert(int_ft); + ec = bt_ctf_event_class_create("minimal"); + assert(ec); + ret = bt_ctf_event_class_add_field(ec, int_ft, "field"); + assert(!ret); + BT_PUT(int_ft); + + return ec; +} + +static +void test_create_writer_vs_non_writer_mode(void) +{ + int ret; + char trace_path[] = "/tmp/ctfwriter_XXXXXX"; + const char *writer_stream_name = "writer stream instance"; + struct bt_ctf_writer *writer = NULL; + struct bt_ctf_trace *writer_trace = NULL; + struct bt_ctf_stream_class *writer_sc = NULL; + struct bt_ctf_stream *writer_stream = NULL; + struct bt_ctf_stream *writer_stream2 = NULL; + struct bt_ctf_stream *packet_stream = NULL; + struct bt_ctf_trace *non_writer_trace = NULL; + struct bt_ctf_stream_class *non_writer_sc = NULL; + struct bt_ctf_stream *non_writer_stream = NULL; + struct bt_ctf_stream *non_writer_stream2 = NULL; + struct bt_ctf_event_class *writer_ec = NULL; + struct bt_ctf_event_class *non_writer_ec = NULL; + struct bt_ctf_event *event = NULL; + struct bt_ctf_event *event2 = NULL; + struct bt_ctf_field_type *empty_struct_ft = NULL; + struct bt_ctf_field *int_field = NULL; + struct bt_ctf_clock *writer_clock = NULL; + struct bt_ctf_clock *non_writer_clock = NULL; + struct bt_ctf_packet *packet = NULL; + struct bt_ctf_packet *packet2 = NULL; + + if (!bt_mkdtemp(trace_path)) { + perror("# perror"); + } + + /* Create empty structure field type (event header) */ + empty_struct_ft = bt_ctf_field_type_structure_create(); + assert(empty_struct_ft); + + /* Create writer, writer stream class, stream, and clock */ + writer = bt_ctf_writer_create(trace_path); + assert(writer); + writer_trace = bt_ctf_writer_get_trace(writer); + ok(writer_trace, "bt_ctf_writer_get_trace() returns a trace"); + writer_sc = bt_ctf_stream_class_create("writer_sc"); + assert(writer_sc); + ret = bt_ctf_stream_class_set_event_header_type(writer_sc, + empty_struct_ft); + assert(!ret); + ret = bt_ctf_trace_add_stream_class(writer_trace, writer_sc); + assert(!ret); + writer_stream = bt_ctf_stream_create(writer_sc, writer_stream_name); + assert(writer_stream); + ok(!strcmp(bt_ctf_stream_get_name(writer_stream), writer_stream_name), + "bt_ctf_stream_get_name() returns the stream's name"); + writer_clock = bt_ctf_clock_create("writer_clock"); + assert(writer_clock); + ret = bt_ctf_trace_add_clock(writer_trace, writer_clock); + assert(!ret); + + /* Create non-writer trace, stream class, stream, and clock */ + non_writer_trace = bt_ctf_trace_create(); + assert(non_writer_trace); + non_writer_sc = bt_ctf_stream_class_create("nonwriter_sc"); + assert(non_writer_sc); + ret = bt_ctf_stream_class_set_event_header_type(non_writer_sc, + empty_struct_ft); + assert(!ret); + ret = bt_ctf_trace_add_stream_class(non_writer_trace, non_writer_sc); + assert(!ret); + non_writer_stream = bt_ctf_stream_create(non_writer_sc, NULL); + assert(non_writer_stream); + non_writer_clock = bt_ctf_clock_create("non_writer_clock"); + assert(non_writer_clock); + ret = bt_ctf_trace_add_clock(non_writer_trace, non_writer_clock); + assert(!ret); + + /* Create event class and event */ + writer_ec = create_minimal_event_class(); + assert(writer_ec); + ret = bt_ctf_stream_class_add_event_class(writer_sc, writer_ec); + assert(!ret); + event = bt_ctf_event_create(writer_ec); + assert(event); + int_field = bt_ctf_event_get_payload_by_index(event, 0); + assert(int_field); + bt_ctf_field_unsigned_integer_set_value(int_field, 17); + + /* + * Verify non-writer stream: it should be impossible to append + * an event to it. + */ + ok(bt_ctf_stream_append_event(non_writer_stream, event), + "bt_ctf_stream_append_event() fails with a non-writer stream"); + + /* + * Verify writer stream: it should be possible to append an + * event to it. + */ + ok(!bt_ctf_stream_append_event(writer_stream, event), + "bt_ctf_stream_append_event() succeeds with a writer stream"); + + /* + * Verify that it's possible to get and set the value of a + * writer mode clock. + */ + ok (!bt_ctf_clock_set_value(writer_clock, 1000), + "bt_ctf_clock_set_value() succeeds with a writer mode clock"); + ok (bt_ctf_clock_get_value(writer_clock) == 1000, + "bt_ctf_clock_get_value() succeeds with a writer mode clock"); + + /* + * Verify that it's impossible to get and set the value of a + * non-writer mode clock. + */ + ok (bt_ctf_clock_set_value(non_writer_clock, 1000), + "bt_ctf_clock_set_value() fails with a non-writer mode clock"); + ok (bt_ctf_clock_get_value(non_writer_clock) == -1ULL, + "bt_ctf_clock_get_value() fails with a non-writer mode clock"); + + /* + * It should be possible to create a packet from a non-writer + * stream, but not from a writer stream. + */ + packet = bt_ctf_packet_create(writer_stream); + ok(!packet, "bt_ctf_packet_create() fails with a writer stream"); + packet = bt_ctf_packet_create(non_writer_stream); + ok(packet, "bt_ctf_packet_create() succeeds with a non-writer stream"); + packet_stream = bt_ctf_packet_get_stream(packet); + ok(packet_stream == non_writer_stream, + "bt_ctf_packet_get_stream() returns the correct stream"); + + /* + * It should not be possible to append an event associated to + * a stream to a different stream. + */ + writer_stream2 = bt_ctf_stream_create(writer_sc, "zoo"); + assert(writer_stream2); + ok(bt_ctf_stream_append_event(writer_stream2, event), + "bt_ctf_stream_append_event() fails with an event associated to another stream"); + + /* + * It should not be possible to set the packet of an event + * associated to a given stream to a packet associated with + * a different stream. + */ + ok(bt_ctf_event_set_packet(event, packet), + "bt_ctf_event_set_packet() fails with a packet not sharing the event's stream"); + + /* + * It should be possible to set the packet of a fresh event, as + * long as the originating stream classes are the same. + */ + event2 = bt_ctf_event_create(writer_ec); + assert(event2); + ok(bt_ctf_event_set_packet(event2, packet), + "bt_ctf_event_set_packet() fails when the event's and the packet's stream class differ"); + non_writer_ec = create_minimal_event_class(); + assert(non_writer_ec); + ret = bt_ctf_stream_class_add_event_class(non_writer_sc, non_writer_ec); + assert(!ret); + BT_PUT(event2); + event2 = bt_ctf_event_create(non_writer_ec); + assert(event2); + ok(!bt_ctf_event_set_packet(event2, packet), + "bt_ctf_event_set_packet() succeeds when the event's and the packet's stream class are the same"); + + /* + * It should be possible to set a packet created from the same + * stream to an event with an existing packet. + */ + packet2 = bt_ctf_packet_create(non_writer_stream); + assert(packet2); + ok(!bt_ctf_event_set_packet(event2, packet2), + "bt_ctf_event_set_packet() succeeds when the event's current packet has the same stream"); + BT_PUT(packet2); + + /* + * It should not be possible to set a packet created from a + * different stream to an event with an existing packet. + */ + non_writer_stream2 = bt_ctf_stream_create(non_writer_sc, "rj45"); + assert(non_writer_stream2); + packet2 = bt_ctf_packet_create(non_writer_stream); + assert(packet2); + ok(!bt_ctf_event_set_packet(event2, packet2), + "bt_ctf_event_set_packet() fails when the event's current packet does not have the same stream"); + + bt_put(writer); + bt_put(writer_trace); + bt_put(writer_sc); + bt_put(writer_stream); + bt_put(writer_stream2); + bt_put(non_writer_trace); + bt_put(non_writer_sc); + bt_put(non_writer_stream); + bt_put(non_writer_stream2); + bt_put(packet_stream); + bt_put(writer_ec); + bt_put(non_writer_ec); + bt_put(event); + bt_put(event2); + bt_put(int_field); + bt_put(empty_struct_ft); + bt_put(writer_clock); + bt_put(non_writer_clock); + bt_put(packet); + bt_put(packet2); + recursive_rmdir(trace_path); +} + +static +void test_clock_utils(void) +{ + int ret; + struct bt_ctf_clock *clock = NULL; + + clock = bt_ctf_clock_create("water"); + assert(clock); + ret = bt_ctf_clock_set_offset_s(clock, 1234); + assert(!ret); + ret = bt_ctf_clock_set_offset(clock, 1000); + assert(!ret); + ret = bt_ctf_clock_set_frequency(clock, 1000000000); + assert(!ret); + ok(bt_ctf_clock_ns_from_value(clock, 4321) == 1234000005321ULL, + "bt_ctf_clock_ns_from_value() returns the correct value with a 1 GHz frequency"); + ret = bt_ctf_clock_set_frequency(clock, 1534); + assert(!ret); + ok(bt_ctf_clock_ns_from_value(clock, 4321) == + (uint64_t) 1237468709256.845, + "bt_ctf_clock_ns_from_value() returns the correct value with a non-1 GHz frequency"); + + BT_PUT(clock); +} + int main(int argc, char **argv) { char trace_path[] = "/tmp/ctfwriter_XXXXXX"; @@ -2658,8 +2926,11 @@ int main(int argc, char **argv) const char *returned_clock_name; const char *returned_clock_description; const uint64_t frequency = 1123456789; - const uint64_t offset_s = 1351530929945824323; - const uint64_t offset = 1234567; + const int64_t offset_s = 1351530929945824323; + const int64_t offset = 1234567; + int64_t get_offset_s, + get_offset, + get_time; const uint64_t precision = 10; const int is_absolute = 0xFF; char *metadata_string; @@ -2901,18 +3172,26 @@ int main(int argc, char **argv) ok(bt_ctf_clock_get_frequency(clock) == frequency, "bt_ctf_clock_get_frequency returns the correct frequency once it is set"); - ok(bt_ctf_clock_get_offset_s(clock) == DEFAULT_CLOCK_OFFSET_S, + ok(bt_ctf_clock_get_offset_s(clock, &get_offset_s) == 0, + "bt_ctf_clock_get_offset_s succeeds"); + ok(get_offset_s == DEFAULT_CLOCK_OFFSET_S, "bt_ctf_clock_get_offset_s returns the correct default offset (in seconds)"); ok(bt_ctf_clock_set_offset_s(clock, offset_s) == 0, "Set clock offset (seconds)"); - ok(bt_ctf_clock_get_offset_s(clock) == offset_s, + ok(bt_ctf_clock_get_offset_s(clock, &get_offset_s) == 0, + "bt_ctf_clock_get_offset_s succeeds"); + ok(get_offset_s == offset_s, "bt_ctf_clock_get_offset_s returns the correct default offset (in seconds) once it is set"); - ok(bt_ctf_clock_get_offset(clock) == DEFAULT_CLOCK_OFFSET, - "bt_ctf_clock_get_frequency returns the correct default offset (in ticks)"); + ok(bt_ctf_clock_get_offset(clock, &get_offset) == 0, + "bt_ctf_clock_get_offset succeeds"); + ok(get_offset == DEFAULT_CLOCK_OFFSET, + "bt_ctf_clock_get_offset returns the correct default offset (in ticks)"); ok(bt_ctf_clock_set_offset(clock, offset) == 0, "Set clock offset"); - ok(bt_ctf_clock_get_offset(clock) == offset, - "bt_ctf_clock_get_frequency returns the correct default offset (in ticks) once it is set"); + ok(bt_ctf_clock_get_offset(clock, &get_offset) == 0, + "bt_ctf_clock_get_offset succeeds"); + ok(get_offset == offset, + "bt_ctf_clock_get_offset returns the correct default offset (in ticks) once it is set"); ok(bt_ctf_clock_get_precision(clock) == DEFAULT_CLOCK_PRECISION, "bt_ctf_clock_get_precision returns the correct default precision"); @@ -2928,45 +3207,23 @@ int main(int argc, char **argv) ok(bt_ctf_clock_get_is_absolute(clock) == !!is_absolute, "bt_ctf_clock_get_precision returns the correct is_absolute attribute once it is set"); - ok(bt_ctf_clock_get_time(clock) == DEFAULT_CLOCK_TIME, + ok(bt_ctf_clock_get_time(clock, &get_time) == 0, + "bt_ctf_clock_get_time succeeds"); + ok(get_time == DEFAULT_CLOCK_TIME, "bt_ctf_clock_get_time returns the correct default time"); + ok(bt_ctf_clock_get_value(clock) == DEFAULT_CLOCK_VALUE, + "bt_ctf_clock_get_value returns the correct default value"); + ok(bt_ctf_clock_set_value(clock, current_time) == 0, + "Set clock value"); + ok(bt_ctf_clock_get_value(clock) == current_time, + "bt_ctf_clock_get_value returns the correct value once it is set"); ok(bt_ctf_clock_set_time(clock, current_time) == 0, "Set clock time"); - ok(bt_ctf_clock_get_time(clock) == current_time, + ok(bt_ctf_clock_get_time(clock, &get_time) == 0, + "bt_ctf_clock_get_time succeeds"); + ok(get_time >= current_time - 1 && get_time <= current_time + 1, "bt_ctf_clock_get_time returns the correct time once it is set"); - ok(bt_ctf_writer_add_clock(writer, clock) == 0, - "Add clock to writer instance"); - ok(bt_ctf_writer_add_clock(writer, clock), - "Verify a clock can't be added twice to a writer instance"); - - ok(bt_ctf_trace_get_clock_count(NULL) < 0, - "bt_ctf_trace_get_clock_count correctly handles NULL"); - ok(bt_ctf_trace_get_clock_count(trace) == 1, - "bt_ctf_trace_get_clock_count returns the correct number of clocks"); - ok(!bt_ctf_trace_get_clock(NULL, 0), - "bt_ctf_trace_get_clock correctly handles NULL"); - ok(!bt_ctf_trace_get_clock(trace, -1), - "bt_ctf_trace_get_clock correctly handles negative indexes"); - ok(!bt_ctf_trace_get_clock(trace, 1), - "bt_ctf_trace_get_clock correctly handles out of bound accesses"); - ret_clock = bt_ctf_trace_get_clock(trace, 0); - ok(ret_clock == clock, - "bt_ctf_trace_get_clock returns the right clock instance"); - 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), - "bt_ctf_trace_get_clock_by_name correctly handles NULL (clock name)"); - ok(!bt_ctf_trace_get_clock_by_name(NULL, NULL), - "bt_ctf_trace_get_clock_by_name correctly handles NULL (both)"); - 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_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"); - ok(!bt_ctf_clock_get_name(NULL), "bt_ctf_clock_get_name correctly handles NULL"); ok(!bt_ctf_clock_get_description(NULL), @@ -2975,14 +3232,20 @@ int main(int argc, char **argv) "bt_ctf_clock_get_frequency correctly handles NULL"); ok(bt_ctf_clock_get_precision(NULL) == -1ULL, "bt_ctf_clock_get_precision correctly handles NULL"); - ok(bt_ctf_clock_get_offset_s(NULL) == -1ULL, - "bt_ctf_clock_get_offset_s correctly handles NULL"); - ok(bt_ctf_clock_get_offset(NULL) == -1ULL, - "bt_ctf_clock_get_offset correctly handles NULL"); + ok(bt_ctf_clock_get_offset_s(NULL, &get_offset_s) < 0, + "bt_ctf_clock_get_offset_s correctly handles NULL clock"); + ok(bt_ctf_clock_get_offset_s(clock, NULL) < 0, + "bt_ctf_clock_get_offset_s correctly handles NULL output"); + ok(bt_ctf_clock_get_offset(NULL, &get_offset) < 0, + "bt_ctf_clock_get_offset correctly handles NULL clock"); + ok(bt_ctf_clock_get_offset(clock, NULL) < 0, + "bt_ctf_clock_get_offset correctly handles NULL output"); ok(bt_ctf_clock_get_is_absolute(NULL) < 0, "bt_ctf_clock_get_is_absolute correctly handles NULL"); - ok(bt_ctf_clock_get_time(NULL) == -1ULL, - "bt_ctf_clock_get_time correctly handles NULL"); + ok(bt_ctf_clock_get_time(NULL, &get_time) < 0, + "bt_ctf_clock_get_time correctly handles NULL clock"); + ok(bt_ctf_clock_get_time(clock, NULL) < 0, + "bt_ctf_clock_get_time correctly handles NULL output"); ok(bt_ctf_clock_set_description(NULL, NULL) < 0, "bt_ctf_clock_set_description correctly handles NULL clock"); @@ -3014,7 +3277,7 @@ int main(int argc, char **argv) ok(bt_ctf_clock_set_uuid(clock, NULL) < 0, "bt_ctf_clock_set_uuid correctly handles a NULL UUID"); ok(bt_ctf_clock_set_uuid(clock, tmp_uuid) == 0, - "bt_ctf_clock_set_uuid sets a new uuid succesfully"); + "bt_ctf_clock_set_uuid sets a new uuid successfully"); ret_uuid = bt_ctf_clock_get_uuid(clock); ok(ret_uuid, "bt_ctf_clock_get_uuid returns a UUID after setting a new one"); @@ -3067,7 +3330,7 @@ int main(int argc, char **argv) stream_class); ok(ret_field_type, "bt_ctf_stream_class_get_event_header_type returns an event header type"); - ok(bt_ctf_field_type_get_type_id(ret_field_type) == CTF_TYPE_STRUCT, + ok(bt_ctf_field_type_get_type_id(ret_field_type) == BT_CTF_TYPE_ID_STRUCT, "Default event header type is a structure"); event_header_field_type = bt_ctf_field_type_structure_get_field_type_by_name( @@ -3075,7 +3338,7 @@ int main(int argc, char **argv) ok(event_header_field_type, "Default event header type contains an \"id\" field"); ok(bt_ctf_field_type_get_type_id( - event_header_field_type) == CTF_TYPE_INTEGER, + event_header_field_type) == BT_CTF_TYPE_ID_INTEGER, "Default event header \"id\" field is an integer"); bt_put(event_header_field_type); event_header_field_type = @@ -3084,7 +3347,7 @@ int main(int argc, char **argv) ok(event_header_field_type, "Default event header type contains a \"timestamp\" field"); ok(bt_ctf_field_type_get_type_id( - event_header_field_type) == CTF_TYPE_INTEGER, + event_header_field_type) == BT_CTF_TYPE_ID_INTEGER, "Default event header \"timestamp\" field is an integer"); bt_put(event_header_field_type); bt_put(ret_field_type); @@ -3095,7 +3358,7 @@ int main(int argc, char **argv) packet_header_type = bt_ctf_trace_get_packet_header_type(trace); ok(packet_header_type, "bt_ctf_trace_get_packet_header_type returns a packet header"); - ok(bt_ctf_field_type_get_type_id(packet_header_type) == CTF_TYPE_STRUCT, + ok(bt_ctf_field_type_get_type_id(packet_header_type) == BT_CTF_TYPE_ID_STRUCT, "bt_ctf_trace_get_packet_header_type returns a packet header of type struct"); ret_field_type = bt_ctf_field_type_structure_get_field_type_by_name( packet_header_type, "magic"); @@ -3129,7 +3392,7 @@ int main(int argc, char **argv) packet_context_type = bt_ctf_stream_class_get_packet_context_type(stream_class); ok(packet_context_type, "bt_ctf_stream_class_get_packet_context_type returns a packet context type."); - ok(bt_ctf_field_type_get_type_id(packet_context_type) == CTF_TYPE_STRUCT, + ok(bt_ctf_field_type_get_type_id(packet_context_type) == BT_CTF_TYPE_ID_STRUCT, "Packet context is a structure"); ok(bt_ctf_stream_class_set_packet_context_type(NULL, packet_context_type), @@ -3181,6 +3444,38 @@ int main(int argc, char **argv) stream1 = bt_ctf_writer_create_stream(writer, stream_class); ok(stream1, "Instanciate a stream class from writer"); + /* + * Creating a stream through a writer adds the given stream + * class to the writer's trace, thus registering the stream + * class's clock to the trace. + */ + ok(bt_ctf_trace_get_clock_count(NULL) < 0, + "bt_ctf_trace_get_clock_count correctly handles NULL"); + ok(bt_ctf_trace_get_clock_count(trace) == 1, + "bt_ctf_trace_get_clock_count returns the correct number of clocks"); + ok(!bt_ctf_trace_get_clock(NULL, 0), + "bt_ctf_trace_get_clock correctly handles NULL"); + ok(!bt_ctf_trace_get_clock(trace, -1), + "bt_ctf_trace_get_clock correctly handles negative indexes"); + ok(!bt_ctf_trace_get_clock(trace, 1), + "bt_ctf_trace_get_clock correctly handles out of bound accesses"); + ret_clock = bt_ctf_trace_get_clock(trace, 0); + ok(ret_clock == clock, + "bt_ctf_trace_get_clock returns the right clock instance"); + 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), + "bt_ctf_trace_get_clock_by_name correctly handles NULL (clock name)"); + ok(!bt_ctf_trace_get_clock_by_name(NULL, NULL), + "bt_ctf_trace_get_clock_by_name correctly handles NULL (both)"); + 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_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"); + ok(bt_ctf_stream_get_class(NULL) == NULL, "bt_ctf_stream_get_class correctly handles NULL"); ret_stream_class = bt_ctf_stream_get_class(stream1); @@ -3189,6 +3484,23 @@ int main(int argc, char **argv) ok(ret_stream_class == stream_class, "Returned stream class is of the correct type"); + /* + * Packet header, packet context, event header, and stream + * 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); + packet_header_type = bt_ctf_trace_get_packet_header_type(trace); + assert(packet_header_type); + packet_context_type = + bt_ctf_stream_class_get_packet_context_type(stream_class); + assert(packet_context_type); + stream_event_context_type = + bt_ctf_stream_class_get_event_context_type(stream_class); + assert(stream_event_context_type); + /* * Try to modify the packet context type after a stream has been * created. @@ -3235,7 +3547,7 @@ int main(int argc, char **argv) ok(packet_header_field, "Packet header structure contains a custom field with the appropriate name"); ret_field_type = bt_ctf_field_get_type(packet_header_field); - ok(ret_field_type == packet_header_field_type, + ok(bt_ctf_field_type_compare(ret_field_type, packet_header_field_type) == 0, "Custom packet header field is of the expected type"); ok(!bt_ctf_field_unsigned_integer_set_value(packet_header_field, 54321), "Set custom packet header value successfully"); @@ -3251,6 +3563,12 @@ int main(int argc, char **argv) ok(bt_ctf_writer_add_environment_field(writer, "new_field", "test") == 0, "Add environment field to writer after stream creation"); + test_clock_utils(); + + test_trace_stream_class_clock(); + + test_create_writer_vs_non_writer_mode(); + test_instanciate_event_before_stream(writer); append_simple_event(stream_class, stream1, clock); @@ -3289,33 +3607,6 @@ int main(int argc, char **argv) free(metadata_string); bt_put(stream_class); - /* Remove all trace files and delete temporary trace directory */ - DIR *trace_dir = opendir(trace_path); - if (!trace_dir) { - perror("# opendir"); - return -1; - } - - struct dirent *entry; - while ((entry = readdir(trace_dir))) { - struct stat st; - char filename[PATH_MAX]; - - if (snprintf(filename, sizeof(filename), "%s/%s", - trace_path, entry->d_name) <= 0) { - continue; - } - - if (stat(entry->d_name, &st)) { - continue; - } - - if (S_ISREG(st.st_mode)) { - unlinkat(bt_dirfd(trace_dir), entry->d_name, 0); - } - } - - rmdir(trace_path); - closedir(trace_dir); + recursive_rmdir(trace_path); return 0; }