tests/lib/test_ctf_writer.c

   1 /*
   2  * test_ctf_writer.c
   3  *
   4  * CTF Writer test
   5  *
   6  * Copyright 2013 - 2017 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; under version 2 of the License.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <babeltrace/ctf-writer/writer.h>
  23 #include <babeltrace/ctf-writer/clock.h>
  24 #include <babeltrace/ctf-writer/stream.h>
  25 #include <babeltrace/ctf-writer/event.h>
  26 #include <babeltrace/ctf-writer/event-types.h>
  27 #include <babeltrace/ctf-writer/event-fields.h>
  28 #include <babeltrace/ctf-writer/stream-class.h>
  29 #include <babeltrace/ctf-ir/packet.h>
  30 #include <babeltrace/ctf-ir/clock-class.h>
  31 #include <babeltrace/ctf-ir/trace.h>
  32 #include <babeltrace/ref.h>
  33 #include <babeltrace/ctf/events.h>
  34 #include <babeltrace/values.h>
  35 #include <glib.h>
  36 #include <unistd.h>
  37 #include <babeltrace/compat/stdlib-internal.h>
  38 #include <stdio.h>
  39 #include <babeltrace/compat/limits-internal.h>
  40 #include <babeltrace/compat/stdio-internal.h>
  41 #include <string.h>
  42 #include <assert.h>
  43 #include <fcntl.h>
  44 #include "tap/tap.h"
  45 #include <math.h>
  46 #include <float.h>
  47 #include "common.h"
  48
  49 #define METADATA_LINE_SIZE 512
  50 #define SEQUENCE_TEST_LENGTH 10
  51 #define ARRAY_TEST_LENGTH 5
  52 #define PACKET_RESIZE_TEST_DEF_LENGTH 100000
  53
  54 #define DEFAULT_CLOCK_FREQ 1000000000
  55 #define DEFAULT_CLOCK_PRECISION 1
  56 #define DEFAULT_CLOCK_OFFSET 0
  57 #define DEFAULT_CLOCK_OFFSET_S 0
  58 #define DEFAULT_CLOCK_IS_ABSOLUTE 0
  59 #define DEFAULT_CLOCK_TIME 0
  60 #define DEFAULT_CLOCK_VALUE 0
  61
  62 #define NR_TESTS 552
  63
  64 struct bt_utsname {
  65         char sysname[BABELTRACE_HOST_NAME_MAX];
  66         char nodename[BABELTRACE_HOST_NAME_MAX];
  67         char release[BABELTRACE_HOST_NAME_MAX];
  68         char version[BABELTRACE_HOST_NAME_MAX];
  69         char machine[BABELTRACE_HOST_NAME_MAX];
  70 };
  71
  72 static int64_t current_time = 42;
  73 static unsigned int packet_resize_test_length = PACKET_RESIZE_TEST_DEF_LENGTH;
  74
  75 /* Return 1 if uuids match, zero if different. */
  76 static
  77 int uuid_match(const unsigned char *uuid_a, const unsigned char *uuid_b)
  78 {
  79         int ret = 0;
  80         int i;
  81
  82         if (!uuid_a || !uuid_b) {
  83                 goto end;
  84         }
  85
  86         for (i = 0; i < 16; i++) {
  87                 if (uuid_a[i] != uuid_b[i]) {
  88                         goto end;
  89                 }
  90         }
  91
  92         ret = 1;
  93 end:
  94         return ret;
  95 }
  96
  97 static
  98 void validate_trace(char *parser_path, char *trace_path)
  99 {
 100         int ret = 0;
 101         gchar *standard_error = NULL;
 102         gint exit_status;
 103         char *argv[] = {parser_path, trace_path, "-o", "dummy", NULL};
 104
 105         if (!parser_path || !trace_path) {
 106                 ret = -1;
 107                 goto result;
 108         }
 109
 110         if (!g_spawn_sync(NULL,
 111                         argv,
 112                         NULL,
 113                         G_SPAWN_STDOUT_TO_DEV_NULL,
 114                         NULL,
 115                         NULL,
 116                         NULL,
 117                         &standard_error,
 118                         &exit_status,
 119                         NULL)) {
 120                 diag("Failed to spawn babeltrace.");
 121                 ret = -1;
 122                 goto result;
 123         }
 124
 125         /* Replace by g_spawn_check_exit_status when we require glib >= 2.34 */
 126 #ifdef G_OS_UNIX
 127         ret = WIFEXITED(exit_status) ? WEXITSTATUS(exit_status) : -1;
 128 #else
 129         ret = exit_status;
 130 #endif
 131
 132         if (ret != 0) {
 133                 diag("Babeltrace returned an error.");
 134                 diag_multiline(standard_error);
 135                 goto result;
 136         }
 137
 138 result:
 139         ok(ret == 0, "Babeltrace could read the resulting trace");
 140         g_free(standard_error);
 141 }
 142
 143 static
 144 void append_simple_event(struct bt_stream_class *stream_class,
 145                 struct bt_stream *stream, struct bt_ctf_clock *clock)
 146 {
 147         /* Create and add a simple event class */
 148         struct bt_event_class *simple_event_class =
 149                 bt_event_class_create("Simple Event");
 150         struct bt_field_type *uint_12_type =
 151                 bt_field_type_integer_create(12);
 152         struct bt_field_type *int_64_type =
 153                 bt_field_type_integer_create(64);
 154         struct bt_field_type *float_type =
 155                 bt_field_type_floating_point_create();
 156         struct bt_field_type *enum_type;
 157         struct bt_field_type *enum_type_unsigned =
 158                 bt_field_type_enumeration_create(uint_12_type);
 159         struct bt_field_type *event_context_type =
 160                 bt_field_type_structure_create();
 161         struct bt_field_type *event_payload_type = NULL;
 162         struct bt_field_type *returned_type;
 163         struct bt_event *simple_event;
 164         struct bt_field *integer_field;
 165         struct bt_field *float_field;
 166         struct bt_field *enum_field;
 167         struct bt_field *enum_field_unsigned;
 168         struct bt_field *enum_container_field;
 169         const char *mapping_name_test = "truie";
 170         const double double_test_value = 3.1415;
 171         struct bt_field *enum_container_field_unsigned;
 172         const char *mapping_name_negative_test = "negative_value";
 173         const char *ret_char;
 174         double ret_double;
 175         int64_t ret_range_start_int64_t, ret_range_end_int64_t;
 176         uint64_t ret_range_start_uint64_t, ret_range_end_uint64_t;
 177         struct bt_event_class *ret_event_class;
 178         struct bt_field *packet_context;
 179         struct bt_field *packet_context_field;
 180         struct bt_field *stream_event_context;
 181         struct bt_field *stream_event_context_field;
 182         struct bt_field *event_context;
 183         struct bt_field *event_context_field;
 184         struct bt_field_type *ep_integer_field_type = NULL;
 185         struct bt_field_type *ep_enum_field_type = NULL;
 186         struct bt_field_type *ep_enum_field_unsigned_type = NULL;
 187         struct bt_field_type_enumeration_mapping_iterator *iter = NULL;
 188         int ret;
 189
 190         ok(uint_12_type, "Create an unsigned integer type");
 191
 192         ok(!bt_ctf_field_type_integer_set_signed(int_64_type, 1),
 193                 "Set signed 64 bit integer signedness to true");
 194         ok(int_64_type, "Create a signed integer type");
 195         enum_type = bt_field_type_enumeration_create(int_64_type);
 196
 197         returned_type = bt_field_type_enumeration_get_container_type(enum_type);
 198         ok(returned_type == int_64_type, "bt_field_type_enumeration_get_container_type returns the right type");
 199         ok(!bt_field_type_enumeration_get_container_type(NULL), "bt_field_type_enumeration_get_container_type handles NULL correctly");
 200         ok(!bt_field_type_enumeration_create(enum_type),
 201                 "bt_field_enumeration_type_create rejects non-integer container field types");
 202         bt_put(returned_type);
 203
 204         bt_field_type_set_alignment(float_type, 32);
 205         ok(bt_field_type_get_alignment(NULL) < 0,
 206                 "bt_field_type_get_alignment handles NULL correctly");
 207         ok(bt_field_type_get_alignment(float_type) == 32,
 208                 "bt_field_type_get_alignment returns a correct value");
 209
 210         ok(bt_field_type_floating_point_set_exponent_digits(float_type, 11) == 0,
 211                 "Set a floating point type's exponent digit count");
 212         ok(bt_field_type_floating_point_set_mantissa_digits(float_type, 53) == 0,
 213                 "Set a floating point type's mantissa digit count");
 214
 215         ok(bt_field_type_floating_point_get_exponent_digits(NULL) < 0,
 216                 "bt_field_type_floating_point_get_exponent_digits handles NULL properly");
 217         ok(bt_field_type_floating_point_get_mantissa_digits(NULL) < 0,
 218                 "bt_field_type_floating_point_get_mantissa_digits handles NULL properly");
 219         ok(bt_field_type_floating_point_get_exponent_digits(float_type) == 11,
 220                 "bt_field_type_floating_point_get_exponent_digits returns the correct value");
 221         ok(bt_field_type_floating_point_get_mantissa_digits(float_type) == 53,
 222                 "bt_field_type_floating_point_get_mantissa_digits returns the correct value");
 223
 224         ok(bt_ctf_field_type_enumeration_add_mapping(enum_type,
 225                 mapping_name_negative_test, -12345, 0) == 0,
 226                 "bt_field_type_enumeration_add_mapping accepts negative enumeration mappings");
 227         ok(bt_ctf_field_type_enumeration_add_mapping(enum_type,
 228                 "escaping; \"test\"", 1, 1) == 0,
 229                 "bt_field_type_enumeration_add_mapping accepts enumeration mapping strings containing quotes");
 230         ok(bt_ctf_field_type_enumeration_add_mapping(enum_type,
 231                 "\tanother \'escaping\'\n test\"", 2, 4) == 0,
 232                 "bt_field_type_enumeration_add_mapping accepts enumeration mapping strings containing special characters");
 233         ok(bt_ctf_field_type_enumeration_add_mapping(enum_type,
 234                 "event clock int float", 5, 22) == 0,
 235                 "Accept enumeration mapping strings containing reserved keywords");
 236         bt_ctf_field_type_enumeration_add_mapping(enum_type, mapping_name_test,
 237                 42, 42);
 238         ok(bt_ctf_field_type_enumeration_add_mapping(enum_type, mapping_name_test,
 239                 43, 51) == 0, "bt_field_type_enumeration_add_mapping accepts duplicate mapping names");
 240         ok(bt_ctf_field_type_enumeration_add_mapping(enum_type, "something",
 241                 -500, -400) == 0, "bt_field_type_enumeration_add_mapping accepts overlapping enum entries");
 242         ok(bt_ctf_field_type_enumeration_add_mapping(enum_type, mapping_name_test,
 243                 -54, -55), "bt_field_type_enumeration_add_mapping rejects mapping where end < start");
 244         bt_ctf_field_type_enumeration_add_mapping(enum_type, "another entry", -42000, -13000);
 245
 246         iter = bt_field_type_enumeration_find_mappings_by_signed_value(NULL, -42);
 247         ok(iter == NULL, "bt_field_type_enumeration_find_mappings_by_signed_value handles a NULL field type correctly");
 248
 249         iter = bt_field_type_enumeration_find_mappings_by_signed_value(enum_type, -4200000);
 250         ret = bt_field_type_enumeration_mapping_iterator_next(iter);
 251         ok(iter && ret, "bt_field_type_enumeration_find_mappings_by_signed_value rejects non-mapped values");
 252         BT_PUT(iter);
 253
 254         iter = bt_field_type_enumeration_find_mappings_by_signed_value(enum_type, 3);
 255         ok(iter != NULL, "bt_field_type_enumeration_find_mappings_by_signed_value succeeds with mapped value");
 256         ret = bt_field_type_enumeration_mapping_iterator_next(iter);
 257         ok(!ret && bt_field_type_enumeration_mapping_iterator_get_signed(iter, NULL, NULL, NULL) == 0,
 258                 "bt_field_type_enumeration_mapping_iterator_get_signed handles mapped values correctly");
 259         BT_PUT(iter);
 260
 261         ok(bt_event_class_add_field(simple_event_class, enum_type,
 262                 "enum_field") == 0, "Add signed enumeration field to event");
 263
 264         ok(bt_field_type_enumeration_get_mapping_signed(NULL, 0, &ret_char,
 265                 &ret_range_start_int64_t, &ret_range_end_int64_t) < 0,
 266                 "bt_field_type_enumeration_get_mapping_signed handles a NULL enumeration correctly");
 267         ok(bt_field_type_enumeration_get_mapping_signed(enum_type, 0, NULL,
 268                 &ret_range_start_int64_t, &ret_range_end_int64_t) == 0,
 269                 "bt_field_type_enumeration_get_mapping_signed handles a NULL string correctly");
 270         ok(bt_field_type_enumeration_get_mapping_signed(enum_type, 0, &ret_char,
 271                 NULL, &ret_range_end_int64_t) == 0,
 272                 "bt_field_type_enumeration_get_mapping_signed handles a NULL start correctly");
 273         ok(bt_field_type_enumeration_get_mapping_signed(enum_type, 0, &ret_char,
 274                 &ret_range_start_int64_t, NULL) == 0,
 275                 "bt_field_type_enumeration_get_mapping_signed handles a NULL end correctly");
 276         /* Assumes entries are sorted by range_start values. */
 277         ok(bt_field_type_enumeration_get_mapping_signed(enum_type, 6, &ret_char,
 278                 &ret_range_start_int64_t, &ret_range_end_int64_t) == 0,
 279                 "bt_field_type_enumeration_get_mapping_signed returns a value");
 280         ok(!strcmp(ret_char, mapping_name_test),
 281                 "bt_field_type_enumeration_get_mapping_signed returns a correct mapping name");
 282         ok(ret_range_start_int64_t == 42,
 283                 "bt_field_type_enumeration_get_mapping_signed returns a correct mapping start");
 284         ok(ret_range_end_int64_t == 42,
 285                 "bt_field_type_enumeration_get_mapping_signed returns a correct mapping end");
 286
 287         ok(bt_field_type_enumeration_add_mapping_unsigned(enum_type_unsigned,
 288                 "escaping; \"test\"", 0, 0) == 0,
 289                 "bt_field_type_enumeration_add_mapping_unsigned accepts enumeration mapping strings containing quotes");
 290         ok(bt_field_type_enumeration_add_mapping_unsigned(enum_type_unsigned,
 291                 "\tanother \'escaping\'\n test\"", 1, 4) == 0,
 292                 "bt_field_type_enumeration_add_mapping_unsigned accepts enumeration mapping strings containing special characters");
 293         ok(bt_field_type_enumeration_add_mapping_unsigned(enum_type_unsigned,
 294                 "event clock int float", 5, 22) == 0,
 295                 "bt_field_type_enumeration_add_mapping_unsigned accepts enumeration mapping strings containing reserved keywords");
 296         ok(bt_field_type_enumeration_add_mapping_unsigned(enum_type_unsigned, mapping_name_test,
 297                 42, 42) == 0, "bt_field_type_enumeration_add_mapping_unsigned accepts single-value ranges");
 298         ok(bt_field_type_enumeration_add_mapping_unsigned(enum_type_unsigned, mapping_name_test,
 299                 43, 51) == 0, "bt_field_type_enumeration_add_mapping_unsigned accepts duplicate mapping names");
 300         ok(bt_field_type_enumeration_add_mapping_unsigned(enum_type_unsigned, "something",
 301                 7, 8) == 0, "bt_field_type_enumeration_add_mapping_unsigned accepts overlapping enum entries");
 302         ok(bt_field_type_enumeration_add_mapping_unsigned(enum_type_unsigned, mapping_name_test,
 303                 55, 54), "bt_field_type_enumeration_add_mapping_unsigned rejects mapping where end < start");
 304         ok(bt_event_class_add_field(simple_event_class, enum_type_unsigned,
 305                 "enum_field_unsigned") == 0, "Add unsigned enumeration field to event");
 306
 307         ok(bt_field_type_enumeration_get_mapping_count(NULL) < 0,
 308                 "bt_field_type_enumeration_get_mapping_count handles NULL correctly");
 309         ok(bt_field_type_enumeration_get_mapping_count(enum_type_unsigned) == 6,
 310                 "bt_field_type_enumeration_get_mapping_count returns the correct value");
 311
 312         ok(bt_field_type_enumeration_get_mapping_unsigned(NULL, 0, &ret_char,
 313                 &ret_range_start_uint64_t, &ret_range_end_uint64_t) < 0,
 314                 "bt_field_type_enumeration_get_mapping_unsigned handles a NULL enumeration correctly");
 315         ok(bt_field_type_enumeration_get_mapping_unsigned(enum_type_unsigned, 0, NULL,
 316                 &ret_range_start_uint64_t, &ret_range_end_uint64_t) == 0,
 317                 "bt_field_type_enumeration_get_mapping_unsigned handles a NULL string correctly");
 318         ok(bt_field_type_enumeration_get_mapping_unsigned(enum_type_unsigned, 0, &ret_char,
 319                 NULL, &ret_range_end_uint64_t) == 0,
 320                 "bt_field_type_enumeration_get_mapping_unsigned handles a NULL start correctly");
 321         ok(bt_field_type_enumeration_get_mapping_unsigned(enum_type_unsigned, 0, &ret_char,
 322                 &ret_range_start_uint64_t, NULL) == 0,
 323                 "bt_field_type_enumeration_get_mapping_unsigned handles a NULL end correctly");
 324         ok(bt_field_type_enumeration_get_mapping_unsigned(enum_type_unsigned, 4, &ret_char,
 325                 &ret_range_start_uint64_t, &ret_range_end_uint64_t) == 0,
 326                 "bt_field_type_enumeration_get_mapping_unsigned returns a value");
 327         ok(!strcmp(ret_char, mapping_name_test),
 328                 "bt_field_type_enumeration_get_mapping_unsigned returns a correct mapping name");
 329         ok(ret_range_start_uint64_t == 42,
 330                 "bt_field_type_enumeration_get_mapping_unsigned returns a correct mapping start");
 331         ok(ret_range_end_uint64_t == 42,
 332                 "bt_field_type_enumeration_get_mapping_unsigned returns a correct mapping end");
 333
 334         bt_event_class_add_field(simple_event_class, uint_12_type,
 335                 "integer_field");
 336         bt_event_class_add_field(simple_event_class, float_type,
 337                 "float_field");
 338
 339         assert(!bt_event_class_set_id(simple_event_class, 13));
 340
 341         /* Set an event context type which will contain a single integer. */
 342         ok(!bt_field_type_structure_add_field(event_context_type, uint_12_type,
 343                 "event_specific_context"),
 344                 "Add event specific context field");
 345         ok(bt_event_class_get_context_type(NULL) == NULL,
 346                 "bt_event_class_get_context_type handles NULL correctly");
 347
 348         ok(bt_event_class_set_context_type(NULL, event_context_type) < 0,
 349                 "bt_event_class_set_context_type handles a NULL event class correctly");
 350         ok(!bt_event_class_set_context_type(simple_event_class, event_context_type),
 351                 "Set an event class' context type successfully");
 352         returned_type = bt_event_class_get_context_type(simple_event_class);
 353         ok(returned_type == event_context_type,
 354                 "bt_event_class_get_context_type returns the appropriate type");
 355         bt_put(returned_type);
 356
 357         ok(!bt_stream_class_add_event_class(stream_class, simple_event_class),
 358                 "Adding simple event class to stream class");
 359
 360         /*
 361          * bt_stream_class_add_event_class() copies the field types
 362          * of simple_event_class, so we retrieve the new ones to create
 363          * the appropriate fields.
 364          */
 365         BT_PUT(event_context_type);
 366         BT_PUT(event_payload_type);
 367         event_payload_type = bt_event_class_get_payload_type(
 368                 simple_event_class);
 369         assert(event_payload_type);
 370         event_context_type = bt_event_class_get_context_type(
 371                 simple_event_class);
 372         assert(event_context_type);
 373         ep_integer_field_type =
 374                 bt_field_type_structure_get_field_type_by_name(
 375                         event_payload_type, "integer_field");
 376         assert(ep_integer_field_type);
 377         ep_enum_field_type =
 378                 bt_field_type_structure_get_field_type_by_name(
 379                         event_payload_type, "enum_field");
 380         assert(ep_enum_field_type);
 381         ep_enum_field_unsigned_type =
 382                 bt_field_type_structure_get_field_type_by_name(
 383                         event_payload_type, "enum_field_unsigned");
 384         assert(ep_enum_field_unsigned_type);
 385
 386         ok(bt_stream_class_get_event_class_count(NULL) < 0,
 387                 "bt_stream_class_get_event_class_count handles NULL correctly");
 388         ok(bt_stream_class_get_event_class_count(stream_class) == 1,
 389                 "bt_stream_class_get_event_class_count returns a correct number of event classes");
 390         ok(bt_stream_class_get_event_class_by_index(NULL, 0) == NULL,
 391                 "bt_stream_class_get_event_class handles NULL correctly");
 392         ok(bt_stream_class_get_event_class_by_index(stream_class, 8724) == NULL,
 393                 "bt_stream_class_get_event_class handles invalid indexes correctly");
 394         ret_event_class = bt_stream_class_get_event_class_by_index(stream_class, 0);
 395         ok(ret_event_class == simple_event_class,
 396                 "bt_stream_class_get_event_class returns the correct event class");
 397         bt_put(ret_event_class);
 398         ok(!bt_stream_class_get_event_class_by_id(NULL, 0),
 399                 "bt_stream_class_get_event_class_by_id handles NULL correctly");
 400         ok(!bt_stream_class_get_event_class_by_id(stream_class, 2),
 401                 "bt_stream_class_get_event_class_by_id returns NULL when the requested ID doesn't exist");
 402         ret_event_class =
 403                 bt_stream_class_get_event_class_by_id(stream_class, 13);
 404         ok(ret_event_class == simple_event_class,
 405                 "bt_stream_class_get_event_class_by_id returns a correct event class");
 406         bt_put(ret_event_class);
 407
 408         simple_event = bt_event_create(simple_event_class);
 409         ok(simple_event,
 410                 "Instantiate an event containing a single integer field");
 411
 412         integer_field = bt_field_create(ep_integer_field_type);
 413         bt_field_unsigned_integer_set_value(integer_field, 42);
 414         ok(bt_event_set_payload(simple_event, "integer_field",
 415                 integer_field) == 0, "Use bt_event_set_payload to set a manually allocated field");
 416
 417         float_field = bt_event_get_payload(simple_event, "float_field");
 418         bt_field_floating_point_set_value(float_field, double_test_value);
 419         ok(!bt_field_floating_point_get_value(float_field, &ret_double),
 420                 "bt_field_floating_point_get_value returns a double value");
 421         ok(fabs(ret_double - double_test_value) <= DBL_EPSILON,
 422                 "bt_field_floating_point_get_value returns a correct value");
 423
 424         enum_field = bt_field_create(ep_enum_field_type);
 425         assert(enum_field);
 426
 427         enum_container_field = bt_field_enumeration_get_container(enum_field);
 428         ok(bt_field_signed_integer_set_value(
 429                 enum_container_field, -42) == 0,
 430                 "Set signed enumeration container value");
 431         iter = bt_field_enumeration_get_mappings(enum_field);
 432         ok(iter, "bt_field_enumeration_get_mappings returns an iterator to matching mappings");
 433         ret = bt_field_type_enumeration_mapping_iterator_next(iter);
 434         ok(!ret, "bt_field_enumeration_get_mappings returned a non-empty match");
 435         ret = bt_field_type_enumeration_mapping_iterator_get_signed(iter, &ret_char, NULL, NULL);
 436         ok(!ret && ret_char, "bt_field_type_enumeration_mapping_iterator_get_signed return a mapping name");
 437         assert(ret_char);
 438         ok(!strcmp(ret_char, mapping_name_negative_test),
 439                 "bt_field_enumeration_get_single_mapping_name returns the correct mapping name with an signed container");
 440         ret = bt_event_set_payload(simple_event, "enum_field", enum_field);
 441         assert(!ret);
 442         BT_PUT(iter);
 443
 444         enum_field_unsigned = bt_field_create(ep_enum_field_unsigned_type);
 445         assert(enum_field_unsigned);
 446         enum_container_field_unsigned = bt_field_enumeration_get_container(
 447                 enum_field_unsigned);
 448         ok(bt_field_unsigned_integer_set_value(
 449                 enum_container_field_unsigned, 42) == 0,
 450                 "Set unsigned enumeration container value");
 451         ret = bt_event_set_payload(simple_event, "enum_field_unsigned",
 452                 enum_field_unsigned);
 453         assert(!ret);
 454         iter = bt_field_enumeration_get_mappings(enum_field_unsigned);
 455         assert(iter);
 456         ret = bt_field_type_enumeration_mapping_iterator_next(iter);
 457         assert(!ret);
 458         (void) bt_field_type_enumeration_mapping_iterator_get_unsigned(iter, &ret_char, NULL, NULL);
 459         ok(ret_char && !strcmp(ret_char, mapping_name_test),
 460                 "bt_field_type_enumeration_mapping_iterator_get_unsigned returns the correct mapping name with an unsigned container");
 461
 462         ok(bt_ctf_clock_set_time(clock, current_time) == 0, "Set clock time");
 463
 464         /* Populate stream event context */
 465         stream_event_context =
 466                 bt_event_get_stream_event_context(simple_event);
 467         assert(stream_event_context);
 468         stream_event_context_field = bt_field_structure_get_field_by_name(
 469                 stream_event_context, "common_event_context");
 470         bt_field_unsigned_integer_set_value(stream_event_context_field, 42);
 471
 472         /* Populate the event's context */
 473         event_context = bt_event_get_event_context(simple_event);
 474         ok(event_context,
 475                 "bt_event_get_event_context returns a field");
 476         returned_type = bt_field_get_type(event_context);
 477         ok(returned_type == event_context_type,
 478                 "bt_event_get_event_context returns a field of the appropriate type");
 479         event_context_field = bt_field_structure_get_field_by_name(event_context,
 480                 "event_specific_context");
 481         ok(!bt_field_unsigned_integer_set_value(event_context_field, 1234),
 482                 "Successfully set an event context's value");
 483         ok(!bt_event_set_event_context(simple_event, event_context),
 484                 "Set an event context successfully");
 485
 486         ok(bt_stream_append_event(stream, simple_event) == 0,
 487                 "Append simple event to trace stream");
 488
 489         packet_context = bt_stream_get_packet_context(stream);
 490         ok(packet_context,
 491                 "bt_stream_get_packet_context returns a packet context");
 492
 493         packet_context_field = bt_field_structure_get_field_by_name(packet_context,
 494                 "packet_size");
 495         ok(packet_context_field,
 496                 "Packet context contains the default packet_size field.");
 497         bt_put(packet_context_field);
 498         packet_context_field = bt_field_structure_get_field_by_name(packet_context,
 499                 "custom_packet_context_field");
 500         ok(bt_field_unsigned_integer_set_value(packet_context_field, 8) == 0,
 501                 "Custom packet context field value successfully set.");
 502
 503         ok(bt_stream_set_packet_context(stream, packet_context) == 0,
 504                 "Successfully set a stream's packet context");
 505
 506         ok(bt_stream_flush(stream) == 0,
 507                 "Flush trace stream with one event");
 508
 509         bt_put(simple_event_class);
 510         bt_put(simple_event);
 511         bt_put(uint_12_type);
 512         bt_put(int_64_type);
 513         bt_put(float_type);
 514         bt_put(enum_type);
 515         bt_put(enum_type_unsigned);
 516         bt_put(returned_type);
 517         bt_put(event_context_type);
 518         bt_put(integer_field);
 519         bt_put(float_field);
 520         bt_put(enum_field);
 521         bt_put(enum_field_unsigned);
 522         bt_put(enum_container_field);
 523         bt_put(enum_container_field_unsigned);
 524         bt_put(packet_context);
 525         bt_put(packet_context_field);
 526         bt_put(stream_event_context);
 527         bt_put(stream_event_context_field);
 528         bt_put(event_context);
 529         bt_put(event_context_field);
 530         bt_put(event_payload_type);
 531         bt_put(ep_integer_field_type);
 532         bt_put(ep_enum_field_type);
 533         bt_put(ep_enum_field_unsigned_type);
 534         bt_put(iter);
 535 }
 536
 537 static
 538 void append_complex_event(struct bt_stream_class *stream_class,
 539                 struct bt_stream *stream, struct bt_ctf_clock *clock)
 540 {
 541         int i, ret;
 542         struct event_class_attrs_counts ;
 543         const char *complex_test_event_string = "Complex Test Event";
 544         const char *test_string_1 = "Test ";
 545         const char *test_string_2 = "string ";
 546         const char *test_string_3 = "abcdefghi";
 547         const char *test_string_4 = "abcd\0efg\0hi";
 548         const char *test_string_cat = "Test string abcdeefg";
 549         struct bt_field_type *uint_35_type =
 550                 bt_field_type_integer_create(35);
 551         struct bt_field_type *int_16_type =
 552                 bt_field_type_integer_create(16);
 553         struct bt_field_type *uint_3_type =
 554                 bt_field_type_integer_create(3);
 555         struct bt_field_type *enum_variant_type =
 556                 bt_field_type_enumeration_create(uint_3_type);
 557         struct bt_field_type *variant_type =
 558                 bt_field_type_variant_create(enum_variant_type,
 559                         "variant_selector");
 560         struct bt_field_type *string_type =
 561                 bt_field_type_string_create();
 562         struct bt_field_type *sequence_type;
 563         struct bt_field_type *array_type;
 564         struct bt_field_type *inner_structure_type =
 565                 bt_field_type_structure_create();
 566         struct bt_field_type *complex_structure_type =
 567                 bt_field_type_structure_create();
 568         struct bt_field_type *ret_field_type;
 569         struct bt_event_class *event_class;
 570         struct bt_event *event;
 571         struct bt_field *uint_35_field, *int_16_field, *a_string_field,
 572                 *inner_structure_field, *complex_structure_field,
 573                 *a_sequence_field, *enum_variant_field, *enum_container_field,
 574                 *variant_field, *an_array_field, *stream_event_ctx_field,
 575                 *stream_event_ctx_int_field, *ret_field;
 576         uint64_t ret_unsigned_int;
 577         int64_t ret_signed_int;
 578         const char *ret_string;
 579         struct bt_stream_class *ret_stream_class;
 580         struct bt_event_class *ret_event_class;
 581         struct bt_field *packet_context, *packet_context_field;
 582         struct bt_field_type_enumeration_mapping_iterator *iter = NULL;
 583
 584         ok(bt_field_type_set_alignment(int_16_type, 0),
 585                 "bt_field_type_set_alignment handles 0-alignment correctly");
 586         ok(bt_field_type_set_alignment(int_16_type, 3),
 587                 "bt_field_type_set_alignment handles wrong alignment correctly (3)");
 588         ok(bt_field_type_set_alignment(int_16_type, 24),
 589                 "bt_field_type_set_alignment handles wrong alignment correctly (24)");
 590         ok(!bt_field_type_set_alignment(int_16_type, 4),
 591                 "bt_field_type_set_alignment handles correct alignment correctly (4)");
 592         ok(!bt_field_type_set_alignment(int_16_type, 32),
 593                 "Set alignment of signed 16 bit integer to 32");
 594         ok(!bt_ctf_field_type_integer_set_signed(int_16_type, 1),
 595                 "Set integer signedness to true");
 596         ok(!bt_field_type_integer_set_base(uint_35_type,
 597                 BT_INTEGER_BASE_HEXADECIMAL),
 598                 "Set signed 16 bit integer base to hexadecimal");
 599
 600         array_type = bt_field_type_array_create(int_16_type, ARRAY_TEST_LENGTH);
 601         sequence_type = bt_field_type_sequence_create(int_16_type,
 602                 "seq_len");
 603
 604         ok(bt_field_type_array_get_element_type(NULL) == NULL,
 605                 "bt_field_type_array_get_element_type handles NULL correctly");
 606         ret_field_type = bt_field_type_array_get_element_type(
 607                 array_type);
 608         ok(ret_field_type == int_16_type,
 609                 "bt_field_type_array_get_element_type returns the correct type");
 610         bt_put(ret_field_type);
 611
 612         ok(bt_field_type_array_get_length(NULL) < 0,
 613                 "bt_field_type_array_get_length handles NULL correctly");
 614         ok(bt_field_type_array_get_length(array_type) == ARRAY_TEST_LENGTH,
 615                 "bt_field_type_array_get_length returns the correct length");
 616
 617         ok(bt_field_type_structure_add_field(inner_structure_type,
 618                 inner_structure_type, "yes"), "Cannot add self to structure");
 619         ok(!bt_field_type_structure_add_field(inner_structure_type,
 620                 uint_35_type, "seq_len"), "Add seq_len field to inner structure");
 621         ok(!bt_field_type_structure_add_field(inner_structure_type,
 622                 sequence_type, "a_sequence"), "Add a_sequence field to inner structure");
 623         ok(!bt_field_type_structure_add_field(inner_structure_type,
 624                 array_type, "an_array"), "Add an_array field to inner structure");
 625
 626         bt_ctf_field_type_enumeration_add_mapping(enum_variant_type,
 627                 "UINT3_TYPE", 0, 0);
 628         bt_ctf_field_type_enumeration_add_mapping(enum_variant_type,
 629                 "INT16_TYPE", 1, 1);
 630         bt_ctf_field_type_enumeration_add_mapping(enum_variant_type,
 631                 "UINT35_TYPE", 2, 7);
 632
 633         iter = bt_field_type_enumeration_find_mappings_by_name(NULL, "INT16_TYPE");
 634         ok(iter == NULL, "bt_field_type_enumeration_find_mappings_by_name handles a NULL field type correctly");
 635
 636         iter = bt_field_type_enumeration_find_mappings_by_name(enum_variant_type, "INT16_TYPE");
 637         ok(iter != NULL, "bt_field_type_enumeration_find_mappings_by_name returns a non-NULL iterator");
 638         ret = bt_field_type_enumeration_mapping_iterator_next(iter);
 639         ok(!ret, "bt_field_type_enumeration_find_mappings_by_name handles an existing mapping correctly");
 640         ok(bt_field_type_enumeration_mapping_iterator_get_unsigned(iter, NULL, NULL, NULL) == 0,
 641                 "bt_field_type_enumeration_mapping_iterator_get_unsigned handles mapped values correctly");
 642         BT_PUT(iter);
 643
 644         iter = bt_field_type_enumeration_find_mappings_by_name(enum_variant_type, NULL);
 645         ret = bt_field_type_enumeration_mapping_iterator_next(iter);
 646         ok(iter && ret, "bt_field_type_enumeration_find_mappings_by_name handles a NULL name correctly");
 647         BT_PUT(iter);
 648
 649         iter = bt_field_type_enumeration_find_mappings_by_unsigned_value(NULL, 1);
 650         ok(iter == NULL, "bt_field_type_enumeration_find_mappings_by_unsigned_value handles a NULL field type correctly");
 651
 652         iter = bt_field_type_enumeration_find_mappings_by_unsigned_value(enum_variant_type, -42);
 653         ret = bt_field_type_enumeration_mapping_iterator_next(iter);
 654         ok(iter && ret, "bt_field_type_enumeration_find_mappings_by_unsigned_value handles invalid values correctly");
 655         ok(bt_field_type_enumeration_mapping_iterator_get_unsigned(iter, NULL, NULL, NULL) != 0,
 656                 "bt_field_type_enumeration_mapping_iterator_get_unsigned handles invalid values correctly");
 657         BT_PUT(iter);
 658
 659         iter = bt_field_type_enumeration_find_mappings_by_unsigned_value(enum_variant_type, 5);
 660         ret = bt_field_type_enumeration_mapping_iterator_next(iter);
 661         ok(iter != NULL && !ret, "bt_field_type_enumeration_find_mappings_by_unsigned_value handles valid values correctly");
 662         ok(bt_field_type_enumeration_mapping_iterator_get_unsigned(iter, NULL, NULL, NULL) == 0,
 663                 "bt_field_type_enumeration_mapping_iterator_get_unsigned handles valid values correctly");
 664         BT_PUT(iter);
 665
 666         ok(bt_field_type_variant_add_field(variant_type, uint_3_type,
 667                 "An unknown entry"), "Reject a variant field based on an unknown tag value");
 668         ok(bt_field_type_variant_add_field(variant_type, uint_3_type,
 669                 "UINT3_TYPE") == 0, "Add a field to a variant");
 670         ok(!bt_field_type_variant_add_field(variant_type, int_16_type,
 671                 "INT16_TYPE"), "Add INT16_TYPE field to variant");
 672         ok(!bt_field_type_variant_add_field(variant_type, uint_35_type,
 673                 "UINT35_TYPE"), "Add UINT35_TYPE field to variant");
 674
 675         ok(bt_field_type_variant_get_tag_type(NULL) == NULL,
 676                 "bt_field_type_variant_get_tag_type handles NULL correctly");
 677         ret_field_type = bt_field_type_variant_get_tag_type(variant_type);
 678         ok(ret_field_type == enum_variant_type,
 679                 "bt_field_type_variant_get_tag_type returns a correct tag type");
 680         bt_put(ret_field_type);
 681
 682         ok(bt_field_type_variant_get_tag_name(NULL) == NULL,
 683                 "bt_field_type_variant_get_tag_name handles NULL correctly");
 684         ret_string = bt_field_type_variant_get_tag_name(variant_type);
 685         ok(ret_string ? !strcmp(ret_string, "variant_selector") : 0,
 686                 "bt_field_type_variant_get_tag_name returns the correct variant tag name");
 687         ok(bt_field_type_variant_get_field_type_by_name(NULL,
 688                 "INT16_TYPE") == NULL,
 689                 "bt_field_type_variant_get_field_type_by_name handles a NULL variant_type correctly");
 690         ok(bt_field_type_variant_get_field_type_by_name(variant_type,
 691                 NULL) == NULL,
 692                 "bt_field_type_variant_get_field_type_by_name handles a NULL field name correctly");
 693         ret_field_type = bt_field_type_variant_get_field_type_by_name(
 694                 variant_type, "INT16_TYPE");
 695         ok(ret_field_type == int_16_type,
 696                 "bt_field_type_variant_get_field_type_by_name returns a correct field type");
 697         bt_put(ret_field_type);
 698
 699         ok(bt_field_type_variant_get_field_count(NULL) < 0,
 700                 "bt_field_type_variant_get_field_count handles NULL correctly");
 701         ok(bt_field_type_variant_get_field_count(variant_type) == 3,
 702                 "bt_field_type_variant_get_field_count returns the correct count");
 703
 704         ok(bt_field_type_variant_get_field_by_index(NULL, &ret_string, &ret_field_type, 0) < 0,
 705                 "bt_field_type_variant_get_field handles a NULL type correctly");
 706         ok(bt_field_type_variant_get_field_by_index(variant_type, NULL, &ret_field_type, 0) == 0,
 707                 "bt_field_type_variant_get_field handles a NULL field name correctly");
 708         bt_put(ret_field_type);
 709         ok(bt_field_type_variant_get_field_by_index(variant_type, &ret_string, NULL, 0) == 0,
 710                 "bt_field_type_variant_get_field handles a NULL field type correctly");
 711         ok(bt_field_type_variant_get_field_by_index(variant_type, &ret_string, &ret_field_type, 200) < 0,
 712                 "bt_field_type_variant_get_field handles an invalid index correctly");
 713         ok(bt_field_type_variant_get_field_by_index(variant_type, &ret_string, &ret_field_type, 1) == 0,
 714                 "bt_field_type_variant_get_field returns a field");
 715         ok(!strcmp("INT16_TYPE", ret_string),
 716                 "bt_field_type_variant_get_field returns a correct field name");
 717         ok(ret_field_type == int_16_type,
 718                 "bt_field_type_variant_get_field returns a correct field type");
 719         bt_put(ret_field_type);
 720
 721         ok(!bt_field_type_structure_add_field(complex_structure_type,
 722                 enum_variant_type, "variant_selector"),
 723                 "Add variant_selector field to complex structure");
 724         ok(!bt_field_type_structure_add_field(complex_structure_type,
 725                 string_type, "string"), "Add `string` field to complex structure");
 726         ok(!bt_field_type_structure_add_field(complex_structure_type,
 727                 variant_type, "variant_value"),
 728                 "Add variant_value field to complex structure");
 729         ok(!bt_field_type_structure_add_field(complex_structure_type,
 730                 inner_structure_type, "inner_structure"),
 731                 "Add inner_structure field to complex structure");
 732
 733         event_class = bt_event_class_create(complex_test_event_string);
 734         ok(event_class, "Create an event class");
 735         ok(bt_event_class_add_field(event_class, uint_35_type, ""),
 736                 "Reject addition of a field with an empty name to an event");
 737         ok(bt_event_class_add_field(event_class, NULL, "an_integer"),
 738                 "Reject addition of a field with a NULL type to an event");
 739         ok(bt_event_class_add_field(event_class, uint_35_type,
 740                 "int"),
 741                 "Reject addition of a type with an illegal name to an event");
 742         ok(bt_event_class_add_field(event_class, uint_35_type,
 743                 "uint_35") == 0,
 744                 "Add field of type unsigned integer to an event");
 745         ok(bt_event_class_add_field(event_class, int_16_type,
 746                 "int_16") == 0, "Add field of type signed integer to an event");
 747         ok(bt_event_class_add_field(event_class, complex_structure_type,
 748                 "complex_structure") == 0,
 749                 "Add composite structure to an event");
 750
 751         ok(bt_event_class_get_name(NULL) == NULL,
 752                 "bt_event_class_get_name handles NULL correctly");
 753         ret_string = bt_event_class_get_name(event_class);
 754         ok(!strcmp(ret_string, complex_test_event_string),
 755                 "bt_event_class_get_name returns a correct name");
 756         ok(bt_event_class_get_id(event_class) < 0,
 757                 "bt_event_class_get_id returns a negative value when not set");
 758         ok(bt_event_class_get_id(NULL) < 0,
 759                 "bt_event_class_get_id handles NULL correctly");
 760         ok(bt_event_class_set_id(NULL, 42) < 0,
 761                 "bt_event_class_set_id handles NULL correctly");
 762         ok(bt_event_class_set_id(event_class, 42) == 0,
 763                 "Set an event class' id");
 764         ok(bt_event_class_get_id(event_class) == 42,
 765                 "bt_event_class_get_id returns the correct value");
 766
 767         /* Test event class attributes */
 768         ok(bt_event_class_get_log_level(event_class) == BT_EVENT_CLASS_LOG_LEVEL_UNSPECIFIED,
 769                 "event class has the expected initial log level");
 770         ok(!bt_event_class_get_emf_uri(event_class),
 771                 "as expected, event class has no initial EMF URI");
 772         ok(bt_event_class_set_log_level(NULL, BT_EVENT_CLASS_LOG_LEVEL_INFO),
 773                 "bt_event_class_set_log_level handles a NULL event class correctly");
 774         ok(bt_event_class_set_log_level(event_class, BT_EVENT_CLASS_LOG_LEVEL_UNKNOWN),
 775                 "bt_event_class_set_log_level handles an unknown log level correctly");
 776         ok(!bt_event_class_set_log_level(event_class, BT_EVENT_CLASS_LOG_LEVEL_INFO),
 777                 "bt_event_class_set_log_level succeeds with a valid log level");
 778         ok(bt_event_class_get_log_level(NULL) == BT_EVENT_CLASS_LOG_LEVEL_UNKNOWN,
 779                 "bt_event_class_get_log_level handles a NULL event class correctly");
 780         ok(bt_event_class_get_log_level(event_class) == BT_EVENT_CLASS_LOG_LEVEL_INFO,
 781                 "bt_event_class_get_log_level returns the expected log level");
 782         ok(bt_event_class_set_emf_uri(NULL, "http://diamon.org/babeltrace/"),
 783                 "bt_event_class_set_emf_uri handles a NULL event class correctly");
 784         ok(!bt_event_class_set_emf_uri(event_class, "http://diamon.org/babeltrace/"),
 785                 "bt_event_class_set_emf_uri succeeds with a valid EMF URI");
 786         ok(!bt_event_class_get_emf_uri(NULL),
 787                 "bt_event_class_get_emf_uri handles a NULL event class correctly");
 788         ok(strcmp(bt_event_class_get_emf_uri(event_class), "http://diamon.org/babeltrace/") == 0,
 789                 "bt_event_class_get_emf_uri returns the expected EMF URI");
 790         ok(!bt_event_class_set_emf_uri(event_class, NULL),
 791                 "bt_event_class_set_emf_uri succeeds with NULL (to reset)");
 792         ok(!bt_event_class_get_emf_uri(event_class),
 793                 "as expected, event class has no EMF URI after reset");
 794
 795         /* Add event class to the stream class */
 796         ok(bt_stream_class_add_event_class(stream_class, NULL),
 797                 "Reject addition of NULL event class to a stream class");
 798         ok(bt_stream_class_add_event_class(stream_class,
 799                 event_class) == 0, "Add an event class to stream class");
 800
 801         ok(bt_event_class_get_stream_class(NULL) == NULL,
 802                 "bt_event_class_get_stream_class handles NULL correctly");
 803         ret_stream_class = bt_event_class_get_stream_class(event_class);
 804         ok(ret_stream_class == stream_class,
 805                 "bt_event_class_get_stream_class returns the correct stream class");
 806         bt_put(ret_stream_class);
 807
 808         ok(bt_event_class_get_payload_type_field_count(NULL) < 0,
 809                 "bt_event_class_get_field_count handles NULL correctly");
 810         ok(bt_event_class_get_payload_type_field_count(event_class) == 3,
 811                 "bt_event_class_get_field_count returns a correct value");
 812
 813         ok(bt_event_class_get_payload_type_field_by_index(NULL, &ret_string,
 814                 &ret_field_type, 0) < 0,
 815                 "bt_event_class_get_field handles a NULL event class correctly");
 816         ok(bt_event_class_get_payload_type_field_by_index(event_class, NULL,
 817                 &ret_field_type, 0) == 0,
 818                 "bt_event_class_get_field handles a NULL field name correctly");
 819         bt_put(ret_field_type);
 820         ok(bt_event_class_get_payload_type_field_by_index(event_class, &ret_string,
 821                 NULL, 0) == 0,
 822                 "bt_event_class_get_field handles a NULL field type correctly");
 823         ok(bt_event_class_get_payload_type_field_by_index(event_class, &ret_string,
 824                 &ret_field_type, 42) < 0,
 825                 "bt_event_class_get_field handles an invalid index correctly");
 826         ok(bt_event_class_get_payload_type_field_by_index(event_class, &ret_string,
 827                 &ret_field_type, 0) == 0,
 828                 "bt_event_class_get_field returns a field");
 829         ok(bt_field_type_compare(ret_field_type, uint_35_type) == 0,
 830                 "bt_event_class_get_field returns a correct field type");
 831         bt_put(ret_field_type);
 832         ok(!strcmp(ret_string, "uint_35"),
 833                 "bt_event_class_get_field returns a correct field name");
 834         ok(bt_ctf_event_class_get_field_by_name(NULL, "") == NULL,
 835                 "bt_event_class_get_field_by_name handles a NULL event class correctly");
 836         ok(bt_ctf_event_class_get_field_by_name(event_class, NULL) == NULL,
 837                 "bt_event_class_get_field_by_name handles a NULL field name correctly");
 838         ok(bt_ctf_event_class_get_field_by_name(event_class, "truie") == NULL,
 839                 "bt_event_class_get_field_by_name handles an invalid field name correctly");
 840         ret_field_type = bt_ctf_event_class_get_field_by_name(event_class,
 841                 "complex_structure");
 842         ok(bt_field_type_compare(ret_field_type, complex_structure_type) == 0,
 843                 "bt_event_class_get_field_by_name returns a correct field type");
 844         bt_put(ret_field_type);
 845
 846         event = bt_event_create(event_class);
 847         ok(event, "Instanciate a complex event");
 848
 849         ret_event_class = bt_event_get_class(event);
 850         ok(ret_event_class == event_class,
 851                 "bt_event_get_class returns the correct event class");
 852         bt_put(ret_event_class);
 853
 854         uint_35_field = bt_event_get_payload(event, "uint_35");
 855         ok(uint_35_field, "Use bt_event_get_payload to get a field instance ");
 856         bt_field_unsigned_integer_set_value(uint_35_field, 0x0DDF00D);
 857         ok(bt_field_unsigned_integer_get_value(uint_35_field,
 858                 &ret_unsigned_int) == 0,
 859                 "bt_field_unsigned_integer_get_value succeeds after setting a value");
 860         ok(ret_unsigned_int == 0x0DDF00D,
 861                 "bt_field_unsigned_integer_get_value returns the correct value");
 862         bt_put(uint_35_field);
 863
 864         int_16_field = bt_event_get_payload(event, "int_16");
 865         bt_field_signed_integer_set_value(int_16_field, -12345);
 866         ok(bt_field_signed_integer_get_value(int_16_field,
 867                 &ret_signed_int) == 0,
 868                 "bt_field_signed_integer_get_value succeeds after setting a value");
 869         ok(ret_signed_int == -12345,
 870                 "bt_field_signed_integer_get_value returns the correct value");
 871         bt_put(int_16_field);
 872
 873         complex_structure_field = bt_event_get_payload(event,
 874                 "complex_structure");
 875
 876         inner_structure_field = bt_field_structure_get_field_by_index(
 877                 complex_structure_field, 3);
 878         ret_field_type = bt_field_get_type(inner_structure_field);
 879         bt_put(inner_structure_field);
 880         ok(bt_field_type_compare(ret_field_type, inner_structure_type) == 0,
 881                 "bt_field_structure_get_field_by_index returns a correct field");
 882         bt_put(ret_field_type);
 883
 884         inner_structure_field = bt_field_structure_get_field_by_name(
 885                 complex_structure_field, "inner_structure");
 886         a_string_field = bt_field_structure_get_field_by_name(
 887                 complex_structure_field, "string");
 888         enum_variant_field = bt_field_structure_get_field_by_name(
 889                 complex_structure_field, "variant_selector");
 890         variant_field = bt_field_structure_get_field_by_name(
 891                 complex_structure_field, "variant_value");
 892         uint_35_field = bt_field_structure_get_field_by_name(
 893                 inner_structure_field, "seq_len");
 894         a_sequence_field = bt_field_structure_get_field_by_name(
 895                 inner_structure_field, "a_sequence");
 896         an_array_field = bt_field_structure_get_field_by_name(
 897                 inner_structure_field, "an_array");
 898
 899         enum_container_field = bt_field_enumeration_get_container(
 900                 enum_variant_field);
 901         bt_field_unsigned_integer_set_value(enum_container_field, 1);
 902         int_16_field = bt_field_variant_get_field(variant_field,
 903                 enum_variant_field);
 904         bt_field_signed_integer_set_value(int_16_field, -200);
 905         bt_put(int_16_field);
 906         bt_field_string_set_value(a_string_field,
 907                 test_string_1);
 908         ok(!bt_field_string_append(a_string_field, test_string_2),
 909                 "bt_field_string_append succeeds");
 910         ok(!bt_field_string_append_len(a_string_field, test_string_3, 5),
 911                 "bt_field_string_append_len succeeds (append 5 characters)");
 912         ok(!bt_field_string_append_len(a_string_field, &test_string_4[5], 3),
 913                 "bt_field_string_append_len succeeds (append 0 characters)");
 914         ok(!bt_field_string_append_len(a_string_field, test_string_3, 0),
 915                 "bt_field_string_append_len succeeds (append 0 characters)");
 916
 917         ret_string = bt_field_string_get_value(a_string_field);
 918         ok(ret_string, "bt_field_string_get_value returns a string");
 919         ok(ret_string ? !strcmp(ret_string, test_string_cat) : 0,
 920                 "bt_field_string_get_value returns a correct value");
 921         bt_field_unsigned_integer_set_value(uint_35_field,
 922                 SEQUENCE_TEST_LENGTH);
 923
 924         ret_field_type = bt_field_type_variant_get_field_type_from_tag(
 925                 variant_type, enum_variant_field);
 926         ok(ret_field_type == int_16_type,
 927                 "bt_field_type_variant_get_field_type_from_tag returns the correct field type");
 928
 929         ok(bt_field_sequence_set_length(a_sequence_field,
 930                 uint_35_field) == 0, "Set a sequence field's length");
 931         ret_field = bt_field_sequence_get_length(a_sequence_field);
 932         ok(ret_field == uint_35_field,
 933                 "bt_field_sequence_get_length returns the correct length field");
 934
 935         for (i = 0; i < SEQUENCE_TEST_LENGTH; i++) {
 936                 int_16_field = bt_field_sequence_get_field(
 937                         a_sequence_field, i);
 938                 bt_field_signed_integer_set_value(int_16_field, 4 - i);
 939                 bt_put(int_16_field);
 940         }
 941
 942         for (i = 0; i < ARRAY_TEST_LENGTH; i++) {
 943                 int_16_field = bt_field_array_get_field(
 944                         an_array_field, i);
 945                 bt_field_signed_integer_set_value(int_16_field, i);
 946                 bt_put(int_16_field);
 947         }
 948
 949         stream_event_ctx_field = bt_event_get_stream_event_context(event);
 950         assert(stream_event_ctx_field);
 951         stream_event_ctx_int_field = bt_field_structure_get_field_by_name(
 952                 stream_event_ctx_field, "common_event_context");
 953         BT_PUT(stream_event_ctx_field);
 954         bt_field_unsigned_integer_set_value(stream_event_ctx_int_field, 17);
 955         BT_PUT(stream_event_ctx_int_field);
 956
 957         bt_ctf_clock_set_time(clock, ++current_time);
 958         ok(bt_stream_append_event(stream, event) == 0,
 959                 "Append a complex event to a stream");
 960
 961         /*
 962          * Populate the custom packet context field with a dummy value
 963          * otherwise flush will fail.
 964          */
 965         packet_context = bt_stream_get_packet_context(stream);
 966         packet_context_field = bt_field_structure_get_field_by_name(packet_context,
 967                 "custom_packet_context_field");
 968         bt_field_unsigned_integer_set_value(packet_context_field, 1);
 969
 970         ok(bt_stream_flush(stream) == 0,
 971                 "Flush a stream containing a complex event");
 972
 973         bt_put(uint_35_field);
 974         bt_put(a_string_field);
 975         bt_put(inner_structure_field);
 976         bt_put(complex_structure_field);
 977         bt_put(a_sequence_field);
 978         bt_put(an_array_field);
 979         bt_put(enum_variant_field);
 980         bt_put(enum_container_field);
 981         bt_put(variant_field);
 982         bt_put(ret_field);
 983         bt_put(packet_context_field);
 984         bt_put(packet_context);
 985         bt_put(uint_35_type);
 986         bt_put(int_16_type);
 987         bt_put(string_type);
 988         bt_put(sequence_type);
 989         bt_put(array_type);
 990         bt_put(inner_structure_type);
 991         bt_put(complex_structure_type);
 992         bt_put(uint_3_type);
 993         bt_put(enum_variant_type);
 994         bt_put(variant_type);
 995         bt_put(ret_field_type);
 996         bt_put(event_class);
 997         bt_put(event);
 998 }
 999
1000 static
1001 void field_copy_tests_validate_same_type(struct bt_field *field,
1002                 struct bt_field_type *expected_type, const char *name)
1003 {
1004         struct bt_field_type *copy_type;
1005
1006         copy_type = bt_field_get_type(field);
1007         ok(copy_type == expected_type,
1008                 "bt_field_copy does not copy the type (%s)", name);
1009         bt_put(copy_type);
1010 }
1011
1012 static
1013 void field_copy_tests_validate_diff_ptrs(struct bt_field *field_a,
1014                 struct bt_field *field_b, const char *name)
1015 {
1016         ok(field_a != field_b,
1017                 "bt_field_copy creates different pointers (%s)", name);
1018 }
1019
1020 static
1021 void field_copy_tests()
1022 {
1023         struct bt_field_type *len_type = NULL;
1024         struct bt_field_type *fp_type = NULL;
1025         struct bt_field_type *s_type = NULL;
1026         struct bt_field_type *e_int_type = NULL;
1027         struct bt_field_type *e_type = NULL;
1028         struct bt_field_type *v_type = NULL;
1029         struct bt_field_type *v_label1_type = NULL;
1030         struct bt_field_type *v_label1_array_type = NULL;
1031         struct bt_field_type *v_label2_type = NULL;
1032         struct bt_field_type *v_label2_seq_type = NULL;
1033         struct bt_field_type *strct_type = NULL;
1034         struct bt_field *len = NULL;
1035         struct bt_field *fp = NULL;
1036         struct bt_field *s = NULL;
1037         struct bt_field *e_int = NULL;
1038         struct bt_field *e = NULL;
1039         struct bt_field *v = NULL;
1040         struct bt_field *v_selected = NULL;
1041         struct bt_field *v_selected_cur = NULL;
1042         struct bt_field *v_selected_0 = NULL;
1043         struct bt_field *v_selected_1 = NULL;
1044         struct bt_field *v_selected_2 = NULL;
1045         struct bt_field *v_selected_3 = NULL;
1046         struct bt_field *v_selected_4 = NULL;
1047         struct bt_field *v_selected_5 = NULL;
1048         struct bt_field *v_selected_6 = NULL;
1049         struct bt_field *a = NULL;
1050         struct bt_field *a_0 = NULL;
1051         struct bt_field *a_1 = NULL;
1052         struct bt_field *a_2 = NULL;
1053         struct bt_field *a_3 = NULL;
1054         struct bt_field *a_4 = NULL;
1055         struct bt_field *strct = NULL;
1056         struct bt_field *len_copy = NULL;
1057         struct bt_field *fp_copy = NULL;
1058         struct bt_field *s_copy = NULL;
1059         struct bt_field *e_int_copy = NULL;
1060         struct bt_field *e_copy = NULL;
1061         struct bt_field *v_copy = NULL;
1062         struct bt_field *v_selected_copy = NULL;
1063         struct bt_field *v_selected_copy_len = NULL;
1064         struct bt_field *v_selected_0_copy = NULL;
1065         struct bt_field *v_selected_1_copy = NULL;
1066         struct bt_field *v_selected_2_copy = NULL;
1067         struct bt_field *v_selected_3_copy = NULL;
1068         struct bt_field *v_selected_4_copy = NULL;
1069         struct bt_field *v_selected_5_copy = NULL;
1070         struct bt_field *v_selected_6_copy = NULL;
1071         struct bt_field *a_copy = NULL;
1072         struct bt_field *a_0_copy = NULL;
1073         struct bt_field *a_1_copy = NULL;
1074         struct bt_field *a_2_copy = NULL;
1075         struct bt_field *a_3_copy = NULL;
1076         struct bt_field *a_4_copy = NULL;
1077         struct bt_field *strct_copy = NULL;
1078         struct bt_field_type_enumeration_mapping_iterator *e_iter = NULL;
1079         uint64_t uint64_t_val;
1080         const char *str_val;
1081         double double_val;
1082         int ret;
1083
1084         /* create len type */
1085         len_type = bt_field_type_integer_create(32);
1086         assert(len_type);
1087
1088         /* create fp type */
1089         fp_type = bt_field_type_floating_point_create();
1090         assert(fp_type);
1091
1092         /* create s type */
1093         s_type = bt_field_type_string_create();
1094         assert(s_type);
1095
1096         /* create e_int type */
1097         e_int_type = bt_field_type_integer_create(8);
1098         assert(e_int_type);
1099
1100         /* create e type */
1101         e_type = bt_field_type_enumeration_create(e_int_type);
1102         assert(e_type);
1103         ret = bt_ctf_field_type_enumeration_add_mapping(e_type, "LABEL1",
1104                 10, 15);
1105         assert(!ret);
1106         ret = bt_ctf_field_type_enumeration_add_mapping(e_type, "LABEL2",
1107                 23, 23);
1108         assert(!ret);
1109
1110         /* create v_label1 type */
1111         v_label1_type = bt_field_type_string_create();
1112         assert(v_label1_type);
1113
1114         /* create v_label1_array type */
1115         v_label1_array_type = bt_field_type_array_create(v_label1_type, 5);
1116         assert(v_label1_array_type);
1117
1118         /* create v_label2 type */
1119         v_label2_type = bt_field_type_integer_create(16);
1120         assert(v_label2_type);
1121
1122         /* create v_label2_seq type */
1123         v_label2_seq_type = bt_field_type_sequence_create(v_label2_type,
1124                 "len");
1125         assert(v_label2_seq_type);
1126
1127         /* create v type */
1128         v_type = bt_field_type_variant_create(e_type, "e");
1129         assert(v_type);
1130         ret = bt_field_type_variant_add_field(v_type, v_label1_array_type,
1131                 "LABEL1");
1132         assert(!ret);
1133         ret = bt_field_type_variant_add_field(v_type, v_label2_seq_type,
1134                 "LABEL2");
1135         assert(!ret);
1136
1137         /* create strct type */
1138         strct_type = bt_field_type_structure_create();
1139         assert(strct_type);
1140         ret = bt_field_type_structure_add_field(strct_type, len_type,
1141                 "len");
1142         assert(!ret);
1143         ret = bt_field_type_structure_add_field(strct_type, fp_type, "fp");
1144         assert(!ret);
1145         ret = bt_field_type_structure_add_field(strct_type, s_type, "s");
1146         assert(!ret);
1147         ret = bt_field_type_structure_add_field(strct_type, e_type, "e");
1148         assert(!ret);
1149         ret = bt_field_type_structure_add_field(strct_type, v_type, "v");
1150         assert(!ret);
1151         ret = bt_field_type_structure_add_field(strct_type,
1152                 v_label1_array_type, "a");
1153         assert(!ret);
1154
1155         /* create strct */
1156         strct = bt_field_create(strct_type);
1157         assert(strct);
1158
1159         /* get len field */
1160         len = bt_field_structure_get_field_by_name(strct, "len");
1161         assert(len);
1162
1163         /* get fp field */
1164         fp = bt_field_structure_get_field_by_name(strct, "fp");
1165         assert(fp);
1166
1167         /* get s field */
1168         s = bt_field_structure_get_field_by_name(strct, "s");
1169         assert(s);
1170
1171         /* get e field */
1172         e = bt_field_structure_get_field_by_name(strct, "e");
1173         assert(e);
1174
1175         /* get e_int (underlying integer) */
1176         e_int = bt_field_enumeration_get_container(e);
1177         assert(e_int);
1178
1179         /* get v field */
1180         v = bt_field_structure_get_field_by_name(strct, "v");
1181         assert(v);
1182
1183         /* get a field */
1184         a = bt_field_structure_get_field_by_name(strct, "a");
1185         assert(a);
1186
1187         /* set len field */
1188         ret = bt_field_unsigned_integer_set_value(len, 7);
1189         assert(!ret);
1190
1191         /* set fp field */
1192         ret = bt_field_floating_point_set_value(fp, 3.14);
1193         assert(!ret);
1194
1195         /* set s field */
1196         ret = bt_field_string_set_value(s, "btbt");
1197         assert(!ret);
1198
1199         /* set e field (LABEL2) */
1200         ret = bt_field_unsigned_integer_set_value(e_int, 23);
1201         assert(!ret);
1202
1203         /* set v field */
1204         v_selected = bt_field_variant_get_field(v, e);
1205         assert(v_selected);
1206         v_selected_cur = bt_field_variant_get_current_field(v);
1207         ok(v_selected_cur == v_selected,
1208                 "bt_field_variant_get_current_field returns the current field");
1209         bt_put(v_selected_cur);
1210
1211         /* set selected v field */
1212         ret = bt_field_sequence_set_length(v_selected, len);
1213         assert(!ret);
1214         v_selected_0 = bt_field_sequence_get_field(v_selected, 0);
1215         assert(v_selected_0);
1216         ret = bt_field_unsigned_integer_set_value(v_selected_0, 7);
1217         assert(!ret);
1218         v_selected_1 = bt_field_sequence_get_field(v_selected, 1);
1219         assert(v_selected_1);
1220         ret = bt_field_unsigned_integer_set_value(v_selected_1, 6);
1221         assert(!ret);
1222         v_selected_2 = bt_field_sequence_get_field(v_selected, 2);
1223         assert(v_selected_2);
1224         ret = bt_field_unsigned_integer_set_value(v_selected_2, 5);
1225         assert(!ret);
1226         v_selected_3 = bt_field_sequence_get_field(v_selected, 3);
1227         assert(v_selected_3);
1228         ret = bt_field_unsigned_integer_set_value(v_selected_3, 4);
1229         assert(!ret);
1230         v_selected_4 = bt_field_sequence_get_field(v_selected, 4);
1231         assert(v_selected_4);
1232         ret = bt_field_unsigned_integer_set_value(v_selected_4, 3);
1233         assert(!ret);
1234         v_selected_5 = bt_field_sequence_get_field(v_selected, 5);
1235         assert(v_selected_5);
1236         ret = bt_field_unsigned_integer_set_value(v_selected_5, 2);
1237         assert(!ret);
1238         v_selected_6 = bt_field_sequence_get_field(v_selected, 6);
1239         assert(v_selected_6);
1240         ret = bt_field_unsigned_integer_set_value(v_selected_6, 1);
1241         assert(!ret);
1242
1243         /* set a field */
1244         a_0 = bt_field_array_get_field(a, 0);
1245         assert(a_0);
1246         ret = bt_field_string_set_value(a_0, "a_0");
1247         assert(!ret);
1248         a_1 = bt_field_array_get_field(a, 1);
1249         assert(a_1);
1250         ret = bt_field_string_set_value(a_1, "a_1");
1251         assert(!ret);
1252         a_2 = bt_field_array_get_field(a, 2);
1253         assert(a_2);
1254         ret = bt_field_string_set_value(a_2, "a_2");
1255         assert(!ret);
1256         a_3 = bt_field_array_get_field(a, 3);
1257         assert(a_3);
1258         ret = bt_field_string_set_value(a_3, "a_3");
1259         assert(!ret);
1260         a_4 = bt_field_array_get_field(a, 4);
1261         assert(a_4);
1262         ret = bt_field_string_set_value(a_4, "a_4");
1263         assert(!ret);
1264
1265         /* create copy of strct */
1266         strct_copy = bt_field_copy(strct);
1267         ok(strct_copy,
1268                 "bt_field_copy returns a valid pointer");
1269
1270         /* get all copied fields */
1271         len_copy = bt_field_structure_get_field_by_name(strct_copy, "len");
1272         assert(len_copy);
1273         fp_copy = bt_field_structure_get_field_by_name(strct_copy, "fp");
1274         assert(fp_copy);
1275         s_copy = bt_field_structure_get_field_by_name(strct_copy, "s");
1276         assert(s_copy);
1277         e_copy = bt_field_structure_get_field_by_name(strct_copy, "e");
1278         assert(e_copy);
1279         e_int_copy = bt_field_enumeration_get_container(e_copy);
1280         assert(e_int_copy);
1281         v_copy = bt_field_structure_get_field_by_name(strct_copy, "v");
1282         assert(v_copy);
1283         v_selected_copy = bt_field_variant_get_field(v_copy, e_copy);
1284         assert(v_selected_copy);
1285         v_selected_0_copy = bt_field_sequence_get_field(v_selected_copy, 0);
1286         assert(v_selected_0_copy);
1287         v_selected_1_copy = bt_field_sequence_get_field(v_selected_copy, 1);
1288         assert(v_selected_1_copy);
1289         v_selected_2_copy = bt_field_sequence_get_field(v_selected_copy, 2);
1290         assert(v_selected_2_copy);
1291         v_selected_3_copy = bt_field_sequence_get_field(v_selected_copy, 3);
1292         assert(v_selected_3_copy);
1293         v_selected_4_copy = bt_field_sequence_get_field(v_selected_copy, 4);
1294         assert(v_selected_4_copy);
1295         v_selected_5_copy = bt_field_sequence_get_field(v_selected_copy, 5);
1296         assert(v_selected_5_copy);
1297         v_selected_6_copy = bt_field_sequence_get_field(v_selected_copy, 6);
1298         assert(v_selected_6_copy);
1299         a_copy = bt_field_structure_get_field_by_name(strct_copy, "a");
1300         assert(a_copy);
1301         a_0_copy = bt_field_array_get_field(a_copy, 0);
1302         assert(a_0_copy);
1303         a_1_copy = bt_field_array_get_field(a_copy, 1);
1304         assert(a_1_copy);
1305         a_2_copy = bt_field_array_get_field(a_copy, 2);
1306         assert(a_2_copy);
1307         a_3_copy = bt_field_array_get_field(a_copy, 3);
1308         assert(a_3_copy);
1309         a_4_copy = bt_field_array_get_field(a_copy, 4);
1310         assert(a_4_copy);
1311
1312         /* make sure copied fields are different pointers */
1313         field_copy_tests_validate_diff_ptrs(strct_copy, strct, "strct");
1314         field_copy_tests_validate_diff_ptrs(len_copy, len, "len");
1315         field_copy_tests_validate_diff_ptrs(fp_copy, fp, "fp");
1316         field_copy_tests_validate_diff_ptrs(s_copy, s, "s");
1317         field_copy_tests_validate_diff_ptrs(e_int_copy, e_int, "e_int");
1318         field_copy_tests_validate_diff_ptrs(e_copy, e, "e");
1319         field_copy_tests_validate_diff_ptrs(v_copy, v, "v");
1320         field_copy_tests_validate_diff_ptrs(v_selected_copy, v_selected,
1321                 "v_selected");
1322         field_copy_tests_validate_diff_ptrs(v_selected_0_copy, v_selected_0,
1323                 "v_selected_0");
1324         field_copy_tests_validate_diff_ptrs(v_selected_1_copy, v_selected_1,
1325                 "v_selected_1");
1326         field_copy_tests_validate_diff_ptrs(v_selected_2_copy, v_selected_2,
1327                 "v_selected_2");
1328         field_copy_tests_validate_diff_ptrs(v_selected_3_copy, v_selected_3,
1329                 "v_selected_3");
1330         field_copy_tests_validate_diff_ptrs(v_selected_4_copy, v_selected_4,
1331                 "v_selected_4");
1332         field_copy_tests_validate_diff_ptrs(v_selected_5_copy, v_selected_5,
1333                 "v_selected_5");
1334         field_copy_tests_validate_diff_ptrs(v_selected_6_copy, v_selected_6,
1335                 "v_selected_6");
1336         field_copy_tests_validate_diff_ptrs(a_copy, a, "a");
1337         field_copy_tests_validate_diff_ptrs(a_0_copy, a_0, "a_0");
1338         field_copy_tests_validate_diff_ptrs(a_1_copy, a_1, "a_1");
1339         field_copy_tests_validate_diff_ptrs(a_2_copy, a_2, "a_2");
1340         field_copy_tests_validate_diff_ptrs(a_3_copy, a_3, "a_3");
1341         field_copy_tests_validate_diff_ptrs(a_4_copy, a_4, "a_4");
1342
1343         /* make sure copied fields share the same types */
1344         field_copy_tests_validate_same_type(strct_copy, strct_type, "strct");
1345         field_copy_tests_validate_same_type(len_copy, len_type, "len");
1346         field_copy_tests_validate_same_type(fp_copy, fp_type, "fp");
1347         field_copy_tests_validate_same_type(e_int_copy, e_int_type, "e_int");
1348         field_copy_tests_validate_same_type(e_copy, e_type, "e");
1349         field_copy_tests_validate_same_type(v_copy, v_type, "v");
1350         field_copy_tests_validate_same_type(v_selected_copy, v_label2_seq_type,
1351                 "v_selected");
1352         field_copy_tests_validate_same_type(v_selected_0_copy, v_label2_type,
1353                 "v_selected_0");
1354         field_copy_tests_validate_same_type(v_selected_1_copy, v_label2_type,
1355                 "v_selected_1");
1356         field_copy_tests_validate_same_type(v_selected_2_copy, v_label2_type,
1357                 "v_selected_2");
1358         field_copy_tests_validate_same_type(v_selected_3_copy, v_label2_type,
1359                 "v_selected_3");
1360         field_copy_tests_validate_same_type(v_selected_4_copy, v_label2_type,
1361                 "v_selected_4");
1362         field_copy_tests_validate_same_type(v_selected_5_copy, v_label2_type,
1363                 "v_selected_5");
1364         field_copy_tests_validate_same_type(v_selected_6_copy, v_label2_type,
1365                 "v_selected_6");
1366         field_copy_tests_validate_same_type(a_copy, v_label1_array_type, "a");
1367         field_copy_tests_validate_same_type(a_0_copy, v_label1_type, "a_0");
1368         field_copy_tests_validate_same_type(a_1_copy, v_label1_type, "a_1");
1369         field_copy_tests_validate_same_type(a_2_copy, v_label1_type, "a_2");
1370         field_copy_tests_validate_same_type(a_3_copy, v_label1_type, "a_3");
1371         field_copy_tests_validate_same_type(a_4_copy, v_label1_type, "a_4");
1372
1373         /* validate len copy */
1374         ret = bt_field_unsigned_integer_get_value(len_copy, &uint64_t_val);
1375         assert(!ret);
1376         ok(uint64_t_val == 7,
1377                 "bt_field_copy creates a valid integer field copy");
1378
1379         /* validate fp copy */
1380         ret = bt_field_floating_point_get_value(fp_copy, &double_val);
1381         assert(!ret);
1382         ok(double_val == 3.14,
1383                 "bt_field_copy creates a valid floating point number field copy");
1384
1385         /* validate s copy */
1386         str_val = bt_field_string_get_value(s_copy);
1387         ok(str_val && !strcmp(str_val, "btbt"),
1388                 "bt_field_copy creates a valid string field copy");
1389
1390         /* validate e_int copy */
1391         ret = bt_field_unsigned_integer_get_value(e_int_copy,
1392                 &uint64_t_val);
1393         assert(!ret);
1394         ok(uint64_t_val == 23,
1395                 "bt_field_copy creates a valid enum's integer field copy");
1396
1397         /* validate e copy */
1398         e_iter = bt_field_enumeration_get_mappings(e_copy);
1399         (void) bt_field_type_enumeration_mapping_iterator_next(e_iter);
1400         (void) bt_field_type_enumeration_mapping_iterator_get_signed(e_iter,
1401                 &str_val, NULL, NULL);
1402         ok(str_val && !strcmp(str_val, "LABEL2"),
1403                 "bt_field_copy creates a valid enum field copy");
1404
1405         /* validate v_selected copy */
1406         v_selected_copy_len = bt_field_sequence_get_length(v_selected);
1407         assert(v_selected_copy_len);
1408         ret = bt_field_unsigned_integer_get_value(v_selected_copy_len,
1409                 &uint64_t_val);
1410         assert(!ret);
1411         ok(uint64_t_val == 7,
1412                 "bt_field_copy creates a sequence field copy with the proper length");
1413         bt_put(v_selected_copy_len);
1414         v_selected_copy_len = NULL;
1415
1416         /* validate v_selected copy fields */
1417         ret = bt_field_unsigned_integer_get_value(v_selected_0_copy,
1418                 &uint64_t_val);
1419         assert(!ret);
1420         ok(uint64_t_val == 7,
1421                 "bt_field_copy creates a valid sequence field element copy (v_selected_0)");
1422         ret = bt_field_unsigned_integer_get_value(v_selected_1_copy,
1423                 &uint64_t_val);
1424         assert(!ret);
1425         ok(uint64_t_val == 6,
1426                 "bt_field_copy creates a valid sequence field element copy (v_selected_1)");
1427         ret = bt_field_unsigned_integer_get_value(v_selected_2_copy,
1428                 &uint64_t_val);
1429         assert(!ret);
1430         ok(uint64_t_val == 5,
1431                 "bt_field_copy creates a valid sequence field element copy (v_selected_2)");
1432         ret = bt_field_unsigned_integer_get_value(v_selected_3_copy,
1433                 &uint64_t_val);
1434         assert(!ret);
1435         ok(uint64_t_val == 4,
1436                 "bt_field_copy creates a valid sequence field element copy (v_selected_3)");
1437         ret = bt_field_unsigned_integer_get_value(v_selected_4_copy,
1438                 &uint64_t_val);
1439         assert(!ret);
1440         ok(uint64_t_val == 3,
1441                 "bt_field_copy creates a valid sequence field element copy (v_selected_4)");
1442         ret = bt_field_unsigned_integer_get_value(v_selected_5_copy,
1443                 &uint64_t_val);
1444         assert(!ret);
1445         ok(uint64_t_val == 2,
1446                 "bt_field_copy creates a valid sequence field element copy (v_selected_5)");
1447         ret = bt_field_unsigned_integer_get_value(v_selected_6_copy,
1448                 &uint64_t_val);
1449         assert(!ret);
1450         ok(uint64_t_val == 1,
1451                 "bt_field_copy creates a valid sequence field element copy (v_selected_6)");
1452
1453         /* validate a copy fields */
1454         str_val = bt_field_string_get_value(a_0_copy);
1455         ok(str_val && !strcmp(str_val, "a_0"),
1456                 "bt_field_copy creates a valid array field element copy (a_0)");
1457         str_val = bt_field_string_get_value(a_1_copy);
1458         ok(str_val && !strcmp(str_val, "a_1"),
1459                 "bt_field_copy creates a valid array field element copy (a_1)");
1460         str_val = bt_field_string_get_value(a_2_copy);
1461         ok(str_val && !strcmp(str_val, "a_2"),
1462                 "bt_field_copy creates a valid array field element copy (a_2)");
1463         str_val = bt_field_string_get_value(a_3_copy);
1464         ok(str_val && !strcmp(str_val, "a_3"),
1465                 "bt_field_copy creates a valid array field element copy (a_3)");
1466         str_val = bt_field_string_get_value(a_4_copy);
1467         ok(str_val && !strcmp(str_val, "a_4"),
1468                 "bt_field_copy creates a valid array field element copy (a_4)");
1469
1470         /* put everything */
1471         bt_put(len_type);
1472         bt_put(fp_type);
1473         bt_put(s_type);
1474         bt_put(e_int_type);
1475         bt_put(e_type);
1476         bt_put(v_type);
1477         bt_put(v_label1_type);
1478         bt_put(v_label1_array_type);
1479         bt_put(v_label2_type);
1480         bt_put(v_label2_seq_type);
1481         bt_put(strct_type);
1482         bt_put(len);
1483         bt_put(fp);
1484         bt_put(s);
1485         bt_put(e_int);
1486         bt_put(e);
1487         bt_put(v);
1488         bt_put(v_selected);
1489         bt_put(v_selected_0);
1490         bt_put(v_selected_1);
1491         bt_put(v_selected_2);
1492         bt_put(v_selected_3);
1493         bt_put(v_selected_4);
1494         bt_put(v_selected_5);
1495         bt_put(v_selected_6);
1496         bt_put(a);
1497         bt_put(a_0);
1498         bt_put(a_1);
1499         bt_put(a_2);
1500         bt_put(a_3);
1501         bt_put(a_4);
1502         bt_put(strct);
1503         bt_put(len_copy);
1504         bt_put(fp_copy);
1505         bt_put(s_copy);
1506         bt_put(e_int_copy);
1507         bt_put(e_copy);
1508         bt_put(v_copy);
1509         bt_put(v_selected_copy);
1510         bt_put(v_selected_0_copy);
1511         bt_put(v_selected_1_copy);
1512         bt_put(v_selected_2_copy);
1513         bt_put(v_selected_3_copy);
1514         bt_put(v_selected_4_copy);
1515         bt_put(v_selected_5_copy);
1516         bt_put(v_selected_6_copy);
1517         bt_put(a_copy);
1518         bt_put(a_0_copy);
1519         bt_put(a_1_copy);
1520         bt_put(a_2_copy);
1521         bt_put(a_3_copy);
1522         bt_put(a_4_copy);
1523         bt_put(strct_copy);
1524         bt_put(e_iter);
1525 }
1526
1527 static
1528 void type_field_tests()
1529 {
1530         struct bt_field *uint_12;
1531         struct bt_field *int_16;
1532         struct bt_field *string;
1533         struct bt_field_type *composite_structure_type;
1534         struct bt_field_type *structure_seq_type;
1535         struct bt_field_type *string_type;
1536         struct bt_field_type *sequence_type;
1537         struct bt_field_type *uint_8_type;
1538         struct bt_field_type *int_16_type;
1539         struct bt_field_type *uint_12_type =
1540                 bt_field_type_integer_create(12);
1541         struct bt_field_type *enumeration_type;
1542         struct bt_field_type *returned_type;
1543         const char *ret_string;
1544
1545         ok(uint_12_type, "Create an unsigned integer type");
1546         ok(bt_field_type_integer_set_base(uint_12_type,
1547                 BT_INTEGER_BASE_BINARY) == 0,
1548                 "Set integer type's base as binary");
1549         ok(bt_field_type_integer_set_base(uint_12_type,
1550                 BT_INTEGER_BASE_DECIMAL) == 0,
1551                 "Set integer type's base as decimal");
1552         ok(bt_field_type_integer_set_base(uint_12_type,
1553                 BT_INTEGER_BASE_UNKNOWN),
1554                 "Reject integer type's base set as unknown");
1555         ok(bt_field_type_integer_set_base(uint_12_type,
1556                 BT_INTEGER_BASE_OCTAL) == 0,
1557                 "Set integer type's base as octal");
1558         ok(bt_field_type_integer_set_base(uint_12_type,
1559                 BT_INTEGER_BASE_HEXADECIMAL) == 0,
1560                 "Set integer type's base as hexadecimal");
1561         ok(bt_field_type_integer_set_base(uint_12_type, 457417),
1562                 "Reject unknown integer base value");
1563         ok(bt_ctf_field_type_integer_set_signed(uint_12_type, 952835) == 0,
1564                 "Set integer type signedness to signed");
1565         ok(bt_ctf_field_type_integer_set_signed(uint_12_type, 0) == 0,
1566                 "Set integer type signedness to unsigned");
1567         ok(bt_field_type_integer_get_size(NULL) < 0,
1568                 "bt_field_type_integer_get_size handles NULL correctly");
1569         ok(bt_field_type_integer_get_size(uint_12_type) == 12,
1570                 "bt_field_type_integer_get_size returns a correct value");
1571         ok(bt_ctf_field_type_integer_get_signed(NULL) < 0,
1572                 "bt_field_type_integer_get_signed handles NULL correctly");
1573         ok(bt_ctf_field_type_integer_get_signed(uint_12_type) == 0,
1574                 "bt_field_type_integer_get_signed returns a correct value for unsigned types");
1575
1576         ok(bt_field_type_set_byte_order(NULL,
1577                 BT_BYTE_ORDER_LITTLE_ENDIAN) < 0,
1578                 "bt_field_type_set_byte_order handles NULL correctly");
1579         ok(bt_field_type_set_byte_order(uint_12_type,
1580                 (enum bt_byte_order) 42) < 0,
1581                 "bt_field_type_set_byte_order rejects invalid values");
1582         ok(bt_field_type_set_byte_order(uint_12_type,
1583                 BT_BYTE_ORDER_LITTLE_ENDIAN) == 0,
1584                 "Set an integer's byte order to little endian");
1585         ok(bt_field_type_set_byte_order(uint_12_type,
1586                 BT_BYTE_ORDER_BIG_ENDIAN) == 0,
1587                 "Set an integer's byte order to big endian");
1588         ok(bt_field_type_get_byte_order(uint_12_type) ==
1589                 BT_BYTE_ORDER_BIG_ENDIAN,
1590                 "bt_field_type_get_byte_order returns a correct value");
1591         ok(bt_field_type_get_byte_order(NULL) ==
1592                 BT_BYTE_ORDER_UNKNOWN,
1593                 "bt_field_type_get_byte_order handles NULL correctly");
1594
1595         ok(bt_field_type_get_type_id(NULL) ==
1596                 BT_FIELD_TYPE_ID_UNKNOWN,
1597                 "bt_field_type_get_type_id handles NULL correctly");
1598         ok(bt_field_type_get_type_id(uint_12_type) ==
1599                 BT_FIELD_TYPE_ID_INTEGER,
1600                 "bt_field_type_get_type_id returns a correct value with an integer type");
1601
1602         ok(bt_field_type_integer_get_base(NULL) ==
1603                 BT_INTEGER_BASE_UNKNOWN,
1604                 "bt_field_type_integer_get_base handles NULL correctly");
1605         ok(bt_field_type_integer_get_base(uint_12_type) ==
1606                 BT_INTEGER_BASE_HEXADECIMAL,
1607                 "bt_field_type_integer_get_base returns a correct value");
1608
1609         ok(bt_field_type_integer_set_encoding(NULL,
1610                 BT_STRING_ENCODING_ASCII) < 0,
1611                 "bt_field_type_integer_set_encoding handles NULL correctly");
1612         ok(bt_field_type_integer_set_encoding(uint_12_type,
1613                 (enum bt_string_encoding) 123) < 0,
1614                 "bt_field_type_integer_set_encoding handles invalid encodings correctly");
1615         ok(bt_field_type_integer_set_encoding(uint_12_type,
1616                 BT_STRING_ENCODING_UTF8) == 0,
1617                 "Set integer type encoding to UTF8");
1618         ok(bt_field_type_integer_get_encoding(NULL) ==
1619                 BT_STRING_ENCODING_UNKNOWN,
1620                 "bt_field_type_integer_get_encoding handles NULL correctly");
1621         ok(bt_field_type_integer_get_encoding(uint_12_type) ==
1622                 BT_STRING_ENCODING_UTF8,
1623                 "bt_field_type_integer_get_encoding returns a correct value");
1624
1625         int_16_type = bt_field_type_integer_create(16);
1626         assert(int_16_type);
1627         ok(!bt_ctf_field_type_integer_set_signed(int_16_type, 1),
1628                 "Set signedness of 16 bit integer to true");
1629         ok(bt_ctf_field_type_integer_get_signed(int_16_type) == 1,
1630                 "bt_field_type_integer_get_signed returns a correct value for signed types");
1631         uint_8_type = bt_field_type_integer_create(8);
1632         sequence_type =
1633                 bt_field_type_sequence_create(int_16_type, "seq_len");
1634         ok(sequence_type, "Create a sequence of int16_t type");
1635         ok(bt_field_type_get_type_id(sequence_type) ==
1636                 BT_FIELD_TYPE_ID_SEQUENCE,
1637                 "bt_field_type_get_type_id returns a correct value with a sequence type");
1638
1639         ok(bt_field_type_sequence_get_length_field_name(NULL) == NULL,
1640                 "bt_field_type_sequence_get_length_field_name handles NULL correctly");
1641         ret_string = bt_field_type_sequence_get_length_field_name(
1642                 sequence_type);
1643         ok(!strcmp(ret_string, "seq_len"),
1644                 "bt_field_type_sequence_get_length_field_name returns the correct value");
1645         ok(bt_field_type_sequence_get_element_type(NULL) == NULL,
1646                 "bt_field_type_sequence_get_element_type handles NULL correctly");
1647         returned_type = bt_field_type_sequence_get_element_type(
1648                 sequence_type);
1649         ok(returned_type == int_16_type,
1650                 "bt_field_type_sequence_get_element_type returns the correct type");
1651         bt_put(returned_type);
1652
1653         string_type = bt_field_type_string_create();
1654         ok(string_type, "Create a string type");
1655         ok(bt_field_type_string_set_encoding(string_type,
1656                 BT_STRING_ENCODING_NONE),
1657                 "Reject invalid \"None\" string encoding");
1658         ok(bt_field_type_string_set_encoding(string_type,
1659                 42),
1660                 "Reject invalid string encoding");
1661         ok(bt_field_type_string_set_encoding(string_type,
1662                 BT_STRING_ENCODING_ASCII) == 0,
1663                 "Set string encoding to ASCII");
1664
1665         ok(bt_field_type_string_get_encoding(NULL) ==
1666                 BT_STRING_ENCODING_UNKNOWN,
1667                 "bt_field_type_string_get_encoding handles NULL correctly");
1668         ok(bt_field_type_string_get_encoding(string_type) ==
1669                 BT_STRING_ENCODING_ASCII,
1670                 "bt_field_type_string_get_encoding returns the correct value");
1671
1672         structure_seq_type = bt_field_type_structure_create();
1673         ok(bt_field_type_get_type_id(structure_seq_type) ==
1674                 BT_FIELD_TYPE_ID_STRUCT,
1675                 "bt_field_type_get_type_id returns a correct value with a structure type");
1676         ok(structure_seq_type, "Create a structure type");
1677         ok(bt_field_type_structure_add_field(structure_seq_type,
1678                 uint_8_type, "seq_len") == 0,
1679                 "Add a uint8_t type to a structure");
1680         ok(bt_field_type_structure_add_field(structure_seq_type,
1681                 sequence_type, "a_sequence") == 0,
1682                 "Add a sequence type to a structure");
1683
1684         ok(bt_field_type_structure_get_field_count(NULL) < 0,
1685                 "bt_field_type_structure_get_field_count handles NULL correctly");
1686         ok(bt_field_type_structure_get_field_count(structure_seq_type) == 2,
1687                 "bt_field_type_structure_get_field_count returns a correct value");
1688
1689         ok(bt_ctf_field_type_structure_get_field(NULL,
1690                 &ret_string, &returned_type, 1) < 0,
1691                 "bt_field_type_structure_get_field handles a NULL type correctly");
1692         ok(bt_ctf_field_type_structure_get_field(structure_seq_type,
1693                 NULL, &returned_type, 1) == 0,
1694                 "bt_field_type_structure_get_field handles a NULL name correctly");
1695         bt_put(returned_type);
1696         ok(bt_ctf_field_type_structure_get_field(structure_seq_type,
1697                 &ret_string, NULL, 1) == 0,
1698                 "bt_field_type_structure_get_field handles a NULL return type correctly");
1699         ok(bt_ctf_field_type_structure_get_field(structure_seq_type,
1700                 &ret_string, &returned_type, 10) < 0,
1701                 "bt_field_type_structure_get_field handles an invalid index correctly");
1702         ok(bt_ctf_field_type_structure_get_field(structure_seq_type,
1703                 &ret_string, &returned_type, 1) == 0,
1704                 "bt_field_type_structure_get_field returns a field");
1705         ok(!strcmp(ret_string, "a_sequence"),
1706                 "bt_field_type_structure_get_field returns a correct field name");
1707         ok(returned_type == sequence_type,
1708                 "bt_field_type_structure_get_field returns a correct field type");
1709         bt_put(returned_type);
1710
1711         ok(bt_field_type_structure_get_field_type_by_name(NULL, "a_sequence") == NULL,
1712                 "bt_field_type_structure_get_field_type_by_name handles a NULL structure correctly");
1713         ok(bt_field_type_structure_get_field_type_by_name(structure_seq_type, NULL) == NULL,
1714                 "bt_field_type_structure_get_field_type_by_name handles a NULL field name correctly");
1715         returned_type = bt_field_type_structure_get_field_type_by_name(
1716                 structure_seq_type, "a_sequence");
1717         ok(returned_type == sequence_type,
1718                 "bt_field_type_structure_get_field_type_by_name returns the correct field type");
1719         bt_put(returned_type);
1720
1721         composite_structure_type = bt_field_type_structure_create();
1722         ok(bt_field_type_structure_add_field(composite_structure_type,
1723                 string_type, "a_string") == 0,
1724                 "Add a string type to a structure");
1725         ok(bt_field_type_structure_add_field(composite_structure_type,
1726                 structure_seq_type, "inner_structure") == 0,
1727                 "Add a structure type to a structure");
1728
1729         ok(bt_field_type_structure_get_field_type_by_name(
1730                 NULL, "a_sequence") == NULL,
1731                 "bt_field_type_structure_get_field_type_by_name handles a NULL field correctly");
1732         ok(bt_field_type_structure_get_field_type_by_name(
1733                 structure_seq_type, NULL) == NULL,
1734                 "bt_field_type_structure_get_field_type_by_name handles a NULL field name correctly");
1735         returned_type = bt_field_type_structure_get_field_type_by_name(
1736                 structure_seq_type, "a_sequence");
1737         ok(returned_type == sequence_type,
1738                 "bt_field_type_structure_get_field_type_by_name returns a correct type");
1739         bt_put(returned_type);
1740
1741         int_16 = bt_field_create(int_16_type);
1742         ok(int_16, "Instanciate a signed 16-bit integer");
1743         uint_12 = bt_field_create(uint_12_type);
1744         ok(uint_12, "Instanciate an unsigned 12-bit integer");
1745         returned_type = bt_field_get_type(int_16);
1746         ok(returned_type == int_16_type,
1747                 "bt_field_get_type returns the correct type");
1748
1749         /* Can't modify types after instanciating them */
1750         ok(bt_field_type_integer_set_base(uint_12_type,
1751                 BT_INTEGER_BASE_DECIMAL),
1752                 "Check an integer type' base can't be modified after instanciation");
1753         ok(bt_ctf_field_type_integer_set_signed(uint_12_type, 0),
1754                 "Check an integer type's signedness can't be modified after instanciation");
1755
1756         /* Check overflows are properly tested for */
1757         ok(bt_field_signed_integer_set_value(int_16, -32768) == 0,
1758                 "Check -32768 is allowed for a signed 16-bit integer");
1759         ok(bt_field_signed_integer_set_value(int_16, 32767) == 0,
1760                 "Check 32767 is allowed for a signed 16-bit integer");
1761         ok(bt_field_signed_integer_set_value(int_16, -42) == 0,
1762                 "Check -42 is allowed for a signed 16-bit integer");
1763
1764         ok(bt_field_unsigned_integer_set_value(uint_12, 4095) == 0,
1765                 "Check 4095 is allowed for an unsigned 12-bit integer");
1766         ok(bt_field_unsigned_integer_set_value(uint_12, 0) == 0,
1767                 "Check 0 is allowed for an unsigned 12-bit integer");
1768
1769         string = bt_field_create(string_type);
1770         ok(string, "Instanciate a string field");
1771         ok(bt_field_string_set_value(string, "A value") == 0,
1772                 "Set a string's value");
1773
1774         enumeration_type = bt_field_type_enumeration_create(uint_12_type);
1775         ok(enumeration_type,
1776                 "Create an enumeration type with an unsigned 12-bit integer as container");
1777
1778         bt_put(string);
1779         bt_put(uint_12);
1780         bt_put(int_16);
1781         bt_put(composite_structure_type);
1782         bt_put(structure_seq_type);
1783         bt_put(string_type);
1784         bt_put(sequence_type);
1785         bt_put(uint_8_type);
1786         bt_put(int_16_type);
1787         bt_put(uint_12_type);
1788         bt_put(enumeration_type);
1789         bt_put(returned_type);
1790 }
1791
1792 static
1793 void packet_resize_test(struct bt_stream_class *stream_class,
1794                 struct bt_stream *stream, struct bt_ctf_clock *clock)
1795 {
1796         /*
1797          * Append enough events to force the underlying packet to be resized.
1798          * Also tests that a new event can be declared after a stream has been
1799          * instantiated and used/flushed.
1800          */
1801         int ret = 0;
1802         int i;
1803         struct bt_event_class *event_class = bt_event_class_create(
1804                 "Spammy_Event");
1805         struct bt_field_type *integer_type =
1806                 bt_field_type_integer_create(17);
1807         struct bt_field_type *string_type =
1808                 bt_field_type_string_create();
1809         struct bt_event *event = NULL;
1810         struct bt_field *ret_field = NULL;
1811         struct bt_field_type *ret_field_type = NULL;
1812         uint64_t ret_uint64;
1813         int events_appended = 0;
1814         struct bt_field *packet_context = NULL,
1815                 *packet_context_field = NULL, *stream_event_context = NULL;
1816         struct bt_field_type *ep_field_1_type = NULL;
1817         struct bt_field_type *ep_a_string_type = NULL;
1818         struct bt_field_type *ep_type = NULL;
1819
1820         ret |= bt_event_class_add_field(event_class, integer_type,
1821                 "field_1");
1822         ret |= bt_event_class_add_field(event_class, string_type,
1823                 "a_string");
1824         ret |= bt_stream_class_add_event_class(stream_class, event_class);
1825         ok(ret == 0, "Add a new event class to a stream class after writing an event");
1826         if (ret) {
1827                 goto end;
1828         }
1829
1830         /*
1831          * bt_stream_class_add_event_class() copies the field types
1832          * of event_class, so we retrieve the new ones to create the
1833          * appropriate fields.
1834          */
1835         ep_type = bt_event_class_get_payload_type(event_class);
1836         assert(ep_type);
1837         ep_field_1_type = bt_field_type_structure_get_field_type_by_name(
1838                 ep_type, "field_1");
1839         assert(ep_field_1_type);
1840         ep_a_string_type = bt_field_type_structure_get_field_type_by_name(
1841                 ep_type, "a_string");
1842         assert(ep_a_string_type);
1843
1844         event = bt_event_create(event_class);
1845         ret_field = bt_event_get_payload_by_index(event, 0);
1846         ret_field_type = bt_field_get_type(ret_field);
1847         ok(bt_field_type_compare(ret_field_type, integer_type) == 0,
1848                 "bt_event_get_payload_by_index returns a correct field");
1849         bt_put(ret_field_type);
1850         bt_put(ret_field);
1851         bt_put(event);
1852
1853         for (i = 0; i < packet_resize_test_length; i++) {
1854                 event = bt_event_create(event_class);
1855                 struct bt_field *integer =
1856                         bt_field_create(ep_field_1_type);
1857                 struct bt_field *string =
1858                         bt_field_create(ep_a_string_type);
1859
1860                 ret |= bt_ctf_clock_set_time(clock, ++current_time);
1861                 ret |= bt_field_unsigned_integer_set_value(integer, i);
1862                 ret |= bt_event_set_payload(event, "field_1",
1863                         integer);
1864                 bt_put(integer);
1865                 ret |= bt_field_string_set_value(string, "This is a test");
1866                 ret |= bt_event_set_payload(event, "a_string",
1867                         string);
1868                 bt_put(string);
1869
1870                 /* Populate stream event context */
1871                 stream_event_context =
1872                         bt_event_get_stream_event_context(event);
1873                 integer = bt_field_structure_get_field_by_name(stream_event_context,
1874                         "common_event_context");
1875                 BT_PUT(stream_event_context);
1876                 ret |= bt_field_unsigned_integer_set_value(integer,
1877                         i % 42);
1878                 bt_put(integer);
1879
1880                 ret |= bt_stream_append_event(stream, event);
1881                 bt_put(event);
1882
1883                 if (ret) {
1884                         break;
1885                 }
1886         }
1887
1888         events_appended = !!(i == packet_resize_test_length);
1889         ret = bt_stream_get_discarded_events_count(stream, &ret_uint64);
1890         ok(ret == 0 && ret_uint64 == 0,
1891                 "bt_stream_get_discarded_events_count returns a correct number of discarded events when none were discarded");
1892         bt_stream_append_discarded_events(stream, 1000);
1893         ret = bt_stream_get_discarded_events_count(stream, &ret_uint64);
1894         ok(ret == 0 && ret_uint64 == 1000,
1895                 "bt_stream_get_discarded_events_count returns a correct number of discarded events when some were discarded");
1896
1897 end:
1898         ok(events_appended, "Append 100 000 events to a stream");
1899
1900         /*
1901          * Populate the custom packet context field with a dummy value
1902          * otherwise flush will fail.
1903          */
1904         packet_context = bt_stream_get_packet_context(stream);
1905         packet_context_field = bt_field_structure_get_field_by_name(packet_context,
1906                 "custom_packet_context_field");
1907         bt_field_unsigned_integer_set_value(packet_context_field, 2);
1908
1909         ok(bt_stream_flush(stream) == 0,
1910                 "Flush a stream that forces a packet resize");
1911         ret = bt_stream_get_discarded_events_count(stream, &ret_uint64);
1912         ok(ret == 0 && ret_uint64 == 1000,
1913                 "bt_stream_get_discarded_events_count returns a correct number of discarded events after a flush");
1914         bt_put(integer_type);
1915         bt_put(string_type);
1916         bt_put(packet_context);
1917         bt_put(packet_context_field);
1918         bt_put(stream_event_context);
1919         bt_put(event_class);
1920         bt_put(ep_field_1_type);
1921         bt_put(ep_a_string_type);
1922         bt_put(ep_type);
1923 }
1924
1925 static
1926 void test_empty_stream(struct bt_ctf_writer *writer)
1927 {
1928         int ret = 0;
1929         struct bt_trace *trace = NULL, *ret_trace = NULL;
1930         struct bt_stream_class *stream_class = NULL;
1931         struct bt_stream *stream = NULL;
1932
1933         trace = bt_ctf_writer_get_trace(writer);
1934         if (!trace) {
1935                 diag("Failed to get trace from writer");
1936                 ret = -1;
1937                 goto end;
1938         }
1939
1940         stream_class = bt_stream_class_create("empty_stream");
1941         if (!stream_class) {
1942                 diag("Failed to create stream class");
1943                 ret = -1;
1944                 goto end;
1945         }
1946
1947         ret = bt_stream_class_set_packet_context_type(stream_class, NULL);
1948         assert(ret == 0);
1949         ret = bt_stream_class_set_event_header_type(stream_class, NULL);
1950         assert(ret == 0);
1951
1952         ok(bt_stream_class_get_trace(NULL) == NULL,
1953                 "bt_stream_class_get_trace handles NULL correctly");
1954         ok(bt_stream_class_get_trace(stream_class) == NULL,
1955                 "bt_stream_class_get_trace returns NULL when stream class is orphaned");
1956
1957         stream = bt_ctf_writer_create_stream(writer, stream_class);
1958         if (!stream) {
1959                 diag("Failed to create writer stream");
1960                 ret = -1;
1961                 goto end;
1962         }
1963
1964         ret_trace = bt_stream_class_get_trace(stream_class);
1965         ok(ret_trace == trace,
1966                 "bt_stream_class_get_trace returns the correct trace after a stream has been created");
1967 end:
1968         ok(ret == 0,
1969                 "Created a stream class with default attributes and an empty stream");
1970         bt_put(trace);
1971         bt_put(ret_trace);
1972         bt_put(stream);
1973         bt_put(stream_class);
1974 }
1975
1976 static
1977 void test_custom_event_header_stream(struct bt_ctf_writer *writer,
1978                         struct bt_ctf_clock *clock)
1979 {
1980         int i, ret;
1981         struct bt_stream_class *stream_class = NULL;
1982         struct bt_stream *stream = NULL;
1983         struct bt_field_type *integer_type = NULL,
1984                 *sequence_type = NULL, *event_header_type = NULL;
1985         struct bt_field *integer = NULL, *sequence = NULL,
1986                 *event_header = NULL, *packet_header = NULL;
1987         struct bt_event_class *event_class = NULL;
1988         struct bt_event *event = NULL;
1989
1990         stream_class = bt_stream_class_create("custom_event_header_stream");
1991         if (!stream_class) {
1992                 fail("Failed to create stream class");
1993                 goto end;
1994         }
1995
1996         ret = bt_stream_class_set_clock(stream_class, clock);
1997         if (ret) {
1998                 fail("Failed to set stream class clock");
1999                 goto end;
2000         }
2001
2002         /*
2003          * Customize event header to add an "seq_len" integer member
2004          * which will be used as the length of a sequence in an event of this
2005          * stream.
2006          */
2007         event_header_type = bt_stream_class_get_event_header_type(
2008                 stream_class);
2009         if (!event_header_type) {
2010                 fail("Failed to get event header type");
2011                 goto end;
2012         }
2013
2014         integer_type = bt_field_type_integer_create(13);
2015         if (!integer_type) {
2016                 fail("Failed to create length integer type");
2017                 goto end;
2018         }
2019
2020         ret = bt_field_type_structure_add_field(event_header_type,
2021                 integer_type, "seq_len");
2022         if (ret) {
2023                 fail("Failed to add a new field to stream event header");
2024                 goto end;
2025         }
2026
2027         event_class = bt_event_class_create("sequence_event");
2028         if (!event_class) {
2029                 fail("Failed to create event class");
2030                 goto end;
2031         }
2032
2033         /*
2034          * This event's payload will contain a sequence which references
2035          * stream.event.header.seq_len as its length field.
2036          */
2037         sequence_type = bt_field_type_sequence_create(integer_type,
2038                 "stream.event.header.seq_len");
2039         if (!sequence_type) {
2040                 fail("Failed to create a sequence");
2041                 goto end;
2042         }
2043
2044         ret = bt_event_class_add_field(event_class, sequence_type,
2045                 "some_sequence");
2046         if (ret) {
2047                 fail("Failed to add a sequence to an event class");
2048                 goto end;
2049         }
2050
2051         ret = bt_stream_class_add_event_class(stream_class, event_class);
2052         if (ret) {
2053                 fail("Failed to add event class to stream class");
2054                 goto end;
2055         }
2056
2057         stream = bt_ctf_writer_create_stream(writer, stream_class);
2058         if (!stream) {
2059                 fail("Failed to create stream")
2060                 goto end;
2061         }
2062
2063         /*
2064          * We have defined a custom packet header field. We have to populate it
2065          * explicitly.
2066          */
2067         packet_header = bt_stream_get_packet_header(stream);
2068         if (!packet_header) {
2069                 fail("Failed to get stream packet header");
2070                 goto end;
2071         }
2072
2073         integer = bt_field_structure_get_field_by_name(packet_header,
2074                 "custom_trace_packet_header_field");
2075         if (!integer) {
2076                 fail("Failed to retrieve custom_trace_packet_header_field");
2077                 goto end;
2078         }
2079
2080         ret = bt_field_unsigned_integer_set_value(integer, 3487);
2081         if (ret) {
2082                 fail("Failed to set custom_trace_packet_header_field value");
2083                 goto end;
2084         }
2085         bt_put(integer);
2086
2087         event = bt_event_create(event_class);
2088         if (!event) {
2089                 fail("Failed to create event");
2090                 goto end;
2091         }
2092
2093         event_header = bt_event_get_header(event);
2094         if (!event_header) {
2095                 fail("Failed to get event header");
2096                 goto end;
2097         }
2098
2099         integer = bt_field_structure_get_field_by_name(event_header,
2100                 "seq_len");
2101         if (!integer) {
2102                 fail("Failed to get seq_len field from event header");
2103                 goto end;
2104         }
2105
2106         ret = bt_field_unsigned_integer_set_value(integer, 2);
2107         if (ret) {
2108                 fail("Failed to set seq_len value in event header");
2109                 goto end;
2110         }
2111
2112         /* Populate both sequence integer fields */
2113         sequence = bt_event_get_payload(event, "some_sequence");
2114         if (!sequence) {
2115                 fail("Failed to retrieve sequence from event");
2116                 goto end;
2117         }
2118
2119         ret = bt_field_sequence_set_length(sequence, integer);
2120         if (ret) {
2121                 fail("Failed to set sequence length");
2122                 goto end;
2123         }
2124         bt_put(integer);
2125
2126         for (i = 0; i < 2; i++) {
2127                 integer = bt_field_sequence_get_field(sequence, i);
2128                 if (ret) {
2129                         fail("Failed to retrieve sequence element");
2130                         goto end;
2131                 }
2132
2133                 ret = bt_field_unsigned_integer_set_value(integer, i);
2134                 if (ret) {
2135                         fail("Failed to set sequence element value");
2136                         goto end;
2137                 }
2138
2139                 bt_put(integer);
2140                 integer = NULL;
2141         }
2142
2143         ret = bt_stream_append_event(stream, event);
2144         if (ret) {
2145                 fail("Failed to append event to stream");
2146                 goto end;
2147         }
2148
2149         ret = bt_stream_flush(stream);
2150         if (ret) {
2151                 fail("Failed to flush custom_event_header stream");
2152         }
2153 end:
2154         bt_put(stream);
2155         bt_put(stream_class);
2156         bt_put(event_class);
2157         bt_put(event);
2158         bt_put(integer);
2159         bt_put(sequence);
2160         bt_put(event_header);
2161         bt_put(packet_header);
2162         bt_put(sequence_type);
2163         bt_put(integer_type);
2164         bt_put(event_header_type);
2165 }
2166
2167 static
2168 void test_instanciate_event_before_stream(struct bt_ctf_writer *writer,
2169                 struct bt_ctf_clock *clock)
2170 {
2171         int ret = 0;
2172         struct bt_stream_class *stream_class = NULL;
2173         struct bt_stream *stream = NULL,
2174                 *ret_stream = NULL;
2175         struct bt_event_class *event_class = NULL;
2176         struct bt_event *event = NULL;
2177         struct bt_field_type *integer_type = NULL;
2178         struct bt_field *integer = NULL;
2179
2180         stream_class = bt_stream_class_create("event_before_stream_test");
2181         if (!stream_class) {
2182                 diag("Failed to create stream class");
2183                 ret = -1;
2184                 goto end;
2185         }
2186
2187         ret = bt_stream_class_set_clock(stream_class, clock);
2188         if (ret) {
2189                 diag("Failed to set stream class clock");
2190                 goto end;
2191         }
2192
2193         event_class = bt_event_class_create("some_event_class_name");
2194         integer_type = bt_field_type_integer_create(32);
2195         if (!integer_type) {
2196                 diag("Failed to create integer field type");
2197                 ret = -1;
2198                 goto end;
2199         }
2200
2201         ret = bt_event_class_add_field(event_class, integer_type,
2202                 "integer_field");
2203         if (ret) {
2204                 diag("Failed to add field to event class");
2205                 goto end;
2206         }
2207
2208         ret = bt_stream_class_add_event_class(stream_class,
2209                 event_class);
2210         if (ret) {
2211                 diag("Failed to add event class to stream class");
2212         }
2213
2214         event = bt_event_create(event_class);
2215         if (!event) {
2216                 diag("Failed to create event");
2217                 ret = -1;
2218                 goto end;
2219         }
2220
2221         integer = bt_event_get_payload_by_index(event, 0);
2222         if (!integer) {
2223                 diag("Failed to get integer field payload from event");
2224                 ret = -1;
2225                 goto end;
2226         }
2227
2228         ret = bt_field_unsigned_integer_set_value(integer, 1234);
2229         if (ret) {
2230                 diag("Failed to set integer field value");
2231                 goto end;
2232         }
2233
2234         stream = bt_ctf_writer_create_stream(writer, stream_class);
2235         if (!stream) {
2236                 diag("Failed to create writer stream");
2237                 ret = -1;
2238                 goto end;
2239         }
2240
2241         ret = bt_stream_append_event(stream, event);
2242         if (ret) {
2243                 diag("Failed to append event to stream");
2244                 goto end;
2245         }
2246
2247         ret_stream = bt_event_get_stream(event);
2248         ok(ret_stream == stream,
2249                 "bt_event_get_stream returns an event's stream after it has been appended");
2250 end:
2251         ok(ret == 0,
2252                 "Create an event before instanciating its associated stream");
2253         bt_put(stream);
2254         bt_put(ret_stream);
2255         bt_put(stream_class);
2256         bt_put(event_class);
2257         bt_put(event);
2258         bt_put(integer_type);
2259         bt_put(integer);
2260 }
2261
2262 static
2263 void append_existing_event_class(struct bt_stream_class *stream_class)
2264 {
2265         struct bt_event_class *event_class;
2266
2267         event_class = bt_event_class_create("Simple Event");
2268         assert(event_class);
2269         ok(bt_stream_class_add_event_class(stream_class, event_class) == 0,
2270                 "two event classes with the same name may cohabit within the same stream class");
2271         bt_put(event_class);
2272
2273         event_class = bt_event_class_create("different name, ok");
2274         assert(event_class);
2275         assert(!bt_event_class_set_id(event_class, 13));
2276         ok(bt_stream_class_add_event_class(stream_class, event_class),
2277                 "two event classes with the same ID cannot cohabit within the same stream class");
2278         bt_put(event_class);
2279 }
2280
2281 static
2282 struct bt_event_class *create_minimal_event_class(void)
2283 {
2284         struct bt_event_class *ec = NULL;
2285         struct bt_field_type *int_ft = NULL;
2286         int ret;
2287
2288         int_ft = bt_field_type_integer_create(23);
2289         assert(int_ft);
2290         ec = bt_event_class_create("minimal");
2291         assert(ec);
2292         ret = bt_event_class_add_field(ec, int_ft, "field");
2293         assert(!ret);
2294         BT_PUT(int_ft);
2295
2296         return ec;
2297 }
2298
2299 static
2300 void test_create_writer_vs_non_writer_mode(void)
2301 {
2302         int ret;
2303         gchar *trace_path;
2304         const char *writer_stream_name = "writer stream instance";
2305         struct bt_ctf_writer *writer = NULL;
2306         struct bt_trace *writer_trace = NULL;
2307         struct bt_stream_class *writer_sc = NULL;
2308         struct bt_stream *writer_stream = NULL;
2309         struct bt_stream *writer_stream2 = NULL;
2310         struct bt_stream *packet_stream = NULL;
2311         struct bt_trace *non_writer_trace = NULL;
2312         struct bt_stream_class *non_writer_sc = NULL;
2313         struct bt_stream *non_writer_stream = NULL;
2314         struct bt_stream *non_writer_stream2 = NULL;
2315         struct bt_event_class *writer_ec = NULL;
2316         struct bt_event_class *non_writer_ec = NULL;
2317         struct bt_event *event = NULL;
2318         struct bt_event *event2 = NULL;
2319         struct bt_field_type *empty_struct_ft = NULL;
2320         struct bt_field *int_field = NULL;
2321         struct bt_ctf_clock *writer_clock = NULL;
2322         struct bt_clock_class *non_writer_clock_class = NULL;
2323         struct bt_packet *packet = NULL;
2324         struct bt_packet *packet2 = NULL;
2325
2326         trace_path = g_build_filename(g_get_tmp_dir(), "ctfwriter_XXXXXX", NULL);
2327         if (!bt_mkdtemp(trace_path)) {
2328                 perror("# perror");
2329         }
2330
2331         /* Create empty structure field type (event header) */
2332         empty_struct_ft = bt_field_type_structure_create();
2333         assert(empty_struct_ft);
2334
2335         /* Create writer, writer stream class, stream, and clock */
2336         writer = bt_ctf_writer_create(trace_path);
2337         assert(writer);
2338         writer_clock = bt_ctf_clock_create("writer_clock");
2339         assert(writer_clock);
2340         ret = bt_ctf_writer_add_clock(writer, writer_clock);
2341         assert(!ret);
2342         ret = bt_ctf_writer_set_byte_order(writer, BT_BYTE_ORDER_LITTLE_ENDIAN);
2343         assert(!ret);
2344         writer_trace = bt_ctf_writer_get_trace(writer);
2345         ok(writer_trace, "bt_ctf_writer_get_trace() returns a trace");
2346         writer_sc = bt_stream_class_create("writer_sc");
2347         assert(writer_sc);
2348         ret = bt_stream_class_set_event_header_type(writer_sc,
2349                 empty_struct_ft);
2350         assert(!ret);
2351         ret = bt_stream_class_set_clock(writer_sc, writer_clock);
2352         assert(!ret);
2353         ret = bt_trace_add_stream_class(writer_trace, writer_sc);
2354         assert(!ret);
2355         writer_stream = bt_stream_create(writer_sc, writer_stream_name);
2356         assert(writer_stream);
2357         ok(!strcmp(bt_stream_get_name(writer_stream), writer_stream_name),
2358                 "bt_stream_get_name() returns the stream's name");
2359
2360         /* Create non-writer trace, stream class, stream, and clock */
2361         non_writer_trace = bt_trace_create();
2362         assert(non_writer_trace);
2363         non_writer_sc = bt_stream_class_create("nonwriter_sc");
2364         assert(non_writer_sc);
2365         ret = bt_stream_class_set_event_header_type(non_writer_sc,
2366                 empty_struct_ft);
2367         assert(!ret);
2368         ret = bt_stream_class_set_packet_context_type(non_writer_sc, NULL);
2369         assert(!ret);
2370         ret = bt_trace_add_stream_class(non_writer_trace, non_writer_sc);
2371         assert(!ret);
2372         non_writer_stream = bt_stream_create(non_writer_sc, NULL);
2373         assert(non_writer_stream);
2374         non_writer_clock_class =
2375                 bt_clock_class_create("non_writer_clock_class",
2376                         1000000000);
2377         assert(non_writer_clock_class);
2378         ret = bt_trace_add_clock_class(non_writer_trace,
2379                 non_writer_clock_class);
2380         assert(!ret);
2381
2382         /* Create event class and event */
2383         writer_ec = create_minimal_event_class();
2384         assert(writer_ec);
2385         ret = bt_stream_class_add_event_class(writer_sc, writer_ec);
2386         assert(!ret);
2387         event = bt_event_create(writer_ec);
2388         assert(event);
2389         int_field = bt_event_get_payload_by_index(event, 0);
2390         assert(int_field);
2391         bt_field_unsigned_integer_set_value(int_field, 17);
2392
2393         /*
2394          * Verify non-writer stream: it should be impossible to append
2395          * an event to it.
2396          */
2397         ok(bt_stream_append_event(non_writer_stream, event),
2398                 "bt_stream_append_event() fails with a non-writer stream");
2399
2400         /*
2401          * Verify writer stream: it should be possible to append an
2402          * event to it.
2403          */
2404         ok(!bt_stream_append_event(writer_stream, event),
2405                 "bt_stream_append_event() succeeds with a writer stream");
2406
2407         /*
2408          * It should be possible to create a packet from a non-writer
2409          * stream, but not from a writer stream.
2410          */
2411         packet = bt_packet_create(non_writer_stream);
2412         ok(packet, "bt_packet_create() succeeds with a non-writer stream");
2413         packet_stream = bt_packet_get_stream(packet);
2414         ok(packet_stream == non_writer_stream,
2415                 "bt_packet_get_stream() returns the correct stream");
2416
2417         /*
2418          * It should not be possible to append an event associated to
2419          * a stream to a different stream.
2420          */
2421         writer_stream2 = bt_stream_create(writer_sc, "zoo");
2422         assert(writer_stream2);
2423
2424         /*
2425          * It should be possible to set the packet of a fresh event, as
2426          * long as the originating stream classes are the same.
2427          */
2428         event2 = bt_event_create(writer_ec);
2429         assert(event2);
2430         non_writer_ec = create_minimal_event_class();
2431         assert(non_writer_ec);
2432         ret = bt_stream_class_add_event_class(non_writer_sc, non_writer_ec);
2433         assert(!ret);
2434         BT_PUT(event2);
2435         event2 = bt_event_create(non_writer_ec);
2436         assert(event2);
2437         ok(!bt_event_set_packet(event2, packet),
2438                 "bt_event_set_packet() succeeds when the event's and the packet's stream class are the same");
2439
2440         /*
2441          * It should be possible to set a packet created from the same
2442          * stream to an event with an existing packet.
2443          */
2444         packet2 = bt_packet_create(non_writer_stream);
2445         assert(packet2);
2446         ok(!bt_event_set_packet(event2, packet2),
2447                 "bt_event_set_packet() succeeds when the event's current packet has the same stream");
2448         BT_PUT(packet2);
2449
2450         /*
2451          * It should not be possible to set a packet created from a
2452          * different stream to an event with an existing packet.
2453          */
2454         non_writer_stream2 = bt_stream_create(non_writer_sc, "rj45");
2455         assert(non_writer_stream2);
2456         packet2 = bt_packet_create(non_writer_stream);
2457         assert(packet2);
2458
2459         bt_put(writer);
2460         bt_put(writer_trace);
2461         bt_put(writer_sc);
2462         bt_put(writer_stream);
2463         bt_put(writer_stream2);
2464         bt_put(non_writer_trace);
2465         bt_put(non_writer_sc);
2466         bt_put(non_writer_stream);
2467         bt_put(non_writer_stream2);
2468         bt_put(packet_stream);
2469         bt_put(writer_ec);
2470         bt_put(non_writer_ec);
2471         bt_put(event);
2472         bt_put(event2);
2473         bt_put(int_field);
2474         bt_put(empty_struct_ft);
2475         bt_put(writer_clock);
2476         bt_put(non_writer_clock_class);
2477         bt_put(packet);
2478         bt_put(packet2);
2479         recursive_rmdir(trace_path);
2480         g_free(trace_path);
2481 }
2482
2483 static
2484 void test_clock_utils(void)
2485 {
2486         int ret;
2487         struct bt_ctf_clock *clock = NULL;
2488
2489         clock = bt_ctf_clock_create("water");
2490         assert(clock);
2491         ret = bt_ctf_clock_set_offset_s(clock, 1234);
2492         assert(!ret);
2493         ret = bt_ctf_clock_set_offset(clock, 1000);
2494         assert(!ret);
2495         ret = bt_ctf_clock_set_frequency(clock, 1000000000);
2496         assert(!ret);
2497         ret = bt_ctf_clock_set_frequency(clock, 1534);
2498         assert(!ret);
2499
2500         BT_PUT(clock);
2501 }
2502
2503 void test_set_clock_non_writer_stream_class(void)
2504 {
2505         struct bt_ctf_clock *clock;
2506         struct bt_trace *trace;
2507         struct bt_stream_class *sc;
2508         int ret;
2509
2510         clock = bt_ctf_clock_create("the_clock");
2511         assert(clock);
2512
2513         trace = bt_trace_create();
2514         assert(trace);
2515
2516         sc = bt_stream_class_create(NULL);
2517         assert(sc);
2518
2519         ret = bt_stream_class_set_clock(sc, clock);
2520         assert(ret == 0);
2521
2522         ret = bt_trace_add_stream_class(trace, sc);
2523         ok(ret < 0,
2524                 "bt_trace_add_stream_class() fails with a stream class with a registered clock");
2525
2526         bt_put(clock);
2527         bt_put(trace);
2528         bt_put(sc);
2529 }
2530
2531 static
2532 void test_static_trace(void)
2533 {
2534         struct bt_trace *trace;
2535         struct bt_stream_class *stream_class;
2536         struct bt_stream_class *stream_class2;
2537         struct bt_stream *stream;
2538         struct bt_clock_class *clock_class;
2539         int ret;
2540
2541         trace = bt_trace_create();
2542         assert(trace);
2543         stream_class = bt_stream_class_create(NULL);
2544         assert(stream_class);
2545         ret = bt_stream_class_set_packet_context_type(stream_class, NULL);
2546         assert(ret == 0);
2547         ret = bt_trace_add_stream_class(trace, stream_class);
2548         assert(ret == 0);
2549         stream = bt_stream_create(stream_class, "hello");
2550         ok(stream, "bt_stream_create() succeeds with a non-static trace");
2551         bt_put(stream);
2552         ok(!bt_trace_is_static(trace),
2553                 "bt_trace_is_static() returns the expected value");
2554         ok(bt_trace_set_is_static(trace) == 0,
2555                 "bt_trace_set_is_static() succeeds");
2556         ok(bt_trace_is_static(trace),
2557                 "bt_trace_is_static() returns the expected value");
2558         clock_class = bt_clock_class_create("yes", 1000000000);
2559         assert(clock_class);
2560         stream_class2 = bt_stream_class_create(NULL);
2561         assert(stream_class2);
2562         ok(bt_trace_add_stream_class(trace, stream_class2),
2563                 "bt_trace_add_stream_class() fails with a static trace");
2564         ok(bt_trace_add_clock_class(trace, clock_class),
2565                 "bt_trace_add_clock_class() fails with a static trace");
2566         ok(!bt_stream_create(stream_class, "hello2"),
2567                 "bt_stream_create() fails with a static trace");
2568
2569         bt_put(trace);
2570         bt_put(stream_class);
2571         bt_put(stream_class2);
2572         bt_put(clock_class);
2573 }
2574
2575 static
2576 void trace_is_static_listener(struct bt_trace *trace, void *data)
2577 {
2578         *((int *) data) |= 1;
2579 }
2580
2581 static
2582 void trace_listener_removed(struct bt_trace *trace, void *data)
2583 {
2584         *((int *) data) |= 2;
2585 }
2586
2587 static
2588 void test_trace_is_static_listener(void)
2589 {
2590         struct bt_trace *trace;
2591         int ret;
2592         int called1 = 0;
2593         int called2 = 0;
2594         int called3 = 0;
2595         int called4 = 0;
2596         int listener1_id;
2597         int listener2_id;
2598         int listener3_id;
2599         int listener4_id;
2600
2601         trace = bt_trace_create();
2602         assert(trace);
2603         ret = bt_trace_add_is_static_listener(NULL,
2604                 trace_is_static_listener, trace_listener_removed, &called1);
2605         ok(ret < 0, "bt_trace_add_is_static_listener() handles NULL (trace)");
2606         ret = bt_trace_add_is_static_listener(trace, NULL,
2607                 trace_listener_removed, &called1);
2608         ok(ret < 0, "bt_trace_add_is_static_listener() handles NULL (listener)");
2609         listener1_id = bt_trace_add_is_static_listener(trace,
2610                 trace_is_static_listener, trace_listener_removed, &called1);
2611         ok(listener1_id >= 0, "bt_trace_add_is_static_listener() succeeds (1)");
2612         listener2_id = bt_trace_add_is_static_listener(trace,
2613                 trace_is_static_listener, trace_listener_removed, &called2);
2614         ok(listener2_id >= 0, "bt_trace_add_is_static_listener() succeeds (2)");
2615         listener3_id = bt_trace_add_is_static_listener(trace,
2616                 trace_is_static_listener, trace_listener_removed, &called3);
2617         ok(listener3_id >= 0, "bt_trace_add_is_static_listener() succeeds (3)");
2618         ret = bt_trace_remove_is_static_listener(NULL, 0);
2619         ok(ret < 0, "bt_trace_remove_is_static_listener() handles NULL (trace)");
2620         ret = bt_trace_remove_is_static_listener(trace, -2);
2621         ok(ret < 0, "bt_trace_remove_is_static_listener() handles invalid ID (negative)");
2622         ret = bt_trace_remove_is_static_listener(trace, 77);
2623         ok(ret < 0, "bt_trace_remove_is_static_listener() handles invalid ID (non existing)");
2624         ret = bt_trace_remove_is_static_listener(trace, listener2_id);
2625         ok(ret == 0, "bt_trace_remove_is_static_listener() succeeds");
2626         ok(called2 == 2, "bt_trace_remove_is_static_listener() calls the remove listener");
2627         listener4_id = bt_trace_add_is_static_listener(trace,
2628                 trace_is_static_listener, NULL, &called4);
2629         ok(listener4_id >= 0, "bt_trace_add_is_static_listener() succeeds (4)");
2630         ok(called1 == 0, "\"trace is static\" listener not called before the trace is made static (1)");
2631         ok(called2 == 2, "\"trace is static\" listener not called before the trace is made static (2)");
2632         ok(called3 == 0, "\"trace is static\" listener not called before the trace is made static (3)");
2633         ok(called4 == 0, "\"trace is static\" listener not called before the trace is made static (4)");
2634         ret = bt_trace_set_is_static(trace);
2635         assert(ret == 0);
2636         ret = bt_trace_add_is_static_listener(trace,
2637                 trace_is_static_listener, trace_listener_removed, &called1);
2638         ok(ret < 0,
2639                 "bt_trace_add_is_static_listener() fails when the trace is static");
2640         ok(called1 == 1, "\"trace is static\" listener called when the trace is made static (1)");
2641         ok(called2 == 2, "\"trace is static\" listener not called when the trace is made static (2)");
2642         ok(called3 == 1, "\"trace is static\" listener called when the trace is made static (3)");
2643         ok(called4 == 1, "\"trace is static\" listener called when the trace is made static (4)");
2644         called1 = 0;
2645         called2 = 0;
2646         called3 = 0;
2647         called4 = 0;
2648         bt_put(trace);
2649         ok(called1 == 2, "\"trace is static\" listener not called after the trace is put (1)");
2650         ok(called2 == 0, "\"trace is static\" listener not called after the trace is put (2)");
2651         ok(called3 == 2, "\"trace is static\" listener not called after the trace is put (3)");
2652         ok(called4 == 0, "\"trace is static\" listener not called after the trace is put (4)");
2653 }
2654
2655 static
2656 void test_trace_uuid(void)
2657 {
2658         struct bt_trace *trace;
2659         const unsigned char uuid[] = {
2660                 0x35, 0x92, 0x63, 0xab, 0xb4, 0xbe, 0x40, 0xb4,
2661                 0xb2, 0x60, 0xd3, 0xf1, 0x3b, 0xb0, 0xd8, 0x59,
2662         };
2663         const unsigned char *ret_uuid;
2664
2665         trace = bt_trace_create();
2666         assert(trace);
2667         ok(!bt_trace_get_uuid(NULL),
2668                 "bt_trace_get_uuid() handles NULL");
2669         ok(!bt_trace_get_uuid(trace),
2670                 "bt_trace_get_uuid() returns NULL initially");
2671         ok(bt_trace_set_uuid(NULL, uuid),
2672                 "bt_trace_set_uuid() handles NULL (trace)");
2673         ok(bt_trace_set_uuid(trace, NULL),
2674                 "bt_trace_set_uuid() handles NULL (UUID)");
2675         ok(bt_trace_set_uuid(trace, uuid) == 0,
2676                 "bt_trace_set_uuid() succeeds with a valid UUID");
2677         ret_uuid = bt_trace_get_uuid(trace);
2678         ok(ret_uuid, "bt_trace_get_uuid() returns a UUID");
2679         assert(ret_uuid);
2680         ok(memcmp(uuid, ret_uuid, 16) == 0,
2681                 "bt_trace_get_uuid() returns the expected UUID");
2682
2683         bt_put(trace);
2684 }
2685
2686 int main(int argc, char **argv)
2687 {
2688         const char *env_resize_length;
2689         gchar *trace_path;
2690         gchar *metadata_path;
2691         const char *clock_name = "test_clock";
2692         const char *clock_description = "This is a test clock";
2693         const char *returned_clock_name;
2694         const char *returned_clock_description;
2695         const uint64_t frequency = 1123456789;
2696         const int64_t offset_s = 13515309;
2697         const int64_t offset = 1234567;
2698         int64_t get_offset_s,
2699                 get_offset;
2700         const uint64_t precision = 10;
2701         const int is_absolute = 0xFF;
2702         char *metadata_string;
2703         struct bt_ctf_writer *writer;
2704         struct bt_utsname name = {"GNU/Linux", "testhost", "4.4.0-87-generic",
2705                 "#110-Ubuntu SMP Tue Jul 18 12:55:35 UTC 2017", "x86_64"};
2706         struct bt_ctf_clock *clock, *ret_clock;
2707         struct bt_clock_class *ret_clock_class;
2708         struct bt_stream_class *stream_class, *ret_stream_class;
2709         struct bt_stream *stream1;
2710         struct bt_stream *stream;
2711         const char *ret_string;
2712         const unsigned char *ret_uuid;
2713         unsigned char tmp_uuid[16] = { 0 };
2714         struct bt_field_type *packet_context_type,
2715                 *packet_context_field_type,
2716                 *packet_header_type,
2717                 *packet_header_field_type,
2718                 *integer_type,
2719                 *stream_event_context_type,
2720                 *ret_field_type,
2721                 *event_header_field_type;
2722         struct bt_field *packet_header, *packet_header_field;
2723         struct bt_trace *trace;
2724         int ret;
2725         int64_t ret_int64_t;
2726         struct bt_value *obj;
2727
2728         if (argc < 2) {
2729                 printf("Usage: tests-ctf-writer path_to_babeltrace\n");
2730                 return -1;
2731         }
2732
2733         env_resize_length = getenv("PACKET_RESIZE_TEST_LENGTH");
2734         if (env_resize_length) {
2735                 packet_resize_test_length =
2736                         (unsigned int) atoi(env_resize_length);
2737         }
2738
2739         plan_tests(NR_TESTS);
2740
2741         trace_path = g_build_filename(g_get_tmp_dir(), "ctfwriter_XXXXXX", NULL);
2742         if (!bt_mkdtemp(trace_path)) {
2743                 perror("# perror");
2744         }
2745
2746         metadata_path = g_build_filename(trace_path, "metadata", NULL);
2747
2748         writer = bt_ctf_writer_create(trace_path);
2749         ok(writer, "bt_create succeeds in creating trace with path");
2750
2751         ok(!bt_ctf_writer_get_trace(NULL),
2752                 "bt_ctf_writer_get_trace correctly handles NULL");
2753         trace = bt_ctf_writer_get_trace(writer);
2754         ok(bt_trace_set_native_byte_order(trace, BT_BYTE_ORDER_NATIVE),
2755                 "Cannot set a trace's byte order to BT_BYTE_ORDER_NATIVE");
2756         ok(bt_trace_set_native_byte_order(trace, BT_BYTE_ORDER_UNSPECIFIED),
2757                 "Cannot set a trace's byte order to BT_BYTE_ORDER_UNSPECIFIED");
2758         ok(trace,
2759                 "bt_ctf_writer_get_trace returns a bt_trace object");
2760         ok(bt_trace_set_native_byte_order(trace, BT_BYTE_ORDER_BIG_ENDIAN) == 0,
2761                 "Set a trace's byte order to big endian");
2762         ok(bt_trace_get_native_byte_order(trace) == BT_BYTE_ORDER_BIG_ENDIAN,
2763                 "bt_trace_get_native_byte_order returns a correct endianness");
2764
2765         /* Add environment context to the trace */
2766         ok(bt_ctf_writer_add_environment_field(writer, "host", name.nodename) == 0,
2767                 "Add host (%s) environment field to writer instance",
2768                 name.nodename);
2769         ok(bt_ctf_writer_add_environment_field(NULL, "test_field",
2770                 "test_value"),
2771                 "bt_ctf_writer_add_environment_field error with NULL writer");
2772         ok(bt_ctf_writer_add_environment_field(writer, NULL,
2773                 "test_value"),
2774                 "bt_ctf_writer_add_environment_field error with NULL field name");
2775         ok(bt_ctf_writer_add_environment_field(writer, "test_field",
2776                 NULL),
2777                 "bt_ctf_writer_add_environment_field error with NULL field value");
2778
2779         /* Test bt_trace_set_environment_field with an integer object */
2780         obj = bt_value_integer_create_init(23);
2781         assert(obj);
2782         ok(bt_trace_set_environment_field(NULL, "test_env_int_obj", obj),
2783                 "bt_trace_set_environment_field handles a NULL trace correctly");
2784         ok(bt_trace_set_environment_field(trace, NULL, obj),
2785                 "bt_trace_set_environment_field handles a NULL name correctly");
2786         ok(bt_trace_set_environment_field(trace, "test_env_int_obj", NULL),
2787                 "bt_trace_set_environment_field handles a NULL value correctly");
2788         ok(!bt_trace_set_environment_field(trace, "test_env_int_obj", obj),
2789                 "bt_trace_set_environment_field succeeds in adding an integer object");
2790         BT_PUT(obj);
2791
2792         /* Test bt_trace_set_environment_field with a string object */
2793         obj = bt_value_string_create_init("the value");
2794         assert(obj);
2795         ok(!bt_trace_set_environment_field(trace, "test_env_str_obj", obj),
2796                 "bt_trace_set_environment_field succeeds in adding a string object");
2797         BT_PUT(obj);
2798
2799         /* Test bt_trace_set_environment_field_integer */
2800         ok(bt_trace_set_environment_field_integer(NULL, "test_env_int",
2801                 -194875),
2802                 "bt_trace_set_environment_field_integer handles a NULL trace correctly");
2803         ok(bt_trace_set_environment_field_integer(trace, NULL, -194875),
2804                 "bt_trace_set_environment_field_integer handles a NULL name correctly");
2805         ok(!bt_trace_set_environment_field_integer(trace, "test_env_int",
2806                 -164973),
2807                 "bt_trace_set_environment_field_integer succeeds");
2808
2809         /* Test bt_trace_set_environment_field_string */
2810         ok(bt_trace_set_environment_field_string(NULL, "test_env_str",
2811                 "yeah"),
2812                 "bt_trace_set_environment_field_string handles a NULL trace correctly");
2813         ok(bt_trace_set_environment_field_string(trace, NULL, "yeah"),
2814                 "bt_trace_set_environment_field_string handles a NULL name correctly");
2815         ok(bt_trace_set_environment_field_string(trace, "test_env_str",
2816                 NULL),
2817                 "bt_trace_set_environment_field_string handles a NULL value correctly");
2818         ok(!bt_trace_set_environment_field_string(trace, "test_env_str",
2819                 "oh yeah"),
2820                 "bt_trace_set_environment_field_string succeeds");
2821
2822         /* Test bt_trace_get_environment_field_count */
2823         ok(bt_trace_get_environment_field_count(NULL) < 0,
2824                 "bt_trace_get_environment_field_count handles a NULL trace correctly");
2825         ok(bt_trace_get_environment_field_count(trace) == 5,
2826                 "bt_trace_get_environment_field_count returns a correct number of environment fields");
2827
2828         /* Test bt_trace_get_environment_field_name */
2829         ok(bt_trace_get_environment_field_name_by_index(NULL, 0) == NULL,
2830                 "bt_trace_get_environment_field_name handles a NULL trace correctly");
2831         ok(bt_trace_get_environment_field_name_by_index(trace, 5) == NULL,
2832                 "bt_trace_get_environment_field_name handles an invalid index correctly (too large)");
2833         ret_string = bt_trace_get_environment_field_name_by_index(trace, 0);
2834         ok(ret_string && !strcmp(ret_string, "host"),
2835                 "bt_trace_get_environment_field_name returns a correct field name");
2836         ret_string = bt_trace_get_environment_field_name_by_index(trace, 1);
2837         ok(ret_string && !strcmp(ret_string, "test_env_int_obj"),
2838                 "bt_trace_get_environment_field_name returns a correct field name");
2839         ret_string = bt_trace_get_environment_field_name_by_index(trace, 2);
2840         ok(ret_string && !strcmp(ret_string, "test_env_str_obj"),
2841                 "bt_trace_get_environment_field_name returns a correct field name");
2842         ret_string = bt_trace_get_environment_field_name_by_index(trace, 3);
2843         ok(ret_string && !strcmp(ret_string, "test_env_int"),
2844                 "bt_trace_get_environment_field_name returns a correct field name");
2845         ret_string = bt_trace_get_environment_field_name_by_index(trace, 4);
2846         ok(ret_string && !strcmp(ret_string, "test_env_str"),
2847                 "bt_trace_get_environment_field_name returns a correct field name");
2848
2849         /* Test bt_trace_get_environment_field_value */
2850         ok(bt_trace_get_environment_field_value_by_index(NULL, 0) == NULL,
2851                 "bt_trace_get_environment_field_value handles a NULL trace correctly");
2852         ok(bt_trace_get_environment_field_value_by_index(trace, 5) == NULL,
2853                 "bt_trace_get_environment_field_value handles an invalid index correctly (too large)");
2854         obj = bt_trace_get_environment_field_value_by_index(trace, 1);
2855         ret = bt_value_integer_get(obj, &ret_int64_t);
2856         ok(!ret && ret_int64_t == 23,
2857                 "bt_trace_get_environment_field_value succeeds in getting an integer value");
2858         BT_PUT(obj);
2859         obj = bt_trace_get_environment_field_value_by_index(trace, 2);
2860         ret = bt_value_string_get(obj, &ret_string);
2861         ok(!ret && ret_string && !strcmp(ret_string, "the value"),
2862                 "bt_trace_get_environment_field_value succeeds in getting a string value");
2863         BT_PUT(obj);
2864
2865         /* Test bt_trace_get_environment_field_value_by_name */
2866         ok(!bt_trace_get_environment_field_value_by_name(NULL,
2867                 "test_env_str"),
2868                 "bt_trace_get_environment_field_value_by_name handles a NULL trace correctly");
2869         ok(!bt_trace_get_environment_field_value_by_name(trace, NULL),
2870                 "bt_trace_get_environment_field_value_by_name handles a NULL name correctly");
2871         ok(!bt_trace_get_environment_field_value_by_name(trace, "oh oh"),
2872                 "bt_trace_get_environment_field_value_by_name returns NULL or an unknown field name");
2873         obj = bt_trace_get_environment_field_value_by_name(trace,
2874                 "test_env_str");
2875         ret = bt_value_string_get(obj, &ret_string);
2876         ok(!ret && ret_string && !strcmp(ret_string, "oh yeah"),
2877                 "bt_trace_get_environment_field_value_by_name succeeds in getting an existing field");
2878         BT_PUT(obj);
2879
2880         /* Test environment field replacement */
2881         ok(!bt_trace_set_environment_field_integer(trace, "test_env_int",
2882                 654321),
2883                 "bt_trace_set_environment_field_integer succeeds with an existing name");
2884         ok(bt_trace_get_environment_field_count(trace) == 5,
2885                 "bt_trace_set_environment_field_integer with an existing key does not increase the environment size");
2886         obj = bt_trace_get_environment_field_value_by_index(trace, 3);
2887         ret = bt_value_integer_get(obj, &ret_int64_t);
2888         ok(!ret && ret_int64_t == 654321,
2889                 "bt_trace_get_environment_field_value successfully replaces an existing field");
2890         BT_PUT(obj);
2891
2892         ok(bt_ctf_writer_add_environment_field(writer, "sysname", name.sysname)
2893                 == 0, "Add sysname (%s) environment field to writer instance",
2894                 name.sysname);
2895         ok(bt_ctf_writer_add_environment_field(writer, "nodename",
2896                 name.nodename) == 0,
2897                 "Add nodename (%s) environment field to writer instance",
2898                 name.nodename);
2899         ok(bt_ctf_writer_add_environment_field(writer, "release", name.release)
2900                 == 0, "Add release (%s) environment field to writer instance",
2901                 name.release);
2902         ok(bt_ctf_writer_add_environment_field(writer, "version", name.version)
2903                 == 0, "Add version (%s) environment field to writer instance",
2904                 name.version);
2905         ok(bt_ctf_writer_add_environment_field(writer, "machine", name.machine)
2906                 == 0, "Add machine (%s) environment field to writer istance",
2907                 name.machine);
2908
2909         /* Define a clock and add it to the trace */
2910         ok(bt_ctf_clock_create("signed") == NULL,
2911                 "Illegal clock name rejected");
2912         clock = bt_ctf_clock_create(clock_name);
2913         ok(clock, "Clock created sucessfully");
2914         returned_clock_name = bt_ctf_clock_get_name(clock);
2915         ok(returned_clock_name, "bt_ctf_clock_get_name returns a clock name");
2916         ok(returned_clock_name ? !strcmp(returned_clock_name, clock_name) : 0,
2917                 "Returned clock name is valid");
2918
2919         returned_clock_description = bt_ctf_clock_get_description(clock);
2920         ok(!returned_clock_description, "bt_ctf_clock_get_description returns NULL on an unset description");
2921         ok(bt_ctf_clock_set_description(clock, clock_description) == 0,
2922                 "Clock description set successfully");
2923
2924         returned_clock_description = bt_ctf_clock_get_description(clock);
2925         ok(returned_clock_description,
2926                 "bt_ctf_clock_get_description returns a description.");
2927         ok(returned_clock_description ?
2928                 !strcmp(returned_clock_description, clock_description) : 0,
2929                 "Returned clock description is valid");
2930
2931         ok(bt_ctf_clock_get_frequency(clock) == DEFAULT_CLOCK_FREQ,
2932                 "bt_ctf_clock_get_frequency returns the correct default frequency");
2933         ok(bt_ctf_clock_set_frequency(clock, frequency) == 0,
2934                 "Set clock frequency");
2935         ok(bt_ctf_clock_get_frequency(clock) == frequency,
2936                 "bt_ctf_clock_get_frequency returns the correct frequency once it is set");
2937
2938         ok(bt_ctf_clock_get_offset_s(clock, &get_offset_s) == 0,
2939                 "bt_ctf_clock_get_offset_s succeeds");
2940         ok(get_offset_s == DEFAULT_CLOCK_OFFSET_S,
2941                 "bt_ctf_clock_get_offset_s returns the correct default offset (in seconds)");
2942         ok(bt_ctf_clock_set_offset_s(clock, offset_s) == 0,
2943                 "Set clock offset (seconds)");
2944         ok(bt_ctf_clock_get_offset_s(clock, &get_offset_s) == 0,
2945                 "bt_ctf_clock_get_offset_s succeeds");
2946         ok(get_offset_s == offset_s,
2947                 "bt_ctf_clock_get_offset_s returns the correct default offset (in seconds) once it is set");
2948
2949         ok(bt_ctf_clock_get_offset(clock, &get_offset) == 0,
2950                 "bt_ctf_clock_get_offset succeeds");
2951         ok(get_offset == DEFAULT_CLOCK_OFFSET,
2952                 "bt_ctf_clock_get_offset returns the correct default offset (in ticks)");
2953         ok(bt_ctf_clock_set_offset(clock, offset) == 0, "Set clock offset");
2954         ok(bt_ctf_clock_get_offset(clock, &get_offset) == 0,
2955                 "bt_ctf_clock_get_offset succeeds");
2956         ok(get_offset == offset,
2957                 "bt_ctf_clock_get_offset returns the correct default offset (in ticks) once it is set");
2958
2959         ok(bt_ctf_clock_get_precision(clock) == DEFAULT_CLOCK_PRECISION,
2960                 "bt_ctf_clock_get_precision returns the correct default precision");
2961         ok(bt_ctf_clock_set_precision(clock, precision) == 0,
2962                 "Set clock precision");
2963         ok(bt_ctf_clock_get_precision(clock) == precision,
2964                 "bt_ctf_clock_get_precision returns the correct precision once it is set");
2965
2966         ok(bt_ctf_clock_get_is_absolute(clock) == DEFAULT_CLOCK_IS_ABSOLUTE,
2967                 "bt_ctf_clock_get_precision returns the correct default is_absolute attribute");
2968         ok(bt_ctf_clock_set_is_absolute(clock, is_absolute) == 0,
2969                 "Set clock absolute property");
2970         ok(bt_ctf_clock_get_is_absolute(clock) == !!is_absolute,
2971                 "bt_ctf_clock_get_precision returns the correct is_absolute attribute once it is set");
2972
2973         ok(bt_ctf_clock_set_time(clock, current_time) == 0,
2974                 "Set clock time");
2975
2976         ret_uuid = bt_ctf_clock_get_uuid(clock);
2977         ok(ret_uuid,
2978                 "bt_ctf_clock_get_uuid returns a UUID");
2979         if (ret_uuid) {
2980                 memcpy(tmp_uuid, ret_uuid, sizeof(tmp_uuid));
2981                 /* Slightly modify UUID */
2982                 tmp_uuid[sizeof(tmp_uuid) - 1]++;
2983         }
2984
2985         ok(bt_ctf_clock_set_uuid(clock, tmp_uuid) == 0,
2986                 "bt_ctf_clock_set_uuid sets a new uuid successfully");
2987         ret_uuid = bt_ctf_clock_get_uuid(clock);
2988         ok(ret_uuid,
2989                 "bt_ctf_clock_get_uuid returns a UUID after setting a new one");
2990         ok(uuid_match(ret_uuid, tmp_uuid),
2991                 "bt_ctf_clock_get_uuid returns the correct UUID after setting a new one");
2992
2993         /* Define a stream class */
2994         stream_class = bt_stream_class_create("test_stream");
2995
2996         ok(bt_stream_class_get_name(NULL) == NULL,
2997                 "bt_stream_class_get_name handles NULL correctly");
2998         ret_string = bt_stream_class_get_name(stream_class);
2999         ok(ret_string && !strcmp(ret_string, "test_stream"),
3000                 "bt_stream_class_get_name returns a correct stream class name");
3001
3002         ok(bt_stream_class_get_clock(stream_class) == NULL,
3003                 "bt_stream_class_get_clock returns NULL when a clock was not set");
3004         ok(bt_stream_class_get_clock(NULL) == NULL,
3005                 "bt_stream_class_get_clock handles NULL correctly");
3006
3007         ok(stream_class, "Create stream class");
3008         ok(bt_stream_class_set_clock(stream_class, clock) == 0,
3009                 "Set a stream class' clock");
3010         ret_clock = bt_stream_class_get_clock(stream_class);
3011         ok(ret_clock == clock,
3012                 "bt_stream_class_get_clock returns a correct clock");
3013         bt_put(ret_clock);
3014
3015         /* Test the event fields and event types APIs */
3016         type_field_tests();
3017
3018         /* Test fields copying */
3019         field_copy_tests();
3020
3021         ok(bt_stream_class_get_id(stream_class) < 0,
3022                 "bt_stream_class_get_id returns an error when no id is set");
3023         ok(bt_stream_class_get_id(NULL) < 0,
3024                 "bt_stream_class_get_id handles NULL correctly");
3025         ok(bt_stream_class_set_id(NULL, 123) < 0,
3026                 "bt_stream_class_set_id handles NULL correctly");
3027         ok(bt_stream_class_set_id(stream_class, 123) == 0,
3028                 "Set an stream class' id");
3029         ok(bt_stream_class_get_id(stream_class) == 123,
3030                 "bt_stream_class_get_id returns the correct value");
3031
3032         /* Validate default event header fields */
3033         ok(bt_stream_class_get_event_header_type(NULL) == NULL,
3034                 "bt_stream_class_get_event_header_type handles NULL correctly");
3035         ret_field_type = bt_stream_class_get_event_header_type(
3036                 stream_class);
3037         ok(ret_field_type,
3038                 "bt_stream_class_get_event_header_type returns an event header type");
3039         ok(bt_field_type_get_type_id(ret_field_type) == BT_FIELD_TYPE_ID_STRUCT,
3040                 "Default event header type is a structure");
3041         event_header_field_type =
3042                 bt_field_type_structure_get_field_type_by_name(
3043                 ret_field_type, "id");
3044         ok(event_header_field_type,
3045                 "Default event header type contains an \"id\" field");
3046         ok(bt_field_type_get_type_id(
3047                 event_header_field_type) == BT_FIELD_TYPE_ID_INTEGER,
3048                 "Default event header \"id\" field is an integer");
3049         bt_put(event_header_field_type);
3050         event_header_field_type =
3051                 bt_field_type_structure_get_field_type_by_name(
3052                 ret_field_type, "timestamp");
3053         ok(event_header_field_type,
3054                 "Default event header type contains a \"timestamp\" field");
3055         ok(bt_field_type_get_type_id(
3056                 event_header_field_type) == BT_FIELD_TYPE_ID_INTEGER,
3057                 "Default event header \"timestamp\" field is an integer");
3058         bt_put(event_header_field_type);
3059         bt_put(ret_field_type);
3060
3061         /* Add a custom trace packet header field */
3062         ok(bt_trace_get_packet_header_type(NULL) == NULL,
3063                 "bt_trace_get_packet_header_type handles NULL correctly");
3064         packet_header_type = bt_trace_get_packet_header_type(trace);
3065         ok(packet_header_type,
3066                 "bt_trace_get_packet_header_type returns a packet header");
3067         ok(bt_field_type_get_type_id(packet_header_type) == BT_FIELD_TYPE_ID_STRUCT,
3068                 "bt_trace_get_packet_header_type returns a packet header of type struct");
3069         ret_field_type = bt_field_type_structure_get_field_type_by_name(
3070                 packet_header_type, "magic");
3071         ok(ret_field_type, "Default packet header type contains a \"magic\" field");
3072         bt_put(ret_field_type);
3073         ret_field_type = bt_field_type_structure_get_field_type_by_name(
3074                 packet_header_type, "uuid");
3075         ok(ret_field_type, "Default packet header type contains a \"uuid\" field");
3076         bt_put(ret_field_type);
3077         ret_field_type = bt_field_type_structure_get_field_type_by_name(
3078                 packet_header_type, "stream_id");
3079         ok(ret_field_type, "Default packet header type contains a \"stream_id\" field");
3080         bt_put(ret_field_type);
3081
3082         packet_header_field_type = bt_field_type_integer_create(22);
3083         ok(!bt_field_type_structure_add_field(packet_header_type,
3084                 packet_header_field_type, "custom_trace_packet_header_field"),
3085                 "Added a custom trace packet header field successfully");
3086
3087         ok(bt_trace_set_packet_header_type(NULL, packet_header_type) < 0,
3088                 "bt_trace_set_packet_header_type handles a NULL trace correctly");
3089         ok(!bt_trace_set_packet_header_type(trace, packet_header_type),
3090                 "Set a trace packet_header_type successfully");
3091
3092         ok(bt_stream_class_get_packet_context_type(NULL) == NULL,
3093                 "bt_stream_class_get_packet_context_type handles NULL correctly");
3094
3095         /* Add a custom field to the stream class' packet context */
3096         packet_context_type = bt_stream_class_get_packet_context_type(stream_class);
3097         ok(packet_context_type,
3098                 "bt_stream_class_get_packet_context_type returns a packet context type.");
3099         ok(bt_field_type_get_type_id(packet_context_type) == BT_FIELD_TYPE_ID_STRUCT,
3100                 "Packet context is a structure");
3101
3102         ok(bt_stream_class_set_packet_context_type(NULL, packet_context_type),
3103                 "bt_stream_class_set_packet_context_type handles a NULL stream class correctly");
3104
3105         integer_type = bt_field_type_integer_create(32);
3106         ok(bt_stream_class_set_packet_context_type(stream_class,
3107                 integer_type) < 0,
3108                 "bt_stream_class_set_packet_context_type rejects a packet context that is not a structure");
3109         /* Create a "uint5_t" equivalent custom packet context field */
3110         packet_context_field_type = bt_field_type_integer_create(5);
3111
3112         ret = bt_field_type_structure_add_field(packet_context_type,
3113                 packet_context_field_type, "custom_packet_context_field");
3114         ok(ret == 0, "Packet context field added successfully");
3115
3116         /* Define a stream event context containing a my_integer field. */
3117         ok(bt_stream_class_get_event_context_type(NULL) == NULL,
3118                 "bt_stream_class_get_event_context_type handles NULL correctly");
3119         stream_event_context_type = bt_field_type_structure_create();
3120         bt_field_type_structure_add_field(stream_event_context_type,
3121                 integer_type, "common_event_context");
3122
3123         ok(bt_stream_class_set_event_context_type(NULL,
3124                 stream_event_context_type) < 0,
3125                 "bt_stream_class_set_event_context_type handles a NULL stream_class correctly");
3126         ok(bt_stream_class_set_event_context_type(stream_class,
3127                 integer_type) < 0,
3128                 "bt_stream_class_set_event_context_type validates that the event context os a structure");
3129
3130         ok(bt_stream_class_set_event_context_type(
3131                 stream_class, stream_event_context_type) == 0,
3132                 "Set a new stream event context type");
3133         ret_field_type = bt_stream_class_get_event_context_type(
3134                 stream_class);
3135         ok(ret_field_type == stream_event_context_type,
3136                 "bt_stream_class_get_event_context_type returns the correct field type.");
3137         bt_put(ret_field_type);
3138
3139         /* Instantiate a stream and append events */
3140         ret = bt_ctf_writer_add_clock(writer, clock);
3141         assert(ret == 0);
3142         ok(bt_trace_get_stream_count(trace) == 0,
3143                 "bt_trace_get_stream_count() succeeds and returns the correct value (0)");
3144         stream1 = bt_ctf_writer_create_stream(writer, stream_class);
3145         ok(stream1, "Instanciate a stream class from writer");
3146         ok(bt_trace_get_stream_count(trace) == 1,
3147                 "bt_trace_get_stream_count() succeeds and returns the correct value (1)");
3148         stream = bt_trace_get_stream_by_index(trace, 0);
3149         ok(stream == stream1,
3150                 "bt_trace_get_stream_by_index() succeeds and returns the correct value");
3151         BT_PUT(stream);
3152
3153         /*
3154          * Creating a stream through a writer adds the given stream
3155          * class to the writer's trace, thus registering the stream
3156          * class's clock to the trace.
3157          */
3158         ok(bt_trace_get_clock_class_count(NULL) < 0,
3159                 "bt_trace_get_clock_class_count correctly handles NULL");
3160         ok(bt_trace_get_clock_class_count(trace) == 1,
3161                 "bt_trace_get_clock_class_count returns the correct number of clocks");
3162         ok(!bt_trace_get_clock_class_by_index(NULL, 0),
3163                 "bt_trace_get_clock_class correctly handles NULL");
3164         ok(!bt_trace_get_clock_class_by_index(trace, 1),
3165                 "bt_trace_get_clock_class correctly handles out of bound accesses");
3166         ret_clock_class = bt_trace_get_clock_class_by_index(trace, 0);
3167         ok(strcmp(bt_clock_class_get_name(ret_clock_class),
3168                 bt_ctf_clock_get_name(clock)) == 0,
3169                 "bt_trace_get_clock_class returns the right clock instance");
3170         bt_put(ret_clock_class);
3171         ok(!bt_trace_get_clock_class_by_name(trace, NULL),
3172                 "bt_trace_get_clock_class_by_name correctly handles NULL (trace)");
3173         ok(!bt_trace_get_clock_class_by_name(NULL, clock_name),
3174                 "bt_trace_get_clock_by_name correctly handles NULL (clock name)");
3175         ok(!bt_trace_get_clock_class_by_name(NULL, NULL),
3176                 "bt_trace_get_clock_by_name correctly handles NULL (both)");
3177         ret_clock_class = bt_trace_get_clock_class_by_name(trace, clock_name);
3178         ok(strcmp(bt_clock_class_get_name(ret_clock_class),
3179                 bt_ctf_clock_get_name(clock)) == 0,
3180                 "bt_trace_get_clock_class returns the right clock instance");
3181         bt_put(ret_clock_class);
3182         ok(!bt_trace_get_clock_class_by_name(trace, "random"),
3183                 "bt_trace_get_clock_by_name fails when the requested clock doesn't exist");
3184
3185         ok(bt_stream_get_class(NULL) == NULL,
3186                 "bt_stream_get_class correctly handles NULL");
3187         ret_stream_class = bt_stream_get_class(stream1);
3188         ok(ret_stream_class,
3189                 "bt_stream_get_class returns a stream class");
3190         ok(ret_stream_class == stream_class,
3191                 "Returned stream class is of the correct type");
3192
3193         /*
3194          * Packet header, packet context, event header, and stream
3195          * event context types were copied for the resolving
3196          * process
3197          */
3198         BT_PUT(packet_header_type);
3199         BT_PUT(packet_context_type);
3200         BT_PUT(stream_event_context_type);
3201         packet_header_type = bt_trace_get_packet_header_type(trace);
3202         assert(packet_header_type);
3203         packet_context_type =
3204                 bt_stream_class_get_packet_context_type(stream_class);
3205         assert(packet_context_type);
3206         stream_event_context_type =
3207                 bt_stream_class_get_event_context_type(stream_class);
3208         assert(stream_event_context_type);
3209
3210         /*
3211          * Try to modify the packet context type after a stream has been
3212          * created.
3213          */
3214         ret = bt_field_type_structure_add_field(packet_header_type,
3215                 packet_header_field_type, "should_fail");
3216         ok(ret < 0,
3217                 "Trace packet header type can't be modified once a stream has been instanciated");
3218
3219         /*
3220          * Try to modify the packet context type after a stream has been
3221          * created.
3222          */
3223         ret = bt_field_type_structure_add_field(packet_context_type,
3224                 packet_context_field_type, "should_fail");
3225         ok(ret < 0,
3226                 "Packet context type can't be modified once a stream has been instanciated");
3227
3228         /*
3229          * Try to modify the stream event context type after a stream has been
3230          * created.
3231          */
3232         ret = bt_field_type_structure_add_field(stream_event_context_type,
3233                 integer_type, "should_fail");
3234         ok(ret < 0,
3235                 "Stream event context type can't be modified once a stream has been instanciated");
3236
3237         /* Should fail after instanciating a stream (frozen) */
3238         ok(bt_stream_class_set_clock(stream_class, clock),
3239                 "Changes to a stream class that was already instantiated fail");
3240
3241         /* Populate the custom packet header field only once for all tests */
3242         ok(bt_stream_get_packet_header(NULL) == NULL,
3243                 "bt_stream_get_packet_header handles NULL correctly");
3244         packet_header = bt_stream_get_packet_header(stream1);
3245         ok(packet_header,
3246                 "bt_stream_get_packet_header returns a packet header");
3247         ret_field_type = bt_field_get_type(packet_header);
3248         ok(ret_field_type == packet_header_type,
3249                 "Stream returns a packet header of the appropriate type");
3250         bt_put(ret_field_type);
3251         packet_header_field = bt_field_structure_get_field_by_name(packet_header,
3252                 "custom_trace_packet_header_field");
3253         ok(packet_header_field,
3254                 "Packet header structure contains a custom field with the appropriate name");
3255         ret_field_type = bt_field_get_type(packet_header_field);
3256         ok(bt_field_type_compare(ret_field_type, packet_header_field_type) == 0,
3257                 "Custom packet header field is of the expected type");
3258         ok(!bt_field_unsigned_integer_set_value(packet_header_field,
3259                 54321), "Set custom packet header value successfully");
3260         ok(bt_stream_set_packet_header(stream1, NULL) < 0,
3261                 "bt_stream_set_packet_header handles a NULL packet header correctly");
3262         ok(bt_stream_set_packet_header(NULL, packet_header) < 0,
3263                 "bt_stream_set_packet_header handles a NULL stream correctly");
3264         ok(bt_stream_set_packet_header(stream1, packet_header_field) < 0,
3265                 "bt_stream_set_packet_header rejects a packet header of the wrong type");
3266         ok(!bt_stream_set_packet_header(stream1, packet_header),
3267                 "Successfully set a stream's packet header");
3268
3269         ok(bt_ctf_writer_add_environment_field(writer, "new_field", "test") == 0,
3270                 "Add environment field to writer after stream creation");
3271
3272         test_clock_utils();
3273
3274         test_create_writer_vs_non_writer_mode();
3275
3276         test_set_clock_non_writer_stream_class();
3277
3278         test_instanciate_event_before_stream(writer, clock);
3279
3280         append_simple_event(stream_class, stream1, clock);
3281
3282         packet_resize_test(stream_class, stream1, clock);
3283
3284         append_complex_event(stream_class, stream1, clock);
3285
3286         append_existing_event_class(stream_class);
3287
3288         test_empty_stream(writer);
3289
3290         test_custom_event_header_stream(writer, clock);
3291
3292         test_static_trace();
3293
3294         test_trace_is_static_listener();
3295
3296         test_trace_uuid();
3297
3298         metadata_string = bt_ctf_writer_get_metadata_string(writer);
3299         ok(metadata_string, "Get metadata string");
3300
3301         bt_ctf_writer_flush_metadata(writer);
3302
3303         bt_put(clock);
3304         bt_put(ret_stream_class);
3305         bt_put(writer);
3306         bt_put(stream1);
3307         bt_put(packet_context_type);
3308         bt_put(packet_context_field_type);
3309         bt_put(integer_type);
3310         bt_put(stream_event_context_type);
3311         bt_put(ret_field_type);
3312         bt_put(packet_header_type);
3313         bt_put(packet_header_field_type);
3314         bt_put(packet_header);
3315         bt_put(packet_header_field);
3316         bt_put(trace);
3317         free(metadata_string);
3318         bt_put(stream_class);
3319
3320         validate_trace(argv[1], trace_path);
3321
3322         //recursive_rmdir(trace_path);
3323         g_free(trace_path);
3324         g_free(metadata_path);
3325
3326         return 0;
3327 }