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