X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Flib%2Ftest_ctf_writer.c;h=09eb05f87ba3e2f63cc0142a246140f9df229bd8;hb=e13d28e117bc7463e776cbd6c40cea2f7d081643;hp=f75daba95de4d8f407a000c133b2766e24a94d2a;hpb=09840de5d022697671dafe2bed427fa5c09b40b9;p=babeltrace.git diff --git a/tests/lib/test_ctf_writer.c b/tests/lib/test_ctf_writer.c index f75daba9..09eb05f8 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 594 +#define NR_TESTS 618 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) { @@ -570,7 +493,8 @@ 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 @@ -694,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); @@ -721,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"); @@ -778,6 +703,7 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, 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) { @@ -824,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; @@ -841,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, @@ -863,12 +793,12 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, ok(bt_ctf_field_type_array_get_length(array_type) == ARRAY_TEST_LENGTH, "bt_ctf_field_type_array_get_length returns the correct length"); - bt_ctf_field_type_structure_add_field(inner_structure_type, - uint_35_type, "seq_len"); - bt_ctf_field_type_structure_add_field(inner_structure_type, - sequence_type, "a_sequence"); - bt_ctf_field_type_structure_add_field(inner_structure_type, - array_type, "an_array"); + ok(!bt_ctf_field_type_structure_add_field(inner_structure_type, + uint_35_type, "seq_len"), "Add seq_len field to inner structure"); + ok(!bt_ctf_field_type_structure_add_field(inner_structure_type, + sequence_type, "a_sequence"), "Add a_sequence field to inner structure"); + ok(!bt_ctf_field_type_structure_add_field(inner_structure_type, + array_type, "an_array"), "Add an_array field to inner structure"); bt_ctf_field_type_enumeration_add_mapping(enum_variant_type, "UINT3_TYPE", 0, 0); @@ -898,10 +828,10 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, "An unknown entry"), "Reject a variant field based on an unknown tag value"); ok(bt_ctf_field_type_variant_add_field(variant_type, uint_3_type, "UINT3_TYPE") == 0, "Add a field to a variant"); - bt_ctf_field_type_variant_add_field(variant_type, int_16_type, - "INT16_TYPE"); - bt_ctf_field_type_variant_add_field(variant_type, uint_35_type, - "UINT35_TYPE"); + ok(!bt_ctf_field_type_variant_add_field(variant_type, int_16_type, + "INT16_TYPE"), "Add INT16_TYPE field to variant"); + ok(!bt_ctf_field_type_variant_add_field(variant_type, uint_35_type, + "UINT35_TYPE"), "Add UINT35_TYPE field to variant"); ok(bt_ctf_field_type_variant_get_tag_type(NULL) == NULL, "bt_ctf_field_type_variant_get_tag_type handles NULL correctly"); @@ -949,14 +879,17 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, "bt_ctf_field_type_variant_get_field returns a correct field type"); bt_put(ret_field_type); - bt_ctf_field_type_structure_add_field(complex_structure_type, - enum_variant_type, "variant_selector"); - bt_ctf_field_type_structure_add_field(complex_structure_type, - string_type, "a_string"); - bt_ctf_field_type_structure_add_field(complex_structure_type, - variant_type, "variant_value"); - bt_ctf_field_type_structure_add_field(complex_structure_type, - inner_structure_type, "inner_structure"); + ok(!bt_ctf_field_type_structure_add_field(complex_structure_type, + enum_variant_type, "variant_selector"), + "Add variant_selector field to complex structure"); + ok(!bt_ctf_field_type_structure_add_field(complex_structure_type, + string_type, "a_string"), "Add a_string field to complex structure"); + ok(!bt_ctf_field_type_structure_add_field(complex_structure_type, + variant_type, "variant_value"), + "Add variant_value field to complex structure"); + ok(!bt_ctf_field_type_structure_add_field(complex_structure_type, + inner_structure_type, "inner_structure"), + "Add inner_structure field to complex structure"); ok(bt_ctf_event_class_create("clock") == NULL, "Reject creation of an event class with an illegal name"); @@ -1306,6 +1239,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"); @@ -1349,8 +1290,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; @@ -1360,13 +1302,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; @@ -1876,6 +1820,7 @@ void field_copy_tests() bt_put(strct_copy); } +static void type_field_tests() { struct bt_ctf_field *uint_12; @@ -1948,10 +1893,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) == @@ -1961,20 +1906,24 @@ 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); + assert(int_16_type); bt_ctf_field_type_integer_set_signed(int_16_type, 1); ok(bt_ctf_field_type_integer_get_signed(int_16_type) == 1, "bt_ctf_field_type_integer_get_signed returns a correct value for signed types"); @@ -1983,7 +1932,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, @@ -2003,25 +1952,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, @@ -2155,6 +2104,7 @@ void type_field_tests() 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) { @@ -2177,7 +2127,7 @@ 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; @@ -2220,22 +2170,6 @@ 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(ep_field_1_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 = @@ -2254,8 +2188,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); @@ -2302,13 +2239,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; @@ -2354,6 +2292,7 @@ end: bt_put(stream_class); } +static void test_custom_event_header_stream(struct bt_ctf_writer *writer) { int i, ret; @@ -2559,6 +2498,7 @@ end: bt_put(event_header_type); } +static void test_instanciate_event_before_stream(struct bt_ctf_writer *writer) { int ret = 0; @@ -2675,6 +2615,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; @@ -2693,6 +2634,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"; @@ -2987,45 +3215,19 @@ int main(int argc, char **argv) "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, &get_time) == 0, "bt_ctf_clock_get_time succeeds"); - ok(get_time == current_time, + 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), @@ -3079,7 +3281,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"); @@ -3132,7 +3334,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( @@ -3140,7 +3342,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 = @@ -3149,7 +3351,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); @@ -3160,7 +3362,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"); @@ -3194,7 +3396,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), @@ -3246,6 +3448,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); @@ -3333,6 +3567,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); @@ -3371,33 +3611,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; }