X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Flib%2Ftest_ctf_writer.c;h=a1a3c29ae2bd6894ecbc355358a0137e61e36433;hb=6e1f8ea1c0bffe1dbd292d9797181b97bd3d30b7;hp=826c530d84041aaab4414fceb1195be77de16c4b;hpb=1ff9582c1a6b75ddfde2d01a6afb23311858a049;p=babeltrace.git diff --git a/tests/lib/test_ctf_writer.c b/tests/lib/test_ctf_writer.c index 826c530d..a1a3c29a 100644 --- a/tests/lib/test_ctf_writer.c +++ b/tests/lib/test_ctf_writer.c @@ -31,10 +31,9 @@ #include #include #include -#include +#include #include #include -#include #include #include #include @@ -56,6 +55,27 @@ static uint64_t current_time = 42; +/* Return 1 if uuids match, zero if different. */ +int uuid_match(const unsigned char *uuid_a, const unsigned char *uuid_b) +{ + int ret = 0; + int i; + + if (!uuid_a || !uuid_b) { + goto end; + } + + for (i = 0; i < 16; i++) { + if (uuid_a[i] != uuid_b[i]) { + goto end; + } + } + + ret = 1; +end: + return ret; +} + void validate_metadata(char *parser_path, char *metadata_path) { int ret = 0; @@ -282,10 +302,14 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, const char *mapping_name_negative_test = "negative_value"; const char *ret_char; double ret_double; - size_t ret_size_t; int64_t ret_range_start_int64_t, ret_range_end_int64_t; uint64_t ret_range_start_uint64_t, ret_range_end_uint64_t; struct bt_ctf_clock *ret_clock; + struct bt_ctf_event_class *ret_event_class; + struct bt_ctf_field *packet_context; + struct bt_ctf_field *packet_context_field; + struct bt_ctf_field *event_context; + struct bt_ctf_field *event_context_field; ok(uint_12_type, "Create an unsigned integer type"); @@ -341,15 +365,11 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, -54, -55), "bt_ctf_field_type_enumeration_add_mapping rejects mapping where end < start"); bt_ctf_field_type_enumeration_add_mapping(enum_type, "another entry", -42000, -13000); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(NULL, -42, &ret_size_t) < 0, + ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(NULL, -42) < 0, "bt_ctf_field_type_enumeration_get_mapping_index_by_value handles a NULL field type correctly"); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(enum_type, -42, NULL) < 0, - "bt_ctf_field_type_enumeration_get_mapping_index_by_value handles a NULL index correctly"); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(enum_type, 1000000, &ret_size_t) < 0, - "bt_ctf_field_type_enumeration_get_mapping_index_by_value handles invalid values correctly"); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(enum_type, -55, &ret_size_t) == 0, + ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(enum_type, 1000000) < 0, "bt_ctf_field_type_enumeration_get_mapping_index_by_value handles invalid values correctly"); - ok(ret_size_t == 1, + ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(enum_type, -55) == 1, "bt_ctf_field_type_enumeration_get_mapping_index_by_value returns the correct index"); ok(bt_ctf_event_class_add_field(simple_event_class, enum_type, @@ -431,6 +451,30 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, bt_ctf_stream_class_add_event_class(stream_class, simple_event_class); + ok(bt_ctf_stream_class_get_event_class_count(NULL) < 0, + "bt_ctf_stream_class_get_event_class_count handles NULL correctly"); + ok(bt_ctf_stream_class_get_event_class_count(stream_class) == 1, + "bt_ctf_stream_class_get_event_class_count returns a correct number of event classes"); + ok(bt_ctf_stream_class_get_event_class(NULL, 0) == NULL, + "bt_ctf_stream_class_get_event_class handles NULL correctly"); + ok(bt_ctf_stream_class_get_event_class(stream_class, 8724) == NULL, + "bt_ctf_stream_class_get_event_class handles invalid indexes correctly"); + 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); + + 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"); + ok(bt_ctf_stream_class_get_event_class_by_name(stream_class, NULL) == NULL, + "bt_ctf_stream_class_get_event_class_by_name handles a NULL event class name correctly"); + ok(bt_ctf_stream_class_get_event_class_by_name(stream_class, "some event name") == NULL, + "bt_ctf_stream_class_get_event_class_by_name handles non-existing event class names 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); + simple_event = bt_ctf_event_create(simple_event_class); ok(simple_event, "Instantiate an event containing a single integer field"); @@ -489,9 +533,38 @@ 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 */ + event_context = bt_ctf_stream_get_event_context(stream); + event_context_field = bt_ctf_field_structure_get_field( + event_context, "common_event_context"); + bt_ctf_field_unsigned_integer_set_value(event_context_field, 42); + ok(bt_ctf_stream_append_event(stream, simple_event) == 0, "Append simple event to trace stream"); + ok(bt_ctf_stream_get_packet_context(NULL) == NULL, + "bt_ctf_stream_get_packet_context handles NULL correctly"); + packet_context = bt_ctf_stream_get_packet_context(stream); + ok(packet_context, + "bt_ctf_stream_get_packet_context returns a packet context"); + + packet_context_field = bt_ctf_field_structure_get_field(packet_context, + "packet_size"); + ok(packet_context_field, + "Packet context contains the default packet_size field."); + bt_ctf_field_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, + "Custom packet context field value successfully set."); + + ok(bt_ctf_stream_set_packet_context(NULL, packet_context_field) < 0, + "bt_ctf_stream_set_packet_context handles a NULL stream correctly"); + ok(bt_ctf_stream_set_packet_context(stream, NULL) < 0, + "bt_ctf_stream_set_packet_context handles a NULL packet context correctly"); + ok(bt_ctf_stream_set_packet_context(stream, packet_context) == 0, + "Successfully set a stream's packet context"); + ok(bt_ctf_stream_flush(stream) == 0, "Flush trace stream with one event"); @@ -509,6 +582,10 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, 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(event_context); + bt_ctf_field_put(event_context_field); } void append_complex_event(struct bt_ctf_stream_class *stream_class, @@ -546,9 +623,9 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, uint64_t ret_unsigned_int; int64_t ret_signed_int; const char *ret_string; - size_t ret_size_t; 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; bt_ctf_field_type_set_alignment(int_16_type, 32); bt_ctf_field_type_integer_set_signed(int_16_type, 1); @@ -586,30 +663,21 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, bt_ctf_field_type_enumeration_add_mapping(enum_variant_type, "UINT35_TYPE", 2, 7); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(NULL, "INT16_TYPE", - &ret_size_t) < 0, + ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(NULL, + "INT16_TYPE") < 0, "bt_ctf_field_type_enumeration_get_mapping_index_by_name handles a NULL field type correctly"); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(enum_variant_type, NULL, - &ret_size_t) < 0, + ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name( + enum_variant_type, NULL) < 0, "bt_ctf_field_type_enumeration_get_mapping_index_by_name handles a NULL name correctly"); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(enum_variant_type, "INT16_TYPE", - NULL) < 0, - "bt_ctf_field_type_enumeration_get_mapping_index_by_name handles a NULL index correctly"); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(enum_variant_type, "INT16_TYPE", - &ret_size_t) == 0, - "bt_ctf_field_type_enumeration_get_mapping_index_by_name returns a value"); - ok(ret_size_t == 1, + ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name( + enum_variant_type, "INT16_TYPE") == 1, "bt_ctf_field_type_enumeration_get_mapping_index_by_name returns the correct index"); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(NULL, 1, &ret_size_t) < 0, + ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(NULL, 1) < 0, "bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value handles a NULL field type correctly"); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(enum_variant_type, 1, NULL) < 0, - "bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value handles a NULL index correctly"); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(enum_variant_type, -42, &ret_size_t) < 0, - "bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value handles invalid values correctly"); - ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(enum_variant_type, 5, &ret_size_t) == 0, + ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(enum_variant_type, -42) < 0, "bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value handles invalid values correctly"); - ok(ret_size_t == 2, + ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(enum_variant_type, 5) == 2, "bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value returns the correct index"); ok(bt_ctf_field_type_variant_add_field(variant_type, uint_3_type, @@ -778,9 +846,9 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, ok(uint_35_field, "Use bt_ctf_event_get_payload to get a field instance "); bt_ctf_field_unsigned_integer_set_value(uint_35_field, 0x0DDF00D); - ok(bt_ctf_field_unsigned_integer_get_value(NULL, &ret_unsigned_int) == -1, + ok(bt_ctf_field_unsigned_integer_get_value(NULL, &ret_unsigned_int) < 0, "bt_ctf_field_unsigned_integer_get_value properly properly handles a NULL field."); - ok(bt_ctf_field_unsigned_integer_get_value(uint_35_field, NULL) == -1, + ok(bt_ctf_field_unsigned_integer_get_value(uint_35_field, NULL) < 0, "bt_ctf_field_unsigned_integer_get_value properly handles a NULL return value"); ok(bt_ctf_field_unsigned_integer_get_value(uint_35_field, &ret_unsigned_int) == 0, @@ -788,15 +856,15 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, ok(ret_unsigned_int == 0x0DDF00D, "bt_ctf_field_unsigned_integer_get_value returns the correct value"); ok(bt_ctf_field_signed_integer_get_value(uint_35_field, - &ret_signed_int) == -1, + &ret_signed_int) < 0, "bt_ctf_field_signed_integer_get_value fails on an unsigned field"); bt_ctf_field_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_signed_integer_get_value(NULL, &ret_signed_int) == -1, + ok(bt_ctf_field_signed_integer_get_value(NULL, &ret_signed_int) < 0, "bt_ctf_field_signed_integer_get_value properly handles a NULL field"); - ok(bt_ctf_field_signed_integer_get_value(int_16_field, NULL) == -1, + ok(bt_ctf_field_signed_integer_get_value(int_16_field, NULL) < 0, "bt_ctf_field_signed_integer_get_value properly handles a NULL return value"); ok(bt_ctf_field_signed_integer_get_value(int_16_field, &ret_signed_int) == 0, @@ -804,7 +872,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, ok(ret_signed_int == -12345, "bt_ctf_field_signed_integer_get_value returns the correct value"); ok(bt_ctf_field_unsigned_integer_get_value(int_16_field, - &ret_unsigned_int) == -1, + &ret_unsigned_int) < 0, "bt_ctf_field_unsigned_integer_get_value fails on a signed field"); bt_ctf_field_put(int_16_field); @@ -853,7 +921,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, "bt_ctf_field_string_get_value correctly handles NULL"); ret_string = bt_ctf_field_string_get_value(a_string_field); ok(ret_string, "bt_ctf_field_string_get_value returns a string"); - ok(!strcmp(ret_string, test_string), + ok(ret_string ? !strcmp(ret_string, test_string) : 0, "bt_ctf_field_string_get_value returns a correct value"); bt_ctf_field_unsigned_integer_set_value(uint_35_field, SEQUENCE_TEST_LENGTH); @@ -896,6 +964,16 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, bt_ctf_clock_set_time(clock, ++current_time); ok(bt_ctf_stream_append_event(stream, event) == 0, "Append a complex event to a stream"); + + /* + * Populate the custom packet context field with a dummy value + * otherwise flush will fail. + */ + packet_context = bt_ctf_stream_get_packet_context(stream); + packet_context_field = bt_ctf_field_structure_get_field(packet_context, + "custom_packet_context_field"); + bt_ctf_field_unsigned_integer_set_value(packet_context_field, 1); + ok(bt_ctf_stream_flush(stream) == 0, "Flush a stream containing a complex event"); @@ -909,6 +987,8 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, 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); @@ -1194,7 +1274,7 @@ void type_field_tests() 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") == 0, + enumeration_type, "enumeration"), "Check enumeration types are validated when adding them as structure members"); enumeration = bt_ctf_field_create(enumeration_type); ok(!enumeration, @@ -1233,9 +1313,13 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class, bt_ctf_field_type_integer_create(17); struct bt_ctf_field_type *string_type = bt_ctf_field_type_string_create(); - struct bt_ctf_event *event; - struct bt_ctf_field *ret_field; - struct bt_ctf_field_type *ret_field_type; + struct bt_ctf_event *event = NULL; + struct bt_ctf_field *ret_field = NULL; + struct bt_ctf_field_type *ret_field_type = NULL; + uint64_t ret_uint64; + int events_appended = 0; + struct bt_ctf_field *packet_context = NULL, + *packet_context_field = NULL, *event_context = NULL; ret |= bt_ctf_event_class_add_field(event_class, integer_type, "field_1"); @@ -1261,6 +1345,22 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class, "bt_ctf_event_get_payload_by_index handles an invalid index correctly"); bt_ctf_event_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_ctf_field_put(ret_field); + for (i = 0; i < PACKET_RESIZE_TEST_LENGTH; i++) { event = bt_ctf_event_create(event_class); struct bt_ctf_field *integer = @@ -1277,6 +1377,14 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class, ret |= bt_ctf_event_set_payload(event, "a_string", string); bt_ctf_field_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); + ret |= bt_ctf_stream_append_event(stream, event); bt_ctf_event_put(event); @@ -1284,12 +1392,42 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class, break; } } + + events_appended = !!(i == PACKET_RESIZE_TEST_LENGTH); + ok(bt_ctf_stream_get_discarded_events_count(NULL, &ret_uint64) < 0, + "bt_ctf_stream_get_discarded_events_count handles a NULL stream correctly"); + ok(bt_ctf_stream_get_discarded_events_count(stream, NULL) < 0, + "bt_ctf_stream_get_discarded_events_count handles a NULL return pointer correctly"); + ret = bt_ctf_stream_get_discarded_events_count(stream, &ret_uint64); + ok(ret == 0 && ret_uint64 == 0, + "bt_ctf_stream_get_discarded_events_count returns a correct number of discarded events when none were discarded"); + bt_ctf_stream_append_discarded_events(stream, 1000); + 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 when some were discarded"); + end: - ok(ret == 0, "Append 100 000 events to a stream"); + ok(events_appended, "Append 100 000 events to a stream"); + + /* + * Populate the custom packet context field with a dummy value + * otherwise flush will fail. + */ + packet_context = bt_ctf_stream_get_packet_context(stream); + packet_context_field = bt_ctf_field_structure_get_field(packet_context, + "custom_packet_context_field"); + bt_ctf_field_unsigned_integer_set_value(packet_context_field, 2); + ok(bt_ctf_stream_flush(stream) == 0, "Flush a stream that forces a packet resize"); + 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); } @@ -1309,14 +1447,24 @@ int main(int argc, char **argv) char *metadata_string; struct bt_ctf_writer *writer; struct utsname name; - char hostname[HOST_NAME_MAX]; + char hostname[BABELTRACE_HOST_NAME_MAX]; struct bt_ctf_clock *clock, *ret_clock; struct bt_ctf_stream_class *stream_class; struct bt_ctf_stream *stream1; + const char *ret_string; + const unsigned char *ret_uuid; + unsigned char tmp_uuid[16] = { 0 }; + struct bt_ctf_field_type *packet_context_type, + *packet_context_field_type, + *integer_type, + *stream_event_context_type, + *ret_field_type; + struct bt_ctf_trace *trace; + int ret; if (argc < 3) { printf("Usage: tests-ctf-writer path_to_ctf_parser_test path_to_babeltrace\n"); - exit(-1); + return -1; } plan_no_plan(); @@ -1332,7 +1480,10 @@ int main(int argc, char **argv) ok(writer, "bt_ctf_create succeeds in creating trace with path"); /* Add environment context to the trace */ - gethostname(hostname, HOST_NAME_MAX); + ret = gethostname(hostname, sizeof(hostname)); + if (ret < 0) { + return ret; + } ok(bt_ctf_writer_add_environment_field(writer, "host", hostname) == 0, "Add host (%s) environment field to writer instance", hostname); @@ -1376,7 +1527,7 @@ int main(int argc, char **argv) ok(clock, "Clock created sucessfully"); returned_clock_name = bt_ctf_clock_get_name(clock); ok(returned_clock_name, "bt_ctf_clock_get_name returns a clock name"); - ok(strcmp(returned_clock_name, clock_name) == 0, + ok(returned_clock_name ? !strcmp(returned_clock_name, clock_name) : 0, "Returned clock name is valid"); returned_clock_description = bt_ctf_clock_get_description(clock); @@ -1387,7 +1538,8 @@ int main(int argc, char **argv) returned_clock_description = bt_ctf_clock_get_description(clock); ok(returned_clock_description, "bt_ctf_clock_get_description returns a description."); - ok(strcmp(returned_clock_description, clock_description) == 0, + ok(returned_clock_description ? + !strcmp(returned_clock_description, clock_description) : 0, "Returned clock description is valid"); ok(bt_ctf_clock_get_frequency(clock) == DEFAULT_CLOCK_FREQ, @@ -1436,6 +1588,26 @@ int main(int argc, char **argv) ok(bt_ctf_writer_add_clock(writer, clock), "Verify a clock can't be added twice to a writer instance"); + ok(!bt_ctf_writer_get_trace(NULL), + "bt_ctf_writer_get_trace correctly handles NULL"); + trace = bt_ctf_writer_get_trace(writer); + ok(trace, + "bt_ctf_writer_get_trace returns a bt_ctf_trace object"); + 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_ctf_clock_put(ret_clock); + ok(!bt_ctf_clock_get_name(NULL), "bt_ctf_clock_get_name correctly handles NULL"); ok(!bt_ctf_clock_get_description(NULL), @@ -1448,28 +1620,57 @@ int main(int argc, char **argv) "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_is_absolute(NULL) == -1, + 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_set_description(NULL, NULL) == -1, + ok(bt_ctf_clock_set_description(NULL, NULL) < 0, "bt_ctf_clock_set_description correctly handles NULL clock"); - ok(bt_ctf_clock_set_frequency(NULL, frequency) == -1, + ok(bt_ctf_clock_set_frequency(NULL, frequency) < 0, "bt_ctf_clock_set_frequency correctly handles NULL clock"); - ok(bt_ctf_clock_set_precision(NULL, precision) == -1, + ok(bt_ctf_clock_set_precision(NULL, precision) < 0, "bt_ctf_clock_get_precision correctly handles NULL clock"); - ok(bt_ctf_clock_set_offset_s(NULL, offset_s) == -1, + ok(bt_ctf_clock_set_offset_s(NULL, offset_s) < 0, "bt_ctf_clock_set_offset_s correctly handles NULL clock"); - ok(bt_ctf_clock_set_offset(NULL, offset) == -1, + ok(bt_ctf_clock_set_offset(NULL, offset) < 0, "bt_ctf_clock_set_offset correctly handles NULL clock"); - ok(bt_ctf_clock_set_is_absolute(NULL, is_absolute) == -1, + ok(bt_ctf_clock_set_is_absolute(NULL, is_absolute) < 0, "bt_ctf_clock_set_is_absolute correctly handles NULL clock"); - ok(bt_ctf_clock_set_time(NULL, current_time) == -1, + ok(bt_ctf_clock_set_time(NULL, current_time) < 0, "bt_ctf_clock_set_time correctly handles NULL clock"); + ok(bt_ctf_clock_get_uuid(NULL) == NULL, + "bt_ctf_clock_get_uuid correctly handles NULL clock"); + ret_uuid = bt_ctf_clock_get_uuid(clock); + ok(ret_uuid, + "bt_ctf_clock_get_uuid returns a UUID"); + if (ret_uuid) { + memcpy(tmp_uuid, ret_uuid, sizeof(tmp_uuid)); + /* Slightly modify UUID */ + tmp_uuid[sizeof(tmp_uuid) - 1]++; + } + + ok(bt_ctf_clock_set_uuid(NULL, tmp_uuid) < 0, + "bt_ctf_clock_set_uuid correctly handles a NULL clock"); + 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"); + ret_uuid = bt_ctf_clock_get_uuid(clock); + ok(ret_uuid, + "bt_ctf_clock_get_uuid returns a UUID after setting a new one"); + ok(uuid_match(ret_uuid, tmp_uuid), + "bt_ctf_clock_get_uuid returns the correct UUID after setting a new one"); /* Define a stream class */ stream_class = bt_ctf_stream_class_create("test_stream"); + + ok(bt_ctf_stream_class_get_name(NULL) == NULL, + "bt_ctf_stream_class_get_name handles NULL correctly"); + ret_string = bt_ctf_stream_class_get_name(stream_class); + ok(!strcmp(ret_string, "test_stream"), + "bt_ctf_stream_class_get_name returns a correct stream class name"); + ok(bt_ctf_stream_class_get_clock(stream_class) == NULL, "bt_ctf_stream_class_get_clock returns NULL when a clock was not set"); ok(bt_ctf_stream_class_get_clock(NULL) == NULL, @@ -1497,11 +1698,83 @@ int main(int argc, char **argv) ok(bt_ctf_stream_class_get_id(stream_class) == 123, "bt_ctf_stream_class_get_id returns the correct value"); + /* Create a "uint5_t" equivalent custom packet context field */ + packet_context_field_type = bt_ctf_field_type_integer_create(5); + + ok(bt_ctf_stream_class_get_packet_context_type(NULL) == NULL, + "bt_ctf_stream_class_get_packet_context_type handles NULL correctly"); + + /* Add a custom field to the stream class' packet context */ + 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, + "Packet context is a structure"); + + ok(bt_ctf_stream_class_set_packet_context_type(NULL, packet_context_type), + "bt_ctf_stream_class_set_packet_context_type handles a NULL stream class correctly"); + ok(bt_ctf_stream_class_set_packet_context_type(stream_class, NULL), + "bt_ctf_stream_class_set_packet_context_type handles a NULL packet context type correctly"); + + integer_type = bt_ctf_field_type_integer_create(32); + ok(bt_ctf_stream_class_set_packet_context_type(stream_class, + integer_type) < 0, + "bt_ctf_stream_class_set_packet_context_type rejects a packet context that is not a structure"); + ret = bt_ctf_field_type_structure_add_field(packet_context_type, + packet_context_field_type, "custom_packet_context_field"); + ok(ret == 0, "Packet context field added successfully"); + + /* Define a stream event context containing a my_integer field. */ + ok(bt_ctf_stream_class_get_event_context_type(NULL) == NULL, + "bt_ctf_stream_class_get_event_context_type handles NULL correctly"); + ok(bt_ctf_stream_class_get_event_context_type( + stream_class) == NULL, + "bt_ctf_stream_class_get_event_context_type returns NULL when no stream event context type was set."); + stream_event_context_type = bt_ctf_field_type_structure_create(); + bt_ctf_field_type_structure_add_field(stream_event_context_type, + integer_type, "common_event_context"); + + ok(bt_ctf_stream_class_set_event_context_type(NULL, + stream_event_context_type) < 0, + "bt_ctf_stream_class_set_event_context_type handles a NULL stream_class correctly"); + ok(bt_ctf_stream_class_set_event_context_type(stream_class, + NULL) < 0, + "bt_ctf_stream_class_set_event_context_type handles a NULL event_context correctly"); + ok(bt_ctf_stream_class_set_event_context_type(stream_class, + integer_type) < 0, + "bt_ctf_stream_class_set_event_context_type validates that the event context os a structure"); + + ok(bt_ctf_stream_class_set_event_context_type( + stream_class, stream_event_context_type) == 0, + "Set a new stream event context type"); + ret_field_type = bt_ctf_stream_class_get_event_context_type( + stream_class); + ok(ret_field_type == stream_event_context_type, + "bt_ctf_stream_class_get_event_context_type returns the correct field type."); + /* Instantiate a stream and append events */ stream1 = bt_ctf_writer_create_stream(writer, stream_class); ok(stream1, "Instanciate a stream class from writer"); - /* Should fail after instanciating a stream (locked)*/ + /* + * Try to modify the packet context type after a stream has been + * created. + */ + ret = bt_ctf_field_type_structure_add_field(packet_context_type, + packet_context_field_type, "should_fail"); + ok(ret < 0, + "Packet context type can't be modified once a stream class has been instanciated"); + + /* + * Try to modify the stream event context type after a stream has been + * created. + */ + ret = bt_ctf_field_type_structure_add_field(stream_event_context_type, + integer_type, "should_fail"); + ok(ret < 0, + "Stream event context type can't be modified once a stream class has been instanciated"); + + /* Should fail after instanciating a stream (frozen) */ ok(bt_ctf_stream_class_set_clock(stream_class, clock), "Changes to a stream class that was already instantiated fail"); @@ -1522,6 +1795,12 @@ int main(int argc, char **argv) bt_ctf_stream_class_put(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_trace_put(trace); free(metadata_string); /* Remove all trace files and delete temporary trace directory */