X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Flib%2Ftest_ctf_writer.c;h=1e7393a34a660aa281e870b0bfbd8f8ae0cbee75;hb=5fd2e9fda6185e989583e6e61b9312683149747e;hp=007423d1870c5cbfa39b989fe70828832b86f8d8;hpb=4dc6a420e773a1e928099a0908d6348a73f2941e;p=babeltrace.git diff --git a/tests/lib/test_ctf_writer.c b/tests/lib/test_ctf_writer.c index 007423d1..1e7393a3 100644 --- a/tests/lib/test_ctf_writer.c +++ b/tests/lib/test_ctf_writer.c @@ -34,6 +34,7 @@ #include #include #include +#include #include #include #include @@ -55,8 +56,11 @@ #define DEFAULT_CLOCK_OFFSET_S 0 #define DEFAULT_CLOCK_IS_ABSOLUTE 0 #define DEFAULT_CLOCK_TIME 0 +#define DEFAULT_CLOCK_VALUE 0 -static uint64_t current_time = 42; +#define NR_TESTS 591 + +static int64_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) @@ -160,12 +164,12 @@ result: rewind(metadata_fp); /* Output the metadata and parser output as diagnostic */ - while (getline(&line, &len, metadata_fp) > 0) { + while (bt_getline(&line, &len, metadata_fp) > 0) { fprintf(stderr, "# %s", line); } rewind(parser_output_fp); - while (getline(&line, &len, parser_output_fp) > 0) { + while (bt_getline(&line, &len, parser_output_fp) > 0) { fprintf(stderr, "# %s", line); } @@ -257,7 +261,7 @@ result: diag("malloc error"); } rewind(babeltrace_output_fp); - while (getline(&line, &len, babeltrace_output_fp) > 0) { + while (bt_getline(&line, &len, babeltrace_output_fp) > 0) { diag("%s", line); } @@ -377,6 +381,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; @@ -400,6 +405,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"); @@ -564,6 +573,32 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, bt_ctf_stream_class_add_event_class(stream_class, simple_event_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"); ok(bt_ctf_stream_class_get_event_class_count(stream_class) == 1, @@ -608,7 +643,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"); @@ -626,7 +661,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); @@ -639,16 +675,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"); @@ -656,7 +695,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); @@ -734,6 +775,10 @@ 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); } void append_complex_event(struct bt_ctf_stream_class *stream_class, @@ -782,7 +827,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; @@ -1096,7 +1142,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"), @@ -1109,7 +1155,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); @@ -1171,7 +1217,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); @@ -1264,6 +1310,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"); @@ -1849,8 +1903,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; @@ -1908,10 +1960,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) == @@ -1921,17 +1973,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); @@ -1943,7 +1998,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, @@ -1963,25 +2018,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, @@ -2096,17 +2151,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"); @@ -2123,8 +2167,6 @@ 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); } @@ -2150,7 +2192,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"); @@ -2162,10 +2207,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); @@ -2176,28 +2235,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); @@ -2210,8 +2253,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); @@ -2258,8 +2304,11 @@ 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); } void test_empty_stream(struct bt_ctf_writer *writer) @@ -2655,8 +2704,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; @@ -2688,7 +2740,7 @@ int main(int argc, char **argv) return -1; } - plan_no_plan(); + plan_tests(NR_TESTS); if (!bt_mkdtemp(trace_path)) { perror("# perror"); @@ -2898,18 +2950,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"); @@ -2925,11 +2985,21 @@ 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, @@ -2972,14 +3042,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"); @@ -3064,7 +3140,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( @@ -3072,7 +3148,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 = @@ -3081,7 +3157,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); @@ -3092,7 +3168,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"); @@ -3126,7 +3202,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), @@ -3186,6 +3262,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. @@ -3232,7 +3325,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"); @@ -3284,9 +3377,6 @@ int main(int argc, char **argv) bt_put(packet_header_field); bt_put(trace); free(metadata_string); - - ok(bt_ctf_stream_class_get_trace(stream_class) == NULL, - "bt_ctf_stream_class_get_trace returns NULL after its trace has been reclaimed"); bt_put(stream_class); /* Remove all trace files and delete temporary trace directory */