Add missing trace-internal.h header file

[babeltrace.git] / tests / lib / test_ctf_writer.c

diff --git a/tests/lib/test_ctf_writer.c b/tests/lib/test_ctf_writer.c
index 227ca504369e8c6eac606268f966ed467a5f4b82..2d5cccfb56334ff5bf4587636fb9effd57f79974 100644 (file)
--- a/tests/lib/test_ctf_writer.c
+++ b/tests/lib/test_ctf_writer.c
@@ -56,6 +56,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;
@@ -831,9 +852,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,
@@ -841,15 +862,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,
@@ -857,7 +878,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);
 
@@ -1354,9 +1375,9 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class,
        }
 
        events_appended = 1;
-       ok(bt_ctf_stream_get_discarded_events_count(NULL, &ret_uint64) == -1,
+       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) == -1,
+       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,
@@ -1411,6 +1432,8 @@ int main(int argc, char **argv)
        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;
        int ret;
 
@@ -1552,25 +1575,47 @@ 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");