projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add validation/resolving tests
[babeltrace.git] / tests / lib / test_bt_ctf_field_type_validation.c
1 /*
2 * test_bt_ctf_field_type_validation.c
3 *
4 * Babeltrace CTF IR field type validation test
5 *
6 * Copyright (c) 2016 Philippe Proulx <pproulx@efficios.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; under version 2 of the License.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
22 #include <babeltrace/ctf-ir/event-types.h>
23 #include <babeltrace/ctf-ir/event-types-internal.h>
24 #include <babeltrace/ctf-ir/event.h>
25 #include <babeltrace/ctf-ir/stream-class.h>
26 #include <babeltrace/ctf-ir/trace.h>
27 #include <assert.h>
28 #include <string.h>
29 #include <stdarg.h>
30 #include <glib.h>
31 #include "tap/tap.h"
32
33 static
34 struct bt_ctf_field_type *get_good_packet_header_type(void)
35 {
36 /*
37 Generated by bt-ctfirtg using the following input:
38
39 class: struct
40 fields:
41 magic:
42 class: int
43 size: 32
44 uuid:
45 class: array
46 length: 16
47 element-type:
48 class: int
49 size: 8
50 stream_id:
51 class: int
52 size: 32
53 iron:
54 class: struct
55 fields:
56 listen:
57 class: string
58 dust:
59 class: int
60 size: 23
61 parallel:
62 class: enum
63 value-type:
64 class: int
65 size: 10
66 members:
67 - RED
68 - BLUE
69 - YELLOW
70 fire:
71 class: struct
72 fields:
73 word:
74 class: int
75 size: 17
76 rabbit:
77 class: string
78 keen:
79 class: array
80 length: word
81 element-type:
82 class: variant
83 tag: iron.parallel
84 types:
85 RED:
86 class: string
87 BLUE:
88 class: array
89 length: magic
90 element-type:
91 class: int
92 size: 5
93 YELLOW:
94 class: struct
95 report:
96 class: array
97 length: trace.packet.header.iron.dust
98 element-type:
99 class: string
100 group:
101 class: array
102 length: trace.packet.header.stream_id
103 element-type:
104 class: string
105 serious:
106 class: int
107 size: 1
108
109 */
110
111 struct bt_ctf_field_type *root = NULL;
112 struct bt_ctf_field_type *root_magic = NULL;
113 struct bt_ctf_field_type *root_uuid = NULL;
114 struct bt_ctf_field_type *root_uuid_elem = NULL;
115 struct bt_ctf_field_type *root_stream_id = NULL;
116 struct bt_ctf_field_type *root_iron = NULL;
117 struct bt_ctf_field_type *root_iron_listen = NULL;
118 struct bt_ctf_field_type *root_iron_dust = NULL;
119 struct bt_ctf_field_type *root_iron_parallel = NULL;
120 struct bt_ctf_field_type *root_iron_parallel_int = NULL;
121 struct bt_ctf_field_type *root_iron_fire = NULL;
122 struct bt_ctf_field_type *root_iron_fire_word = NULL;
123 struct bt_ctf_field_type *root_iron_fire_rabbit = NULL;
124 struct bt_ctf_field_type *root_iron_fire_keen = NULL;
125 struct bt_ctf_field_type *root_iron_fire_keen_elem = NULL;
126 struct bt_ctf_field_type *root_iron_fire_keen_elem_RED = NULL;
127 struct bt_ctf_field_type *root_iron_fire_keen_elem_BLUE = NULL;
128 struct bt_ctf_field_type *root_iron_fire_keen_elem_BLUE_elem = NULL;
129 struct bt_ctf_field_type *root_iron_fire_keen_elem_YELLOW = NULL;
130 struct bt_ctf_field_type *root_iron_report = NULL;
131 struct bt_ctf_field_type *root_iron_report_elem = NULL;
132 struct bt_ctf_field_type *root_iron_group = NULL;
133 struct bt_ctf_field_type *root_iron_group_elem = NULL;
134 struct bt_ctf_field_type *root_serious = NULL;
135
136 int ret;
137 root = bt_ctf_field_type_structure_create();
138 assert(root);
139 ret = bt_ctf_field_type_set_alignment(root, 8);
140 assert(ret == 0);
141 root_magic = bt_ctf_field_type_integer_create(32);
142 assert(root_magic);
143 ret = bt_ctf_field_type_integer_set_signed(root_magic, 0);
144 assert(ret == 0);
145 ret = bt_ctf_field_type_integer_set_base(root_magic, 10);
146 assert(ret == 0);
147 ret = bt_ctf_field_type_integer_set_encoding(root_magic, CTF_STRING_NONE);
148 assert(ret == 0);
149 ret = bt_ctf_field_type_set_byte_order(root_magic, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
150 assert(ret == 0);
151 ret = bt_ctf_field_type_set_alignment(root_magic, 8);
152 assert(ret == 0);
153 ret = bt_ctf_field_type_structure_add_field(root, root_magic, "magic");
154 assert(ret == 0);
155 root_uuid_elem = bt_ctf_field_type_integer_create(8);
156 assert(root_uuid_elem);
157 ret = bt_ctf_field_type_integer_set_signed(root_uuid_elem, 0);
158 assert(ret == 0);
159 ret = bt_ctf_field_type_integer_set_base(root_uuid_elem, 10);
160 assert(ret == 0);
161 ret = bt_ctf_field_type_integer_set_encoding(root_uuid_elem, CTF_STRING_NONE);
162 assert(ret == 0);
163 ret = bt_ctf_field_type_set_byte_order(root_uuid_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
164 assert(ret == 0);
165 ret = bt_ctf_field_type_set_alignment(root_uuid_elem, 8);
166 assert(ret == 0);
167 root_uuid = bt_ctf_field_type_array_create(root_uuid_elem, 16);
168 assert(root_uuid);
169 ret = bt_ctf_field_type_structure_add_field(root, root_uuid, "uuid");
170 assert(ret == 0);
171 root_stream_id = bt_ctf_field_type_integer_create(32);
172 assert(root_stream_id);
173 ret = bt_ctf_field_type_integer_set_signed(root_stream_id, 0);
174 assert(ret == 0);
175 ret = bt_ctf_field_type_integer_set_base(root_stream_id, 10);
176 assert(ret == 0);
177 ret = bt_ctf_field_type_integer_set_encoding(root_stream_id, CTF_STRING_NONE);
178 assert(ret == 0);
179 ret = bt_ctf_field_type_set_byte_order(root_stream_id, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
180 assert(ret == 0);
181 ret = bt_ctf_field_type_set_alignment(root_stream_id, 8);
182 assert(ret == 0);
183 ret = bt_ctf_field_type_structure_add_field(root, root_stream_id, "stream_id");
184 assert(ret == 0);
185 root_iron = bt_ctf_field_type_structure_create();
186 assert(root_iron);
187 ret = bt_ctf_field_type_set_alignment(root_iron, 8);
188 assert(ret == 0);
189 root_iron_listen = bt_ctf_field_type_string_create();
190 assert(root_iron_listen);
191 ret = bt_ctf_field_type_string_set_encoding(root_iron_listen, CTF_STRING_UTF8);
192 assert(ret == 0);
193 ret = bt_ctf_field_type_structure_add_field(root_iron, root_iron_listen, "listen");
194 assert(ret == 0);
195 root_iron_dust = bt_ctf_field_type_integer_create(23);
196 assert(root_iron_dust);
197 ret = bt_ctf_field_type_integer_set_signed(root_iron_dust, 0);
198 assert(ret == 0);
199 ret = bt_ctf_field_type_integer_set_base(root_iron_dust, 10);
200 assert(ret == 0);
201 ret = bt_ctf_field_type_integer_set_encoding(root_iron_dust, CTF_STRING_NONE);
202 assert(ret == 0);
203 ret = bt_ctf_field_type_set_byte_order(root_iron_dust, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
204 assert(ret == 0);
205 ret = bt_ctf_field_type_set_alignment(root_iron_dust, 1);
206 assert(ret == 0);
207 ret = bt_ctf_field_type_structure_add_field(root_iron, root_iron_dust, "dust");
208 assert(ret == 0);
209 root_iron_parallel_int = bt_ctf_field_type_integer_create(10);
210 assert(root_iron_parallel_int);
211 ret = bt_ctf_field_type_integer_set_signed(root_iron_parallel_int, 0);
212 assert(ret == 0);
213 ret = bt_ctf_field_type_integer_set_base(root_iron_parallel_int, 10);
214 assert(ret == 0);
215 ret = bt_ctf_field_type_integer_set_encoding(root_iron_parallel_int, CTF_STRING_NONE);
216 assert(ret == 0);
217 ret = bt_ctf_field_type_set_byte_order(root_iron_parallel_int, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
218 assert(ret == 0);
219 ret = bt_ctf_field_type_set_alignment(root_iron_parallel_int, 1);
220 assert(ret == 0);
221 root_iron_parallel = bt_ctf_field_type_enumeration_create(root_iron_parallel_int);
222 assert(root_iron_parallel);
223 ret = bt_ctf_field_type_enumeration_add_mapping(root_iron_parallel, "RED", 0, 0);
224 assert(ret == 0);
225 ret = bt_ctf_field_type_enumeration_add_mapping(root_iron_parallel, "BLUE", 1, 1);
226 assert(ret == 0);
227 ret = bt_ctf_field_type_enumeration_add_mapping(root_iron_parallel, "YELLOW", 2, 2);
228 assert(ret == 0);
229 ret = bt_ctf_field_type_structure_add_field(root_iron, root_iron_parallel, "parallel");
230 assert(ret == 0);
231 root_iron_fire = bt_ctf_field_type_structure_create();
232 assert(root_iron_fire);
233 ret = bt_ctf_field_type_set_alignment(root_iron_fire, 8);
234 assert(ret == 0);
235 root_iron_fire_word = bt_ctf_field_type_integer_create(17);
236 assert(root_iron_fire_word);
237 ret = bt_ctf_field_type_integer_set_signed(root_iron_fire_word, 0);
238 assert(ret == 0);
239 ret = bt_ctf_field_type_integer_set_base(root_iron_fire_word, 10);
240 assert(ret == 0);
241 ret = bt_ctf_field_type_integer_set_encoding(root_iron_fire_word, CTF_STRING_NONE);
242 assert(ret == 0);
243 ret = bt_ctf_field_type_set_byte_order(root_iron_fire_word, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
244 assert(ret == 0);
245 ret = bt_ctf_field_type_set_alignment(root_iron_fire_word, 1);
246 assert(ret == 0);
247 ret = bt_ctf_field_type_structure_add_field(root_iron_fire, root_iron_fire_word, "word");
248 assert(ret == 0);
249 root_iron_fire_rabbit = bt_ctf_field_type_string_create();
250 assert(root_iron_fire_rabbit);
251 ret = bt_ctf_field_type_string_set_encoding(root_iron_fire_rabbit, CTF_STRING_UTF8);
252 assert(ret == 0);
253 ret = bt_ctf_field_type_structure_add_field(root_iron_fire, root_iron_fire_rabbit, "rabbit");
254 assert(ret == 0);
255 root_iron_fire_keen_elem = bt_ctf_field_type_variant_create(NULL, "iron.parallel");
256 assert(root_iron_fire_keen_elem);
257 root_iron_fire_keen_elem_RED = bt_ctf_field_type_string_create();
258 assert(root_iron_fire_keen_elem_RED);
259 ret = bt_ctf_field_type_string_set_encoding(root_iron_fire_keen_elem_RED, CTF_STRING_UTF8);
260 assert(ret == 0);
261 ret = bt_ctf_field_type_variant_add_field(root_iron_fire_keen_elem, root_iron_fire_keen_elem_RED, "RED");
262 assert(ret == 0);
263 root_iron_fire_keen_elem_BLUE_elem = bt_ctf_field_type_integer_create(5);
264 assert(root_iron_fire_keen_elem_BLUE_elem);
265 ret = bt_ctf_field_type_integer_set_signed(root_iron_fire_keen_elem_BLUE_elem, 0);
266 assert(ret == 0);
267 ret = bt_ctf_field_type_integer_set_base(root_iron_fire_keen_elem_BLUE_elem, 10);
268 assert(ret == 0);
269 ret = bt_ctf_field_type_integer_set_encoding(root_iron_fire_keen_elem_BLUE_elem, CTF_STRING_NONE);
270 assert(ret == 0);
271 ret = bt_ctf_field_type_set_byte_order(root_iron_fire_keen_elem_BLUE_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
272 assert(ret == 0);
273 ret = bt_ctf_field_type_set_alignment(root_iron_fire_keen_elem_BLUE_elem, 1);
274 assert(ret == 0);
275 root_iron_fire_keen_elem_BLUE = bt_ctf_field_type_sequence_create(root_iron_fire_keen_elem_BLUE_elem, "magic");
276 assert(root_iron_fire_keen_elem_BLUE);
277 ret = bt_ctf_field_type_variant_add_field(root_iron_fire_keen_elem, root_iron_fire_keen_elem_BLUE, "BLUE");
278 assert(ret == 0);
279 root_iron_fire_keen_elem_YELLOW = bt_ctf_field_type_structure_create();
280 assert(root_iron_fire_keen_elem_YELLOW);
281 ret = bt_ctf_field_type_set_alignment(root_iron_fire_keen_elem_YELLOW, 1);
282 assert(ret == 0);
283 ret = bt_ctf_field_type_variant_add_field(root_iron_fire_keen_elem, root_iron_fire_keen_elem_YELLOW, "YELLOW");
284 assert(ret == 0);
285 root_iron_fire_keen = bt_ctf_field_type_sequence_create(root_iron_fire_keen_elem, "word");
286 assert(root_iron_fire_keen);
287 ret = bt_ctf_field_type_structure_add_field(root_iron_fire, root_iron_fire_keen, "keen");
288 assert(ret == 0);
289 ret = bt_ctf_field_type_structure_add_field(root_iron, root_iron_fire, "fire");
290 assert(ret == 0);
291 root_iron_report_elem = bt_ctf_field_type_string_create();
292 assert(root_iron_report_elem);
293 ret = bt_ctf_field_type_string_set_encoding(root_iron_report_elem, CTF_STRING_UTF8);
294 assert(ret == 0);
295 root_iron_report = bt_ctf_field_type_sequence_create(root_iron_report_elem, "trace.packet.header.iron.dust");
296 assert(root_iron_report);
297 ret = bt_ctf_field_type_structure_add_field(root_iron, root_iron_report, "report");
298 assert(ret == 0);
299 root_iron_group_elem = bt_ctf_field_type_string_create();
300 assert(root_iron_group_elem);
301 ret = bt_ctf_field_type_string_set_encoding(root_iron_group_elem, CTF_STRING_UTF8);
302 assert(ret == 0);
303 root_iron_group = bt_ctf_field_type_sequence_create(root_iron_group_elem, "trace.packet.header.stream_id");
304 assert(root_iron_group);
305 ret = bt_ctf_field_type_structure_add_field(root_iron, root_iron_group, "group");
306 assert(ret == 0);
307 ret = bt_ctf_field_type_structure_add_field(root, root_iron, "iron");
308 assert(ret == 0);
309 root_serious = bt_ctf_field_type_integer_create(1);
310 assert(root_serious);
311 ret = bt_ctf_field_type_integer_set_signed(root_serious, 0);
312 assert(ret == 0);
313 ret = bt_ctf_field_type_integer_set_base(root_serious, 10);
314 assert(ret == 0);
315 ret = bt_ctf_field_type_integer_set_encoding(root_serious, CTF_STRING_NONE);
316 assert(ret == 0);
317 ret = bt_ctf_field_type_set_byte_order(root_serious, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
318 assert(ret == 0);
319 ret = bt_ctf_field_type_set_alignment(root_serious, 1);
320 assert(ret == 0);
321 ret = bt_ctf_field_type_structure_add_field(root, root_serious, "serious");
322 assert(ret == 0);
323
324 BT_PUT(root_magic);
325 BT_PUT(root_uuid);
326 BT_PUT(root_uuid_elem);
327 BT_PUT(root_stream_id);
328 BT_PUT(root_iron);
329 BT_PUT(root_iron_listen);
330 BT_PUT(root_iron_dust);
331 BT_PUT(root_iron_parallel);
332 BT_PUT(root_iron_parallel_int);
333 BT_PUT(root_iron_fire);
334 BT_PUT(root_iron_fire_word);
335 BT_PUT(root_iron_fire_rabbit);
336 BT_PUT(root_iron_fire_keen);
337 BT_PUT(root_iron_fire_keen_elem);
338 BT_PUT(root_iron_fire_keen_elem_RED);
339 BT_PUT(root_iron_fire_keen_elem_BLUE);
340 BT_PUT(root_iron_fire_keen_elem_BLUE_elem);
341 BT_PUT(root_iron_fire_keen_elem_YELLOW);
342 BT_PUT(root_iron_report);
343 BT_PUT(root_iron_report_elem);
344 BT_PUT(root_iron_group);
345 BT_PUT(root_iron_group_elem);
346 BT_PUT(root_serious);
347
348 return root;
349 }
350
351 static
352 struct bt_ctf_field_type *get_good_packet_context_type(void)
353 {
354 /*
355 Generated by bt-ctfirtg using the following input:
356
357 class: struct
358 fields:
359 placid:
360 class: int
361 size: 32
362 meow:
363 class: string
364 serious:
365 class: int
366 size: 11
367 naive:
368 class: array
369 length: 17
370 element-type:
371 class: array
372 length: placid
373 element-type:
374 class: string
375 clover:
376 class: struct
377 fields:
378 oval:
379 class: int
380 size: 17
381 whole:
382 class: variant
383 tag: iron.parallel
384 types:
385 BLUE:
386 class: array
387 length: trace.packet.header.iron.fire.word
388 element-type:
389 class: string
390 RED:
391 class: int
392 size: 44
393 YELLOW:
394 class: string
395 egg:
396 class: array
397 length: stream.packet.context.clover.oval
398 element-type:
399 class: int
400 size: 55
401 square:
402 class: enum
403 value-type:
404 class: int
405 size: 12
406 members:
407 - YOUNG
408 - OLD
409 useful:
410 class: array
411 length: serious
412 element-type:
413 class: int
414 size: 2
415 tart:
416 class: string
417
418 */
419
420 struct bt_ctf_field_type *root = NULL;
421 struct bt_ctf_field_type *root_placid = NULL;
422 struct bt_ctf_field_type *root_meow = NULL;
423 struct bt_ctf_field_type *root_serious = NULL;
424 struct bt_ctf_field_type *root_naive = NULL;
425 struct bt_ctf_field_type *root_naive_elem = NULL;
426 struct bt_ctf_field_type *root_naive_elem_elem = NULL;
427 struct bt_ctf_field_type *root_clover = NULL;
428 struct bt_ctf_field_type *root_clover_oval = NULL;
429 struct bt_ctf_field_type *root_clover_whole = NULL;
430 struct bt_ctf_field_type *root_clover_whole_BLUE = NULL;
431 struct bt_ctf_field_type *root_clover_whole_BLUE_elem = NULL;
432 struct bt_ctf_field_type *root_clover_whole_RED = NULL;
433 struct bt_ctf_field_type *root_clover_whole_YELLOW = NULL;
434 struct bt_ctf_field_type *root_clover_egg = NULL;
435 struct bt_ctf_field_type *root_clover_egg_elem = NULL;
436 struct bt_ctf_field_type *root_clover_square = NULL;
437 struct bt_ctf_field_type *root_clover_square_int = NULL;
438 struct bt_ctf_field_type *root_clover_useful = NULL;
439 struct bt_ctf_field_type *root_clover_useful_elem = NULL;
440 struct bt_ctf_field_type *root_tart = NULL;
441
442 int ret;
443 root = bt_ctf_field_type_structure_create();
444 assert(root);
445 ret = bt_ctf_field_type_set_alignment(root, 8);
446 assert(ret == 0);
447 root_placid = bt_ctf_field_type_integer_create(32);
448 assert(root_placid);
449 ret = bt_ctf_field_type_integer_set_signed(root_placid, 0);
450 assert(ret == 0);
451 ret = bt_ctf_field_type_integer_set_base(root_placid, 10);
452 assert(ret == 0);
453 ret = bt_ctf_field_type_integer_set_encoding(root_placid, CTF_STRING_NONE);
454 assert(ret == 0);
455 ret = bt_ctf_field_type_set_byte_order(root_placid, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
456 assert(ret == 0);
457 ret = bt_ctf_field_type_set_alignment(root_placid, 8);
458 assert(ret == 0);
459 ret = bt_ctf_field_type_structure_add_field(root, root_placid, "placid");
460 assert(ret == 0);
461 root_meow = bt_ctf_field_type_string_create();
462 assert(root_meow);
463 ret = bt_ctf_field_type_string_set_encoding(root_meow, CTF_STRING_UTF8);
464 assert(ret == 0);
465 ret = bt_ctf_field_type_structure_add_field(root, root_meow, "meow");
466 assert(ret == 0);
467 root_serious = bt_ctf_field_type_integer_create(11);
468 assert(root_serious);
469 ret = bt_ctf_field_type_integer_set_signed(root_serious, 0);
470 assert(ret == 0);
471 ret = bt_ctf_field_type_integer_set_base(root_serious, 10);
472 assert(ret == 0);
473 ret = bt_ctf_field_type_integer_set_encoding(root_serious, CTF_STRING_NONE);
474 assert(ret == 0);
475 ret = bt_ctf_field_type_set_byte_order(root_serious, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
476 assert(ret == 0);
477 ret = bt_ctf_field_type_set_alignment(root_serious, 1);
478 assert(ret == 0);
479 ret = bt_ctf_field_type_structure_add_field(root, root_serious, "serious");
480 assert(ret == 0);
481 root_naive_elem_elem = bt_ctf_field_type_string_create();
482 assert(root_naive_elem_elem);
483 ret = bt_ctf_field_type_string_set_encoding(root_naive_elem_elem, CTF_STRING_UTF8);
484 assert(ret == 0);
485 root_naive_elem = bt_ctf_field_type_sequence_create(root_naive_elem_elem, "placid");
486 assert(root_naive_elem);
487 root_naive = bt_ctf_field_type_array_create(root_naive_elem, 17);
488 assert(root_naive);
489 ret = bt_ctf_field_type_structure_add_field(root, root_naive, "naive");
490 assert(ret == 0);
491 root_clover = bt_ctf_field_type_structure_create();
492 assert(root_clover);
493 ret = bt_ctf_field_type_set_alignment(root_clover, 1);
494 assert(ret == 0);
495 root_clover_oval = bt_ctf_field_type_integer_create(17);
496 assert(root_clover_oval);
497 ret = bt_ctf_field_type_integer_set_signed(root_clover_oval, 0);
498 assert(ret == 0);
499 ret = bt_ctf_field_type_integer_set_base(root_clover_oval, 10);
500 assert(ret == 0);
501 ret = bt_ctf_field_type_integer_set_encoding(root_clover_oval, CTF_STRING_NONE);
502 assert(ret == 0);
503 ret = bt_ctf_field_type_set_byte_order(root_clover_oval, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
504 assert(ret == 0);
505 ret = bt_ctf_field_type_set_alignment(root_clover_oval, 1);
506 assert(ret == 0);
507 ret = bt_ctf_field_type_structure_add_field(root_clover, root_clover_oval, "oval");
508 assert(ret == 0);
509 root_clover_whole = bt_ctf_field_type_variant_create(NULL, "iron.parallel");
510 assert(root_clover_whole);
511 root_clover_whole_BLUE_elem = bt_ctf_field_type_string_create();
512 assert(root_clover_whole_BLUE_elem);
513 ret = bt_ctf_field_type_string_set_encoding(root_clover_whole_BLUE_elem, CTF_STRING_UTF8);
514 assert(ret == 0);
515 root_clover_whole_BLUE = bt_ctf_field_type_sequence_create(root_clover_whole_BLUE_elem, "trace.packet.header.iron.fire.word");
516 assert(root_clover_whole_BLUE);
517 ret = bt_ctf_field_type_variant_add_field(root_clover_whole, root_clover_whole_BLUE, "BLUE");
518 assert(ret == 0);
519 root_clover_whole_RED = bt_ctf_field_type_integer_create(44);
520 assert(root_clover_whole_RED);
521 ret = bt_ctf_field_type_integer_set_signed(root_clover_whole_RED, 0);
522 assert(ret == 0);
523 ret = bt_ctf_field_type_integer_set_base(root_clover_whole_RED, 10);
524 assert(ret == 0);
525 ret = bt_ctf_field_type_integer_set_encoding(root_clover_whole_RED, CTF_STRING_NONE);
526 assert(ret == 0);
527 ret = bt_ctf_field_type_set_byte_order(root_clover_whole_RED, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
528 assert(ret == 0);
529 ret = bt_ctf_field_type_set_alignment(root_clover_whole_RED, 1);
530 assert(ret == 0);
531 ret = bt_ctf_field_type_variant_add_field(root_clover_whole, root_clover_whole_RED, "RED");
532 assert(ret == 0);
533 root_clover_whole_YELLOW = bt_ctf_field_type_string_create();
534 assert(root_clover_whole_YELLOW);
535 ret = bt_ctf_field_type_string_set_encoding(root_clover_whole_YELLOW, CTF_STRING_UTF8);
536 assert(ret == 0);
537 ret = bt_ctf_field_type_variant_add_field(root_clover_whole, root_clover_whole_YELLOW, "YELLOW");
538 assert(ret == 0);
539 ret = bt_ctf_field_type_structure_add_field(root_clover, root_clover_whole, "whole");
540 assert(ret == 0);
541 root_clover_egg_elem = bt_ctf_field_type_integer_create(55);
542 assert(root_clover_egg_elem);
543 ret = bt_ctf_field_type_integer_set_signed(root_clover_egg_elem, 0);
544 assert(ret == 0);
545 ret = bt_ctf_field_type_integer_set_base(root_clover_egg_elem, 10);
546 assert(ret == 0);
547 ret = bt_ctf_field_type_integer_set_encoding(root_clover_egg_elem, CTF_STRING_NONE);
548 assert(ret == 0);
549 ret = bt_ctf_field_type_set_byte_order(root_clover_egg_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
550 assert(ret == 0);
551 ret = bt_ctf_field_type_set_alignment(root_clover_egg_elem, 1);
552 assert(ret == 0);
553 root_clover_egg = bt_ctf_field_type_sequence_create(root_clover_egg_elem, "stream.packet.context.clover.oval");
554 assert(root_clover_egg);
555 ret = bt_ctf_field_type_structure_add_field(root_clover, root_clover_egg, "egg");
556 assert(ret == 0);
557 root_clover_square_int = bt_ctf_field_type_integer_create(12);
558 assert(root_clover_square_int);
559 ret = bt_ctf_field_type_integer_set_signed(root_clover_square_int, 0);
560 assert(ret == 0);
561 ret = bt_ctf_field_type_integer_set_base(root_clover_square_int, 10);
562 assert(ret == 0);
563 ret = bt_ctf_field_type_integer_set_encoding(root_clover_square_int, CTF_STRING_NONE);
564 assert(ret == 0);
565 ret = bt_ctf_field_type_set_byte_order(root_clover_square_int, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
566 assert(ret == 0);
567 ret = bt_ctf_field_type_set_alignment(root_clover_square_int, 1);
568 assert(ret == 0);
569 root_clover_square = bt_ctf_field_type_enumeration_create(root_clover_square_int);
570 assert(root_clover_square);
571 ret = bt_ctf_field_type_enumeration_add_mapping(root_clover_square, "YOUNG", 0, 0);
572 assert(ret == 0);
573 ret = bt_ctf_field_type_enumeration_add_mapping(root_clover_square, "OLD", 1, 1);
574 assert(ret == 0);
575 ret = bt_ctf_field_type_structure_add_field(root_clover, root_clover_square, "square");
576 assert(ret == 0);
577 root_clover_useful_elem = bt_ctf_field_type_integer_create(2);
578 assert(root_clover_useful_elem);
579 ret = bt_ctf_field_type_integer_set_signed(root_clover_useful_elem, 0);
580 assert(ret == 0);
581 ret = bt_ctf_field_type_integer_set_base(root_clover_useful_elem, 10);
582 assert(ret == 0);
583 ret = bt_ctf_field_type_integer_set_encoding(root_clover_useful_elem, CTF_STRING_NONE);
584 assert(ret == 0);
585 ret = bt_ctf_field_type_set_byte_order(root_clover_useful_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
586 assert(ret == 0);
587 ret = bt_ctf_field_type_set_alignment(root_clover_useful_elem, 1);
588 assert(ret == 0);
589 root_clover_useful = bt_ctf_field_type_sequence_create(root_clover_useful_elem, "serious");
590 assert(root_clover_useful);
591 ret = bt_ctf_field_type_structure_add_field(root_clover, root_clover_useful, "useful");
592 assert(ret == 0);
593 ret = bt_ctf_field_type_structure_add_field(root, root_clover, "clover");
594 assert(ret == 0);
595 root_tart = bt_ctf_field_type_string_create();
596 assert(root_tart);
597 ret = bt_ctf_field_type_string_set_encoding(root_tart, CTF_STRING_UTF8);
598 assert(ret == 0);
599 ret = bt_ctf_field_type_structure_add_field(root, root_tart, "tart");
600 assert(ret == 0);
601
602 BT_PUT(root_placid);
603 BT_PUT(root_meow);
604 BT_PUT(root_serious);
605 BT_PUT(root_naive);
606 BT_PUT(root_naive_elem);
607 BT_PUT(root_naive_elem_elem);
608 BT_PUT(root_clover);
609 BT_PUT(root_clover_oval);
610 BT_PUT(root_clover_whole);
611 BT_PUT(root_clover_whole_BLUE);
612 BT_PUT(root_clover_whole_BLUE_elem);
613 BT_PUT(root_clover_whole_RED);
614 BT_PUT(root_clover_whole_YELLOW);
615 BT_PUT(root_clover_egg);
616 BT_PUT(root_clover_egg_elem);
617 BT_PUT(root_clover_square);
618 BT_PUT(root_clover_square_int);
619 BT_PUT(root_clover_useful);
620 BT_PUT(root_clover_useful_elem);
621 BT_PUT(root_tart);
622
623 return root;
624 }
625
626
627 static
628 struct bt_ctf_field_type *get_good_event_header_type(void)
629 {
630 /*
631 Generated by bt-ctfirtg using the following input:
632
633 class: struct
634 fields:
635 id:
636 class: int
637 size: 17
638 timestamp:
639 class: int
640 size: 64
641 action:
642 class: struct
643 fields:
644 special:
645 class: int
646 size: 17
647 lucky:
648 class: array
649 length: stream.packet.context.placid
650 element-type:
651 class: string
652 dream:
653 class: string
654 grandiose:
655 class: array
656 length: trace.packet.header.serious
657 element-type:
658 class: int
659 size: 3
660 stiff:
661 class: array
662 length: clover.whole.RED
663 element-type:
664 class: string
665 fruit:
666 class: struct
667 fields:
668 apple:
669 class: array
670 length: action.special
671 element-type:
672 class: int
673 size: 5
674
675 */
676
677 struct bt_ctf_field_type *root = NULL;
678 struct bt_ctf_field_type *root_id = NULL;
679 struct bt_ctf_field_type *root_timestamp = NULL;
680 struct bt_ctf_field_type *root_action = NULL;
681 struct bt_ctf_field_type *root_action_special = NULL;
682 struct bt_ctf_field_type *root_action_lucky = NULL;
683 struct bt_ctf_field_type *root_action_lucky_elem = NULL;
684 struct bt_ctf_field_type *root_action_dream = NULL;
685 struct bt_ctf_field_type *root_action_grandiose = NULL;
686 struct bt_ctf_field_type *root_action_grandiose_elem = NULL;
687 struct bt_ctf_field_type *root_stiff = NULL;
688 struct bt_ctf_field_type *root_stiff_elem = NULL;
689 struct bt_ctf_field_type *root_fruit = NULL;
690 struct bt_ctf_field_type *root_fruit_apple = NULL;
691 struct bt_ctf_field_type *root_fruit_apple_elem = NULL;
692
693 int ret;
694 root = bt_ctf_field_type_structure_create();
695 assert(root);
696 ret = bt_ctf_field_type_set_alignment(root, 8);
697 assert(ret == 0);
698 root_id = bt_ctf_field_type_integer_create(17);
699 assert(root_id);
700 ret = bt_ctf_field_type_integer_set_signed(root_id, 0);
701 assert(ret == 0);
702 ret = bt_ctf_field_type_integer_set_base(root_id, 10);
703 assert(ret == 0);
704 ret = bt_ctf_field_type_integer_set_encoding(root_id, CTF_STRING_NONE);
705 assert(ret == 0);
706 ret = bt_ctf_field_type_set_byte_order(root_id, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
707 assert(ret == 0);
708 ret = bt_ctf_field_type_set_alignment(root_id, 1);
709 assert(ret == 0);
710 ret = bt_ctf_field_type_structure_add_field(root, root_id, "id");
711 assert(ret == 0);
712 root_timestamp = bt_ctf_field_type_integer_create(64);
713 assert(root_timestamp);
714 ret = bt_ctf_field_type_integer_set_signed(root_timestamp, 0);
715 assert(ret == 0);
716 ret = bt_ctf_field_type_integer_set_base(root_timestamp, 10);
717 assert(ret == 0);
718 ret = bt_ctf_field_type_integer_set_encoding(root_timestamp, CTF_STRING_NONE);
719 assert(ret == 0);
720 ret = bt_ctf_field_type_set_byte_order(root_timestamp, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
721 assert(ret == 0);
722 ret = bt_ctf_field_type_set_alignment(root_timestamp, 8);
723 assert(ret == 0);
724 ret = bt_ctf_field_type_structure_add_field(root, root_timestamp, "timestamp");
725 assert(ret == 0);
726 root_action = bt_ctf_field_type_structure_create();
727 assert(root_action);
728 ret = bt_ctf_field_type_set_alignment(root_action, 8);
729 assert(ret == 0);
730 root_action_special = bt_ctf_field_type_integer_create(17);
731 assert(root_action_special);
732 ret = bt_ctf_field_type_integer_set_signed(root_action_special, 0);
733 assert(ret == 0);
734 ret = bt_ctf_field_type_integer_set_base(root_action_special, 10);
735 assert(ret == 0);
736 ret = bt_ctf_field_type_integer_set_encoding(root_action_special, CTF_STRING_NONE);
737 assert(ret == 0);
738 ret = bt_ctf_field_type_set_byte_order(root_action_special, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
739 assert(ret == 0);
740 ret = bt_ctf_field_type_set_alignment(root_action_special, 1);
741 assert(ret == 0);
742 ret = bt_ctf_field_type_structure_add_field(root_action, root_action_special, "special");
743 assert(ret == 0);
744 root_action_lucky_elem = bt_ctf_field_type_string_create();
745 assert(root_action_lucky_elem);
746 ret = bt_ctf_field_type_string_set_encoding(root_action_lucky_elem, CTF_STRING_UTF8);
747 assert(ret == 0);
748 root_action_lucky = bt_ctf_field_type_sequence_create(root_action_lucky_elem, "stream.packet.context.placid");
749 assert(root_action_lucky);
750 ret = bt_ctf_field_type_structure_add_field(root_action, root_action_lucky, "lucky");
751 assert(ret == 0);
752 root_action_dream = bt_ctf_field_type_string_create();
753 assert(root_action_dream);
754 ret = bt_ctf_field_type_string_set_encoding(root_action_dream, CTF_STRING_UTF8);
755 assert(ret == 0);
756 ret = bt_ctf_field_type_structure_add_field(root_action, root_action_dream, "dream");
757 assert(ret == 0);
758 root_action_grandiose_elem = bt_ctf_field_type_integer_create(3);
759 assert(root_action_grandiose_elem);
760 ret = bt_ctf_field_type_integer_set_signed(root_action_grandiose_elem, 0);
761 assert(ret == 0);
762 ret = bt_ctf_field_type_integer_set_base(root_action_grandiose_elem, 10);
763 assert(ret == 0);
764 ret = bt_ctf_field_type_integer_set_encoding(root_action_grandiose_elem, CTF_STRING_NONE);
765 assert(ret == 0);
766 ret = bt_ctf_field_type_set_byte_order(root_action_grandiose_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
767 assert(ret == 0);
768 ret = bt_ctf_field_type_set_alignment(root_action_grandiose_elem, 1);
769 assert(ret == 0);
770 root_action_grandiose = bt_ctf_field_type_sequence_create(root_action_grandiose_elem, "trace.packet.header.serious");
771 assert(root_action_grandiose);
772 ret = bt_ctf_field_type_structure_add_field(root_action, root_action_grandiose, "grandiose");
773 assert(ret == 0);
774 ret = bt_ctf_field_type_structure_add_field(root, root_action, "action");
775 assert(ret == 0);
776 root_stiff_elem = bt_ctf_field_type_string_create();
777 assert(root_stiff_elem);
778 ret = bt_ctf_field_type_string_set_encoding(root_stiff_elem, CTF_STRING_UTF8);
779 assert(ret == 0);
780 root_stiff = bt_ctf_field_type_sequence_create(root_stiff_elem, "clover.whole.RED");
781 assert(root_stiff);
782 ret = bt_ctf_field_type_structure_add_field(root, root_stiff, "stiff");
783 assert(ret == 0);
784 root_fruit = bt_ctf_field_type_structure_create();
785 assert(root_fruit);
786 ret = bt_ctf_field_type_set_alignment(root_fruit, 1);
787 assert(ret == 0);
788 root_fruit_apple_elem = bt_ctf_field_type_integer_create(5);
789 assert(root_fruit_apple_elem);
790 ret = bt_ctf_field_type_integer_set_signed(root_fruit_apple_elem, 0);
791 assert(ret == 0);
792 ret = bt_ctf_field_type_integer_set_base(root_fruit_apple_elem, 10);
793 assert(ret == 0);
794 ret = bt_ctf_field_type_integer_set_encoding(root_fruit_apple_elem, CTF_STRING_NONE);
795 assert(ret == 0);
796 ret = bt_ctf_field_type_set_byte_order(root_fruit_apple_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
797 assert(ret == 0);
798 ret = bt_ctf_field_type_set_alignment(root_fruit_apple_elem, 1);
799 assert(ret == 0);
800 root_fruit_apple = bt_ctf_field_type_sequence_create(root_fruit_apple_elem, "action.special");
801 assert(root_fruit_apple);
802 ret = bt_ctf_field_type_structure_add_field(root_fruit, root_fruit_apple, "apple");
803 assert(ret == 0);
804 ret = bt_ctf_field_type_structure_add_field(root, root_fruit, "fruit");
805 assert(ret == 0);
806
807 BT_PUT(root_id);
808 BT_PUT(root_timestamp);
809 BT_PUT(root_action);
810 BT_PUT(root_action_special);
811 BT_PUT(root_action_lucky);
812 BT_PUT(root_action_lucky_elem);
813 BT_PUT(root_action_dream);
814 BT_PUT(root_action_grandiose);
815 BT_PUT(root_action_grandiose_elem);
816 BT_PUT(root_stiff);
817 BT_PUT(root_stiff_elem);
818 BT_PUT(root_fruit);
819 BT_PUT(root_fruit_apple);
820 BT_PUT(root_fruit_apple_elem);
821
822 return root;
823 }
824
825 static
826 struct bt_ctf_field_type *get_good_stream_event_context_type(void)
827 {
828 /*
829 Generated by bt-ctfirtg using the following input:
830
831 class: struct
832 fields:
833 face:
834 class: struct
835 fields:
836 branch:
837 class: array
838 length: serious
839 element-type:
840 class: string
841 income:
842 class: array
843 length: magic
844 element-type:
845 class: string
846 magic:
847 class: int
848 size: 23
849 lucky:
850 class: array
851 length: magic
852 element-type:
853 class: string
854 cats:
855 class: int
856 size: 5
857 dream:
858 class: array
859 length: stream.packet.context.placid
860 element-type:
861 class: array
862 length: trace.packet.header.iron.dust
863 element-type:
864 class: array
865 length: stream.event.context.face.magic
866 element-type:
867 class: string
868 stream_id:
869 class: int
870 size: 9
871
872 */
873
874 struct bt_ctf_field_type *root = NULL;
875 struct bt_ctf_field_type *root_face = NULL;
876 struct bt_ctf_field_type *root_face_branch = NULL;
877 struct bt_ctf_field_type *root_face_branch_elem = NULL;
878 struct bt_ctf_field_type *root_face_income = NULL;
879 struct bt_ctf_field_type *root_face_income_elem = NULL;
880 struct bt_ctf_field_type *root_face_magic = NULL;
881 struct bt_ctf_field_type *root_face_lucky = NULL;
882 struct bt_ctf_field_type *root_face_lucky_elem = NULL;
883 struct bt_ctf_field_type *root_cats = NULL;
884 struct bt_ctf_field_type *root_dream = NULL;
885 struct bt_ctf_field_type *root_dream_elem = NULL;
886 struct bt_ctf_field_type *root_dream_elem_elem = NULL;
887 struct bt_ctf_field_type *root_dream_elem_elem_elem = NULL;
888 struct bt_ctf_field_type *root_stream_id = NULL;
889
890 int ret;
891 root = bt_ctf_field_type_structure_create();
892 assert(root);
893 ret = bt_ctf_field_type_set_alignment(root, 8);
894 assert(ret == 0);
895 root_face = bt_ctf_field_type_structure_create();
896 assert(root_face);
897 ret = bt_ctf_field_type_set_alignment(root_face, 8);
898 assert(ret == 0);
899 root_face_branch_elem = bt_ctf_field_type_string_create();
900 assert(root_face_branch_elem);
901 ret = bt_ctf_field_type_string_set_encoding(root_face_branch_elem, CTF_STRING_UTF8);
902 assert(ret == 0);
903 root_face_branch = bt_ctf_field_type_sequence_create(root_face_branch_elem, "serious");
904 assert(root_face_branch);
905 ret = bt_ctf_field_type_structure_add_field(root_face, root_face_branch, "branch");
906 assert(ret == 0);
907 root_face_income_elem = bt_ctf_field_type_string_create();
908 assert(root_face_income_elem);
909 ret = bt_ctf_field_type_string_set_encoding(root_face_income_elem, CTF_STRING_UTF8);
910 assert(ret == 0);
911 root_face_income = bt_ctf_field_type_sequence_create(root_face_income_elem, "magic");
912 assert(root_face_income);
913 ret = bt_ctf_field_type_structure_add_field(root_face, root_face_income, "income");
914 assert(ret == 0);
915 root_face_magic = bt_ctf_field_type_integer_create(23);
916 assert(root_face_magic);
917 ret = bt_ctf_field_type_integer_set_signed(root_face_magic, 0);
918 assert(ret == 0);
919 ret = bt_ctf_field_type_integer_set_base(root_face_magic, 10);
920 assert(ret == 0);
921 ret = bt_ctf_field_type_integer_set_encoding(root_face_magic, CTF_STRING_NONE);
922 assert(ret == 0);
923 ret = bt_ctf_field_type_set_byte_order(root_face_magic, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
924 assert(ret == 0);
925 ret = bt_ctf_field_type_set_alignment(root_face_magic, 1);
926 assert(ret == 0);
927 ret = bt_ctf_field_type_structure_add_field(root_face, root_face_magic, "magic");
928 assert(ret == 0);
929 root_face_lucky_elem = bt_ctf_field_type_string_create();
930 assert(root_face_lucky_elem);
931 ret = bt_ctf_field_type_string_set_encoding(root_face_lucky_elem, CTF_STRING_UTF8);
932 assert(ret == 0);
933 root_face_lucky = bt_ctf_field_type_sequence_create(root_face_lucky_elem, "magic");
934 assert(root_face_lucky);
935 ret = bt_ctf_field_type_structure_add_field(root_face, root_face_lucky, "lucky");
936 assert(ret == 0);
937 ret = bt_ctf_field_type_structure_add_field(root, root_face, "face");
938 assert(ret == 0);
939 root_cats = bt_ctf_field_type_integer_create(5);
940 assert(root_cats);
941 ret = bt_ctf_field_type_integer_set_signed(root_cats, 0);
942 assert(ret == 0);
943 ret = bt_ctf_field_type_integer_set_base(root_cats, 10);
944 assert(ret == 0);
945 ret = bt_ctf_field_type_integer_set_encoding(root_cats, CTF_STRING_NONE);
946 assert(ret == 0);
947 ret = bt_ctf_field_type_set_byte_order(root_cats, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
948 assert(ret == 0);
949 ret = bt_ctf_field_type_set_alignment(root_cats, 1);
950 assert(ret == 0);
951 ret = bt_ctf_field_type_structure_add_field(root, root_cats, "cats");
952 assert(ret == 0);
953 root_dream_elem_elem_elem = bt_ctf_field_type_string_create();
954 assert(root_dream_elem_elem_elem);
955 ret = bt_ctf_field_type_string_set_encoding(root_dream_elem_elem_elem, CTF_STRING_UTF8);
956 assert(ret == 0);
957 root_dream_elem_elem = bt_ctf_field_type_sequence_create(root_dream_elem_elem_elem, "stream.event.context.face.magic");
958 assert(root_dream_elem_elem);
959 root_dream_elem = bt_ctf_field_type_sequence_create(root_dream_elem_elem, "trace.packet.header.iron.dust");
960 assert(root_dream_elem);
961 root_dream = bt_ctf_field_type_sequence_create(root_dream_elem, "stream.packet.context.placid");
962 assert(root_dream);
963 ret = bt_ctf_field_type_structure_add_field(root, root_dream, "dream");
964 assert(ret == 0);
965 root_stream_id = bt_ctf_field_type_integer_create(9);
966 assert(root_stream_id);
967 ret = bt_ctf_field_type_integer_set_signed(root_stream_id, 0);
968 assert(ret == 0);
969 ret = bt_ctf_field_type_integer_set_base(root_stream_id, 10);
970 assert(ret == 0);
971 ret = bt_ctf_field_type_integer_set_encoding(root_stream_id, CTF_STRING_NONE);
972 assert(ret == 0);
973 ret = bt_ctf_field_type_set_byte_order(root_stream_id, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
974 assert(ret == 0);
975 ret = bt_ctf_field_type_set_alignment(root_stream_id, 1);
976 assert(ret == 0);
977 ret = bt_ctf_field_type_structure_add_field(root, root_stream_id, "stream_id");
978 assert(ret == 0);
979
980 BT_PUT(root_face);
981 BT_PUT(root_face_branch);
982 BT_PUT(root_face_branch_elem);
983 BT_PUT(root_face_income);
984 BT_PUT(root_face_income_elem);
985 BT_PUT(root_face_magic);
986 BT_PUT(root_face_lucky);
987 BT_PUT(root_face_lucky_elem);
988 BT_PUT(root_cats);
989 BT_PUT(root_dream);
990 BT_PUT(root_dream_elem);
991 BT_PUT(root_dream_elem_elem);
992 BT_PUT(root_dream_elem_elem_elem);
993 BT_PUT(root_stream_id);
994
995 return root;
996 }
997
998 static
999 struct bt_ctf_field_type *get_good_event_context_type(void)
1000 {
1001 /*
1002 Generated by bt-ctfirtg using the following input:
1003
1004 class: struct
1005 fields:
1006 film:
1007 class: int
1008 size: 19
1009 berry:
1010 class: struct
1011 fields:
1012 pine:
1013 class: array
1014 length: stream_id
1015 element-type:
1016 class: string
1017 porter:
1018 class: array
1019 length: face.magic
1020 element-type:
1021 class: string
1022 mice:
1023 class: array
1024 length: action.special
1025 element-type:
1026 class: string
1027 third:
1028 class: int
1029 size: 18
1030 guard:
1031 class: array
1032 length: clover.oval
1033 element-type:
1034 class: string
1035 one:
1036 class: array
1037 length: iron.fire.word
1038 element-type:
1039 class: string
1040 cats:
1041 class: int
1042 size: 55
1043 loud:
1044 class: struct
1045 fields:
1046 toys:
1047 class: array
1048 length: trace.packet.header.iron.fire.word
1049 element-type:
1050 class: string
1051 spoon:
1052 class: array
1053 length: stream.packet.context.clover.oval
1054 element-type:
1055 class: string
1056 turkey:
1057 class: array
1058 length: stream.event.header.action.special
1059 element-type:
1060 class: string
1061 inform:
1062 class: array
1063 length: stream.event.context.face.magic
1064 element-type:
1065 class: string
1066 odd:
1067 class: array
1068 length: berry.third
1069 element-type:
1070 class: string
1071 amuck:
1072 class: array
1073 length: event.context.film
1074 element-type:
1075 class: string
1076
1077 */
1078
1079 struct bt_ctf_field_type *root = NULL;
1080 struct bt_ctf_field_type *root_film = NULL;
1081 struct bt_ctf_field_type *root_berry = NULL;
1082 struct bt_ctf_field_type *root_berry_pine = NULL;
1083 struct bt_ctf_field_type *root_berry_pine_elem = NULL;
1084 struct bt_ctf_field_type *root_berry_porter = NULL;
1085 struct bt_ctf_field_type *root_berry_porter_elem = NULL;
1086 struct bt_ctf_field_type *root_berry_mice = NULL;
1087 struct bt_ctf_field_type *root_berry_mice_elem = NULL;
1088 struct bt_ctf_field_type *root_berry_third = NULL;
1089 struct bt_ctf_field_type *root_berry_guard = NULL;
1090 struct bt_ctf_field_type *root_berry_guard_elem = NULL;
1091 struct bt_ctf_field_type *root_berry_one = NULL;
1092 struct bt_ctf_field_type *root_berry_one_elem = NULL;
1093 struct bt_ctf_field_type *root_cats = NULL;
1094 struct bt_ctf_field_type *root_loud = NULL;
1095 struct bt_ctf_field_type *root_loud_toys = NULL;
1096 struct bt_ctf_field_type *root_loud_toys_elem = NULL;
1097 struct bt_ctf_field_type *root_loud_spoon = NULL;
1098 struct bt_ctf_field_type *root_loud_spoon_elem = NULL;
1099 struct bt_ctf_field_type *root_loud_turkey = NULL;
1100 struct bt_ctf_field_type *root_loud_turkey_elem = NULL;
1101 struct bt_ctf_field_type *root_loud_inform = NULL;
1102 struct bt_ctf_field_type *root_loud_inform_elem = NULL;
1103 struct bt_ctf_field_type *root_loud_odd = NULL;
1104 struct bt_ctf_field_type *root_loud_odd_elem = NULL;
1105 struct bt_ctf_field_type *root_loud_amuck = NULL;
1106 struct bt_ctf_field_type *root_loud_amuck_elem = NULL;
1107
1108 int ret;
1109 root = bt_ctf_field_type_structure_create();
1110 assert(root);
1111 ret = bt_ctf_field_type_set_alignment(root, 8);
1112 assert(ret == 0);
1113 root_film = bt_ctf_field_type_integer_create(19);
1114 assert(root_film);
1115 ret = bt_ctf_field_type_integer_set_signed(root_film, 0);
1116 assert(ret == 0);
1117 ret = bt_ctf_field_type_integer_set_base(root_film, 10);
1118 assert(ret == 0);
1119 ret = bt_ctf_field_type_integer_set_encoding(root_film, CTF_STRING_NONE);
1120 assert(ret == 0);
1121 ret = bt_ctf_field_type_set_byte_order(root_film, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
1122 assert(ret == 0);
1123 ret = bt_ctf_field_type_set_alignment(root_film, 1);
1124 assert(ret == 0);
1125 ret = bt_ctf_field_type_structure_add_field(root, root_film, "film");
1126 assert(ret == 0);
1127 root_berry = bt_ctf_field_type_structure_create();
1128 assert(root_berry);
1129 ret = bt_ctf_field_type_set_alignment(root_berry, 8);
1130 assert(ret == 0);
1131 root_berry_pine_elem = bt_ctf_field_type_string_create();
1132 assert(root_berry_pine_elem);
1133 ret = bt_ctf_field_type_string_set_encoding(root_berry_pine_elem, CTF_STRING_UTF8);
1134 assert(ret == 0);
1135 root_berry_pine = bt_ctf_field_type_sequence_create(root_berry_pine_elem, "stream_id");
1136 assert(root_berry_pine);
1137 ret = bt_ctf_field_type_structure_add_field(root_berry, root_berry_pine, "pine");
1138 assert(ret == 0);
1139 root_berry_porter_elem = bt_ctf_field_type_string_create();
1140 assert(root_berry_porter_elem);
1141 ret = bt_ctf_field_type_string_set_encoding(root_berry_porter_elem, CTF_STRING_UTF8);
1142 assert(ret == 0);
1143 root_berry_porter = bt_ctf_field_type_sequence_create(root_berry_porter_elem, "face.magic");
1144 assert(root_berry_porter);
1145 ret = bt_ctf_field_type_structure_add_field(root_berry, root_berry_porter, "porter");
1146 assert(ret == 0);
1147 root_berry_mice_elem = bt_ctf_field_type_string_create();
1148 assert(root_berry_mice_elem);
1149 ret = bt_ctf_field_type_string_set_encoding(root_berry_mice_elem, CTF_STRING_UTF8);
1150 assert(ret == 0);
1151 root_berry_mice = bt_ctf_field_type_sequence_create(root_berry_mice_elem, "action.special");
1152 assert(root_berry_mice);
1153 ret = bt_ctf_field_type_structure_add_field(root_berry, root_berry_mice, "mice");
1154 assert(ret == 0);
1155 root_berry_third = bt_ctf_field_type_integer_create(18);
1156 assert(root_berry_third);
1157 ret = bt_ctf_field_type_integer_set_signed(root_berry_third, 0);
1158 assert(ret == 0);
1159 ret = bt_ctf_field_type_integer_set_base(root_berry_third, 10);
1160 assert(ret == 0);
1161 ret = bt_ctf_field_type_integer_set_encoding(root_berry_third, CTF_STRING_NONE);
1162 assert(ret == 0);
1163 ret = bt_ctf_field_type_set_byte_order(root_berry_third, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
1164 assert(ret == 0);
1165 ret = bt_ctf_field_type_set_alignment(root_berry_third, 1);
1166 assert(ret == 0);
1167 ret = bt_ctf_field_type_structure_add_field(root_berry, root_berry_third, "third");
1168 assert(ret == 0);
1169 root_berry_guard_elem = bt_ctf_field_type_string_create();
1170 assert(root_berry_guard_elem);
1171 ret = bt_ctf_field_type_string_set_encoding(root_berry_guard_elem, CTF_STRING_UTF8);
1172 assert(ret == 0);
1173 root_berry_guard = bt_ctf_field_type_sequence_create(root_berry_guard_elem, "clover.oval");
1174 assert(root_berry_guard);
1175 ret = bt_ctf_field_type_structure_add_field(root_berry, root_berry_guard, "guard");
1176 assert(ret == 0);
1177 root_berry_one_elem = bt_ctf_field_type_string_create();
1178 assert(root_berry_one_elem);
1179 ret = bt_ctf_field_type_string_set_encoding(root_berry_one_elem, CTF_STRING_UTF8);
1180 assert(ret == 0);
1181 root_berry_one = bt_ctf_field_type_sequence_create(root_berry_one_elem, "iron.fire.word");
1182 assert(root_berry_one);
1183 ret = bt_ctf_field_type_structure_add_field(root_berry, root_berry_one, "one");
1184 assert(ret == 0);
1185 ret = bt_ctf_field_type_structure_add_field(root, root_berry, "berry");
1186 assert(ret == 0);
1187 root_cats = bt_ctf_field_type_integer_create(55);
1188 assert(root_cats);
1189 ret = bt_ctf_field_type_integer_set_signed(root_cats, 0);
1190 assert(ret == 0);
1191 ret = bt_ctf_field_type_integer_set_base(root_cats, 10);
1192 assert(ret == 0);
1193 ret = bt_ctf_field_type_integer_set_encoding(root_cats, CTF_STRING_NONE);
1194 assert(ret == 0);
1195 ret = bt_ctf_field_type_set_byte_order(root_cats, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
1196 assert(ret == 0);
1197 ret = bt_ctf_field_type_set_alignment(root_cats, 1);
1198 assert(ret == 0);
1199 ret = bt_ctf_field_type_structure_add_field(root, root_cats, "cats");
1200 assert(ret == 0);
1201 root_loud = bt_ctf_field_type_structure_create();
1202 assert(root_loud);
1203 ret = bt_ctf_field_type_set_alignment(root_loud, 8);
1204 assert(ret == 0);
1205 root_loud_toys_elem = bt_ctf_field_type_string_create();
1206 assert(root_loud_toys_elem);
1207 ret = bt_ctf_field_type_string_set_encoding(root_loud_toys_elem, CTF_STRING_UTF8);
1208 assert(ret == 0);
1209 root_loud_toys = bt_ctf_field_type_sequence_create(root_loud_toys_elem, "trace.packet.header.iron.fire.word");
1210 assert(root_loud_toys);
1211 ret = bt_ctf_field_type_structure_add_field(root_loud, root_loud_toys, "toys");
1212 assert(ret == 0);
1213 root_loud_spoon_elem = bt_ctf_field_type_string_create();
1214 assert(root_loud_spoon_elem);
1215 ret = bt_ctf_field_type_string_set_encoding(root_loud_spoon_elem, CTF_STRING_UTF8);
1216 assert(ret == 0);
1217 root_loud_spoon = bt_ctf_field_type_sequence_create(root_loud_spoon_elem, "stream.packet.context.clover.oval");
1218 assert(root_loud_spoon);
1219 ret = bt_ctf_field_type_structure_add_field(root_loud, root_loud_spoon, "spoon");
1220 assert(ret == 0);
1221 root_loud_turkey_elem = bt_ctf_field_type_string_create();
1222 assert(root_loud_turkey_elem);
1223 ret = bt_ctf_field_type_string_set_encoding(root_loud_turkey_elem, CTF_STRING_UTF8);
1224 assert(ret == 0);
1225 root_loud_turkey = bt_ctf_field_type_sequence_create(root_loud_turkey_elem, "stream.event.header.action.special");
1226 assert(root_loud_turkey);
1227 ret = bt_ctf_field_type_structure_add_field(root_loud, root_loud_turkey, "turkey");
1228 assert(ret == 0);
1229 root_loud_inform_elem = bt_ctf_field_type_string_create();
1230 assert(root_loud_inform_elem);
1231 ret = bt_ctf_field_type_string_set_encoding(root_loud_inform_elem, CTF_STRING_UTF8);
1232 assert(ret == 0);
1233 root_loud_inform = bt_ctf_field_type_sequence_create(root_loud_inform_elem, "stream.event.context.face.magic");
1234 assert(root_loud_inform);
1235 ret = bt_ctf_field_type_structure_add_field(root_loud, root_loud_inform, "inform");
1236 assert(ret == 0);
1237 root_loud_odd_elem = bt_ctf_field_type_string_create();
1238 assert(root_loud_odd_elem);
1239 ret = bt_ctf_field_type_string_set_encoding(root_loud_odd_elem, CTF_STRING_UTF8);
1240 assert(ret == 0);
1241 root_loud_odd = bt_ctf_field_type_sequence_create(root_loud_odd_elem, "berry.third");
1242 assert(root_loud_odd);
1243 ret = bt_ctf_field_type_structure_add_field(root_loud, root_loud_odd, "odd");
1244 assert(ret == 0);
1245 root_loud_amuck_elem = bt_ctf_field_type_string_create();
1246 assert(root_loud_amuck_elem);
1247 ret = bt_ctf_field_type_string_set_encoding(root_loud_amuck_elem, CTF_STRING_UTF8);
1248 assert(ret == 0);
1249 root_loud_amuck = bt_ctf_field_type_sequence_create(root_loud_amuck_elem, "event.context.film");
1250 assert(root_loud_amuck);
1251 ret = bt_ctf_field_type_structure_add_field(root_loud, root_loud_amuck, "amuck");
1252 assert(ret == 0);
1253 ret = bt_ctf_field_type_structure_add_field(root, root_loud, "loud");
1254 assert(ret == 0);
1255
1256 BT_PUT(root_film);
1257 BT_PUT(root_berry);
1258 BT_PUT(root_berry_pine);
1259 BT_PUT(root_berry_pine_elem);
1260 BT_PUT(root_berry_porter);
1261 BT_PUT(root_berry_porter_elem);
1262 BT_PUT(root_berry_mice);
1263 BT_PUT(root_berry_mice_elem);
1264 BT_PUT(root_berry_third);
1265 BT_PUT(root_berry_guard);
1266 BT_PUT(root_berry_guard_elem);
1267 BT_PUT(root_berry_one);
1268 BT_PUT(root_berry_one_elem);
1269 BT_PUT(root_cats);
1270 BT_PUT(root_loud);
1271 BT_PUT(root_loud_toys);
1272 BT_PUT(root_loud_toys_elem);
1273 BT_PUT(root_loud_spoon);
1274 BT_PUT(root_loud_spoon_elem);
1275 BT_PUT(root_loud_turkey);
1276 BT_PUT(root_loud_turkey_elem);
1277 BT_PUT(root_loud_inform);
1278 BT_PUT(root_loud_inform_elem);
1279 BT_PUT(root_loud_odd);
1280 BT_PUT(root_loud_odd_elem);
1281 BT_PUT(root_loud_amuck);
1282 BT_PUT(root_loud_amuck_elem);
1283
1284 return root;
1285 }
1286
1287 static
1288 struct bt_ctf_field_type *get_good_event_payload_type(void)
1289 {
1290 /*
1291 Generated by bt-ctfirtg using the following input:
1292
1293 class: struct
1294 fields:
1295 splendid:
1296 class: int
1297 size: 12
1298 relative:
1299 class: struct
1300 fields:
1301 equal:
1302 class: array
1303 length: splendid
1304 element-type:
1305 class: string
1306 amuck:
1307 class: array
1308 length: cats
1309 element-type:
1310 class: string
1311 push:
1312 class: array
1313 length: berry.third
1314 element-type:
1315 class: string
1316 brick:
1317 class: array
1318 length: face.magic
1319 element-type:
1320 class: string
1321 amuck:
1322 class: array
1323 length: id
1324 element-type:
1325 class: string
1326 crush:
1327 class: array
1328 length: serious
1329 element-type:
1330 class: string
1331 canvas:
1332 class: array
1333 length: iron.dust
1334 element-type:
1335 class: string
1336 absolute:
1337 class: struct
1338 fields:
1339 equal:
1340 class: array
1341 length: event.fields.splendid
1342 element-type:
1343 class: string
1344 amuck:
1345 class: array
1346 length: event.context.cats
1347 element-type:
1348 class: string
1349 push:
1350 class: array
1351 length: event.context.berry.third
1352 element-type:
1353 class: string
1354 brick:
1355 class: array
1356 length: stream.event.context.face.magic
1357 element-type:
1358 class: string
1359 amuck:
1360 class: array
1361 length: stream.event.header.id
1362 element-type:
1363 class: string
1364 crush:
1365 class: array
1366 length: stream.packet.context.serious
1367 element-type:
1368 class: string
1369 canvas:
1370 class: array
1371 length: trace.packet.header.iron.dust
1372 element-type:
1373 class: string
1374
1375 */
1376
1377 struct bt_ctf_field_type *root = NULL;
1378 struct bt_ctf_field_type *root_splendid = NULL;
1379 struct bt_ctf_field_type *root_relative = NULL;
1380 struct bt_ctf_field_type *root_relative_equal = NULL;
1381 struct bt_ctf_field_type *root_relative_equal_elem = NULL;
1382 struct bt_ctf_field_type *root_relative_amuck = NULL;
1383 struct bt_ctf_field_type *root_relative_amuck_elem = NULL;
1384 struct bt_ctf_field_type *root_relative_push = NULL;
1385 struct bt_ctf_field_type *root_relative_push_elem = NULL;
1386 struct bt_ctf_field_type *root_relative_brick = NULL;
1387 struct bt_ctf_field_type *root_relative_brick_elem = NULL;
1388 struct bt_ctf_field_type *root_relative_crush = NULL;
1389 struct bt_ctf_field_type *root_relative_crush_elem = NULL;
1390 struct bt_ctf_field_type *root_relative_canvas = NULL;
1391 struct bt_ctf_field_type *root_relative_canvas_elem = NULL;
1392 struct bt_ctf_field_type *root_absolute = NULL;
1393 struct bt_ctf_field_type *root_absolute_equal = NULL;
1394 struct bt_ctf_field_type *root_absolute_equal_elem = NULL;
1395 struct bt_ctf_field_type *root_absolute_amuck = NULL;
1396 struct bt_ctf_field_type *root_absolute_amuck_elem = NULL;
1397 struct bt_ctf_field_type *root_absolute_push = NULL;
1398 struct bt_ctf_field_type *root_absolute_push_elem = NULL;
1399 struct bt_ctf_field_type *root_absolute_brick = NULL;
1400 struct bt_ctf_field_type *root_absolute_brick_elem = NULL;
1401 struct bt_ctf_field_type *root_absolute_crush = NULL;
1402 struct bt_ctf_field_type *root_absolute_crush_elem = NULL;
1403 struct bt_ctf_field_type *root_absolute_canvas = NULL;
1404 struct bt_ctf_field_type *root_absolute_canvas_elem = NULL;
1405
1406 int ret;
1407 root = bt_ctf_field_type_structure_create();
1408 assert(root);
1409 ret = bt_ctf_field_type_set_alignment(root, 8);
1410 assert(ret == 0);
1411 root_splendid = bt_ctf_field_type_integer_create(12);
1412 assert(root_splendid);
1413 ret = bt_ctf_field_type_integer_set_signed(root_splendid, 0);
1414 assert(ret == 0);
1415 ret = bt_ctf_field_type_integer_set_base(root_splendid, 10);
1416 assert(ret == 0);
1417 ret = bt_ctf_field_type_integer_set_encoding(root_splendid, CTF_STRING_NONE);
1418 assert(ret == 0);
1419 ret = bt_ctf_field_type_set_byte_order(root_splendid, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
1420 assert(ret == 0);
1421 ret = bt_ctf_field_type_set_alignment(root_splendid, 1);
1422 assert(ret == 0);
1423 ret = bt_ctf_field_type_structure_add_field(root, root_splendid, "splendid");
1424 assert(ret == 0);
1425 root_relative = bt_ctf_field_type_structure_create();
1426 assert(root_relative);
1427 ret = bt_ctf_field_type_set_alignment(root_relative, 8);
1428 assert(ret == 0);
1429 root_relative_equal_elem = bt_ctf_field_type_string_create();
1430 assert(root_relative_equal_elem);
1431 ret = bt_ctf_field_type_string_set_encoding(root_relative_equal_elem, CTF_STRING_UTF8);
1432 assert(ret == 0);
1433 root_relative_equal = bt_ctf_field_type_sequence_create(root_relative_equal_elem, "splendid");
1434 assert(root_relative_equal);
1435 ret = bt_ctf_field_type_structure_add_field(root_relative, root_relative_equal, "equal");
1436 assert(ret == 0);
1437 root_relative_amuck_elem = bt_ctf_field_type_string_create();
1438 assert(root_relative_amuck_elem);
1439 ret = bt_ctf_field_type_string_set_encoding(root_relative_amuck_elem, CTF_STRING_UTF8);
1440 assert(ret == 0);
1441 root_relative_amuck = bt_ctf_field_type_sequence_create(root_relative_amuck_elem, "id");
1442 assert(root_relative_amuck);
1443 ret = bt_ctf_field_type_structure_add_field(root_relative, root_relative_amuck, "amuck");
1444 assert(ret == 0);
1445 root_relative_push_elem = bt_ctf_field_type_string_create();
1446 assert(root_relative_push_elem);
1447 ret = bt_ctf_field_type_string_set_encoding(root_relative_push_elem, CTF_STRING_UTF8);
1448 assert(ret == 0);
1449 root_relative_push = bt_ctf_field_type_sequence_create(root_relative_push_elem, "berry.third");
1450 assert(root_relative_push);
1451 ret = bt_ctf_field_type_structure_add_field(root_relative, root_relative_push, "push");
1452 assert(ret == 0);
1453 root_relative_brick_elem = bt_ctf_field_type_string_create();
1454 assert(root_relative_brick_elem);
1455 ret = bt_ctf_field_type_string_set_encoding(root_relative_brick_elem, CTF_STRING_UTF8);
1456 assert(ret == 0);
1457 root_relative_brick = bt_ctf_field_type_sequence_create(root_relative_brick_elem, "face.magic");
1458 assert(root_relative_brick);
1459 ret = bt_ctf_field_type_structure_add_field(root_relative, root_relative_brick, "brick");
1460 assert(ret == 0);
1461 root_relative_crush_elem = bt_ctf_field_type_string_create();
1462 assert(root_relative_crush_elem);
1463 ret = bt_ctf_field_type_string_set_encoding(root_relative_crush_elem, CTF_STRING_UTF8);
1464 assert(ret == 0);
1465 root_relative_crush = bt_ctf_field_type_sequence_create(root_relative_crush_elem, "serious");
1466 assert(root_relative_crush);
1467 ret = bt_ctf_field_type_structure_add_field(root_relative, root_relative_crush, "crush");
1468 assert(ret == 0);
1469 root_relative_canvas_elem = bt_ctf_field_type_string_create();
1470 assert(root_relative_canvas_elem);
1471 ret = bt_ctf_field_type_string_set_encoding(root_relative_canvas_elem, CTF_STRING_UTF8);
1472 assert(ret == 0);
1473 root_relative_canvas = bt_ctf_field_type_sequence_create(root_relative_canvas_elem, "iron.dust");
1474 assert(root_relative_canvas);
1475 ret = bt_ctf_field_type_structure_add_field(root_relative, root_relative_canvas, "canvas");
1476 assert(ret == 0);
1477 ret = bt_ctf_field_type_structure_add_field(root, root_relative, "relative");
1478 assert(ret == 0);
1479 root_absolute = bt_ctf_field_type_structure_create();
1480 assert(root_absolute);
1481 ret = bt_ctf_field_type_set_alignment(root_absolute, 8);
1482 assert(ret == 0);
1483 root_absolute_equal_elem = bt_ctf_field_type_string_create();
1484 assert(root_absolute_equal_elem);
1485 ret = bt_ctf_field_type_string_set_encoding(root_absolute_equal_elem, CTF_STRING_UTF8);
1486 assert(ret == 0);
1487 root_absolute_equal = bt_ctf_field_type_sequence_create(root_absolute_equal_elem, "event.fields.splendid");
1488 assert(root_absolute_equal);
1489 ret = bt_ctf_field_type_structure_add_field(root_absolute, root_absolute_equal, "equal");
1490 assert(ret == 0);
1491 root_absolute_amuck_elem = bt_ctf_field_type_string_create();
1492 assert(root_absolute_amuck_elem);
1493 ret = bt_ctf_field_type_string_set_encoding(root_absolute_amuck_elem, CTF_STRING_UTF8);
1494 assert(ret == 0);
1495 root_absolute_amuck = bt_ctf_field_type_sequence_create(root_absolute_amuck_elem, "stream.event.header.id");
1496 assert(root_absolute_amuck);
1497 ret = bt_ctf_field_type_structure_add_field(root_absolute, root_absolute_amuck, "amuck");
1498 assert(ret == 0);
1499 root_absolute_push_elem = bt_ctf_field_type_string_create();
1500 assert(root_absolute_push_elem);
1501 ret = bt_ctf_field_type_string_set_encoding(root_absolute_push_elem, CTF_STRING_UTF8);
1502 assert(ret == 0);
1503 root_absolute_push = bt_ctf_field_type_sequence_create(root_absolute_push_elem, "event.context.berry.third");
1504 assert(root_absolute_push);
1505 ret = bt_ctf_field_type_structure_add_field(root_absolute, root_absolute_push, "push");
1506 assert(ret == 0);
1507 root_absolute_brick_elem = bt_ctf_field_type_string_create();
1508 assert(root_absolute_brick_elem);
1509 ret = bt_ctf_field_type_string_set_encoding(root_absolute_brick_elem, CTF_STRING_UTF8);
1510 assert(ret == 0);
1511 root_absolute_brick = bt_ctf_field_type_sequence_create(root_absolute_brick_elem, "stream.event.context.face.magic");
1512 assert(root_absolute_brick);
1513 ret = bt_ctf_field_type_structure_add_field(root_absolute, root_absolute_brick, "brick");
1514 assert(ret == 0);
1515 root_absolute_crush_elem = bt_ctf_field_type_string_create();
1516 assert(root_absolute_crush_elem);
1517 ret = bt_ctf_field_type_string_set_encoding(root_absolute_crush_elem, CTF_STRING_UTF8);
1518 assert(ret == 0);
1519 root_absolute_crush = bt_ctf_field_type_sequence_create(root_absolute_crush_elem, "stream.packet.context.serious");
1520 assert(root_absolute_crush);
1521 ret = bt_ctf_field_type_structure_add_field(root_absolute, root_absolute_crush, "crush");
1522 assert(ret == 0);
1523 root_absolute_canvas_elem = bt_ctf_field_type_string_create();
1524 assert(root_absolute_canvas_elem);
1525 ret = bt_ctf_field_type_string_set_encoding(root_absolute_canvas_elem, CTF_STRING_UTF8);
1526 assert(ret == 0);
1527 root_absolute_canvas = bt_ctf_field_type_sequence_create(root_absolute_canvas_elem, "trace.packet.header.iron.dust");
1528 assert(root_absolute_canvas);
1529 ret = bt_ctf_field_type_structure_add_field(root_absolute, root_absolute_canvas, "canvas");
1530 assert(ret == 0);
1531 ret = bt_ctf_field_type_structure_add_field(root, root_absolute, "absolute");
1532 assert(ret == 0);
1533
1534 BT_PUT(root_splendid);
1535 BT_PUT(root_relative);
1536 BT_PUT(root_relative_equal);
1537 BT_PUT(root_relative_equal_elem);
1538 BT_PUT(root_relative_amuck);
1539 BT_PUT(root_relative_amuck_elem);
1540 BT_PUT(root_relative_push);
1541 BT_PUT(root_relative_push_elem);
1542 BT_PUT(root_relative_brick);
1543 BT_PUT(root_relative_brick_elem);
1544 BT_PUT(root_relative_crush);
1545 BT_PUT(root_relative_crush_elem);
1546 BT_PUT(root_relative_canvas);
1547 BT_PUT(root_relative_canvas_elem);
1548 BT_PUT(root_absolute);
1549 BT_PUT(root_absolute_equal);
1550 BT_PUT(root_absolute_equal_elem);
1551 BT_PUT(root_absolute_amuck);
1552 BT_PUT(root_absolute_amuck_elem);
1553 BT_PUT(root_absolute_push);
1554 BT_PUT(root_absolute_push_elem);
1555 BT_PUT(root_absolute_brick);
1556 BT_PUT(root_absolute_brick_elem);
1557 BT_PUT(root_absolute_crush);
1558 BT_PUT(root_absolute_crush_elem);
1559 BT_PUT(root_absolute_canvas);
1560 BT_PUT(root_absolute_canvas_elem);
1561
1562 return root;
1563 }
1564
1565 static
1566 struct bt_ctf_field_type *get_child_ft(struct bt_ctf_field_type *parent_ft,
1567 const char *name)
1568 {
1569 struct bt_ctf_field_type *ft = NULL;
1570
1571 switch (bt_ctf_field_type_get_type_id(parent_ft)) {
1572 case CTF_TYPE_STRUCT:
1573 ft = bt_ctf_field_type_structure_get_field_type_by_name(
1574 parent_ft, name);
1575 break;
1576
1577 case CTF_TYPE_VARIANT:
1578 ft = bt_ctf_field_type_variant_get_field_type_by_name(
1579 parent_ft, name);
1580 break;
1581
1582 case CTF_TYPE_ARRAY:
1583 ft = bt_ctf_field_type_array_get_element_type(parent_ft);
1584 break;
1585
1586 case CTF_TYPE_SEQUENCE:
1587 ft = bt_ctf_field_type_sequence_get_element_type(parent_ft);
1588 break;
1589
1590 case CTF_TYPE_ENUM:
1591 ft = bt_ctf_field_type_enumeration_get_container_type(
1592 parent_ft);
1593 break;
1594
1595 default:
1596 break;
1597 }
1598
1599 assert(ft);
1600
1601 return ft;
1602 }
1603
1604 static
1605 struct bt_ctf_field_type *get_ft(struct bt_ctf_field_type *root_ft, ...)
1606 {
1607 struct bt_ctf_field_type *child_ft = NULL;
1608 struct bt_ctf_field_type *ft = root_ft;
1609 va_list ap;
1610
1611 va_start(ap, root_ft);
1612 bt_get(ft);
1613
1614 while (true) {
1615 const char *field_name = va_arg(ap, const char *);
1616
1617 if (field_name == NULL) {
1618 break;
1619 }
1620
1621 child_ft = get_child_ft(ft, field_name);
1622
1623 if (!child_ft) {
1624 BT_PUT(ft);
1625 goto end;
1626 }
1627
1628 BT_MOVE(ft, child_ft);
1629 }
1630
1631 end:
1632 va_end(ap);
1633
1634 return ft;
1635 }
1636
1637 #define FIELD_PATH_END -2
1638
1639 static
1640 int validate_field_path(struct bt_ctf_field_type *field_type,
1641 enum bt_ctf_node root, ...)
1642 {
1643 int ret = 0;
1644 int len;
1645 int expected_index;
1646 int actual_index;
1647 int i = 0;
1648 const struct bt_ctf_field_path *field_path;
1649 va_list ap;
1650
1651 va_start(ap, root);
1652
1653 if (bt_ctf_field_type_is_sequence(field_type)) {
1654 field_path = ((struct bt_ctf_field_type_sequence *)
1655 field_type)->length_field_path;
1656 } else if (bt_ctf_field_type_is_variant(field_type)) {
1657 field_path = ((struct bt_ctf_field_type_variant *)
1658 field_type)->tag_path;
1659 } else {
1660 ret = -1;
1661 goto end;
1662 }
1663
1664 if (!field_path) {
1665 ret = -1;
1666 goto end;
1667 }
1668
1669 if (field_path->root != root) {
1670 ret = -1;
1671 goto end;
1672 }
1673
1674 len = field_path->path_indexes->len;
1675
1676 while (true) {
1677 expected_index = va_arg(ap, int);
1678
1679 if (expected_index == FIELD_PATH_END) {
1680 break;
1681 }
1682
1683 if (i == len) {
1684 break;
1685 }
1686
1687 actual_index = g_array_index(field_path->path_indexes, int, i);
1688
1689 if (actual_index != expected_index) {
1690 ret = -1;
1691 goto end;
1692 }
1693
1694 i++;
1695 }
1696
1697 if (i != len || expected_index != FIELD_PATH_END) {
1698 ret = -1;
1699 }
1700
1701 end:
1702 va_end(ap);
1703
1704 return ret;
1705 }
1706
1707 static
1708 void validate_test_pass(struct bt_ctf_trace *trace)
1709 {
1710 struct bt_ctf_stream_class *sc;
1711 struct bt_ctf_event_class *ec;
1712 struct bt_ctf_field_type *ph;
1713 struct bt_ctf_field_type *pc;
1714 struct bt_ctf_field_type *eh;
1715 struct bt_ctf_field_type *sec;
1716 struct bt_ctf_field_type *ectx;
1717 struct bt_ctf_field_type *ep;
1718 struct bt_ctf_field_type *ft_src = NULL;
1719 struct bt_ctf_field_type *ft_target = NULL;
1720 struct bt_ctf_field_type *ft_tag = NULL;
1721
1722 sc = bt_ctf_trace_get_stream_class(trace, 0);
1723 assert(sc);
1724 ec = bt_ctf_stream_class_get_event_class(sc, 0);
1725 assert(ec);
1726
1727 ph = bt_ctf_trace_get_packet_header_type(trace);
1728 ok(ph, "Trace packet header still exists after successful validation");
1729 pc = bt_ctf_stream_class_get_packet_context_type(sc);
1730 ok(pc, "Stream packet context still exists after successful validation");
1731 eh = bt_ctf_stream_class_get_event_header_type(sc);
1732 ok(eh, "Stream event header still exists after successful validation");
1733 sec = bt_ctf_stream_class_get_event_context_type(sc);
1734 ok(sec, "Stream event context still exists after successful validation");
1735 ectx = bt_ctf_event_class_get_context_type(ec);
1736 ok(ectx, "Event context still exists after successful validation");
1737 ep = bt_ctf_event_class_get_payload_type(ec);
1738 ok(ep, "Event payload still exists after successful validation");
1739
1740 /* trace.packet.header.iron.fire.keen */
1741 ft_src = get_ft(ph, "iron", "fire", "keen", NULL);
1742 ok(!validate_field_path(ft_src, CTF_NODE_TRACE_PACKET_HEADER,
1743 3, 3, 0, FIELD_PATH_END),
1744 "trace.packet.header.iron.fire.keen has the correct field path");
1745 BT_PUT(ft_src);
1746
1747 /* trace.packet.header.iron.fire.keen.[element] */
1748 ft_src = get_ft(ph, "iron", "fire", "keen", "", NULL);
1749 ok(!validate_field_path(ft_src,
1750 CTF_NODE_TRACE_PACKET_HEADER, 3, 2, FIELD_PATH_END),
1751 "trace.packet.header.iron.fire.keen.[element] has the correct field path");
1752 ft_target = get_ft(ph, "iron", "parallel", NULL);
1753 ft_tag = bt_ctf_field_type_variant_get_tag_type(ft_src);
1754 ok(ft_tag == ft_target,
1755 "trace.packet.header.iron.fire.keen.[element] has the correct tag type");
1756 BT_PUT(ft_src);
1757 BT_PUT(ft_target);
1758 BT_PUT(ft_tag);
1759
1760 /* trace.packet.header.iron.fire.keen.[element].BLUE */
1761 ft_src = get_ft(ph, "iron", "fire", "keen", "", "BLUE", NULL);
1762 ok(!validate_field_path(ft_src,
1763 CTF_NODE_TRACE_PACKET_HEADER, 0, FIELD_PATH_END),
1764 "trace.packet.header.iron.fire.keen.[element].BLUE has the correct field path");
1765 BT_PUT(ft_src);
1766
1767 /* trace.packet.header.iron.report */
1768 ft_src = get_ft(ph, "iron", "report", NULL);
1769 ok(!validate_field_path(ft_src,
1770 CTF_NODE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
1771 "trace.packet.header.iron.report has the correct field path");
1772 BT_PUT(ft_src);
1773
1774 /* trace.packet.header.iron.group */
1775 ft_src = get_ft(ph, "iron", "group", NULL);
1776 ok(!validate_field_path(ft_src,
1777 CTF_NODE_TRACE_PACKET_HEADER, 2, FIELD_PATH_END),
1778 "trace.packet.header.iron.group has the correct field path");
1779 BT_PUT(ft_src);
1780
1781 /* stream.packet.context.naive.[element] */
1782 ft_src = get_ft(pc, "naive", "", NULL);
1783 ok(!validate_field_path(ft_src,
1784 CTF_NODE_STREAM_PACKET_CONTEXT, 0, FIELD_PATH_END),
1785 "stream.packet.context.naive.[element] has the correct field path");
1786 BT_PUT(ft_src);
1787
1788 /* stream.packet.context.clover.whole */
1789 ft_src = get_ft(pc, "clover", "whole", NULL);
1790 ok(!validate_field_path(ft_src,
1791 CTF_NODE_TRACE_PACKET_HEADER, 3, 2, FIELD_PATH_END),
1792 "stream.packet.context.clover.whole has the correct field path");
1793 ft_target = get_ft(ph, "iron", "parallel", NULL);
1794 ft_tag = bt_ctf_field_type_variant_get_tag_type(ft_src);
1795 ok(ft_tag == ft_target,
1796 "stream.packet.context.clover.whole has the correct tag type");
1797 BT_PUT(ft_src);
1798 BT_PUT(ft_target);
1799 BT_PUT(ft_tag);
1800
1801 /* stream.packet.context.clover.whole.BLUE */
1802 ft_src = get_ft(pc, "clover", "whole", "BLUE", NULL);
1803 ok(!validate_field_path(ft_src,
1804 CTF_NODE_TRACE_PACKET_HEADER, 3, 3, 0, FIELD_PATH_END),
1805 "stream.packet.context.clover.whole.BLUE has the correct field path");
1806 BT_PUT(ft_src);
1807
1808 /* stream.packet.context.clover.egg */
1809 ft_src = get_ft(pc, "clover", "egg", NULL);
1810 ok(!validate_field_path(ft_src,
1811 CTF_NODE_STREAM_PACKET_CONTEXT, 4, 0, FIELD_PATH_END),
1812 "stream.packet.context.clover.egg has the correct field path");
1813 BT_PUT(ft_src);
1814
1815 /* stream.packet.context.clover.useful */
1816 ft_src = get_ft(pc, "clover", "useful", NULL);
1817 ok(!validate_field_path(ft_src,
1818 CTF_NODE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
1819 "stream.packet.context.clover.useful has the correct field path");
1820 BT_PUT(ft_src);
1821
1822 /* stream.event.header.action.lucky */
1823 ft_src = get_ft(eh, "action", "lucky", NULL);
1824 ok(!validate_field_path(ft_src,
1825 CTF_NODE_STREAM_PACKET_CONTEXT, 0, FIELD_PATH_END),
1826 "stream.event.header.action.lucky has the correct field path");
1827 BT_PUT(ft_src);
1828
1829 /* stream.event.header.stiff */
1830 ft_src = get_ft(eh, "stiff", NULL);
1831 ok(!validate_field_path(ft_src,
1832 CTF_NODE_STREAM_PACKET_CONTEXT, 4, 1, 1, FIELD_PATH_END),
1833 "stream.event.header.stiff has the correct field path");
1834 BT_PUT(ft_src);
1835
1836 /* stream.event.header.fruit.apple */
1837 ft_src = get_ft(eh, "fruit", "apple", NULL);
1838 ok(!validate_field_path(ft_src,
1839 CTF_NODE_STREAM_EVENT_HEADER, 2, 0, FIELD_PATH_END),
1840 "stream.event.header.fruit.apple has the correct field path");
1841 BT_PUT(ft_src);
1842
1843 /* stream.event.context.face.branch */
1844 ft_src = get_ft(sec, "face", "branch", NULL);
1845 ok(!validate_field_path(ft_src,
1846 CTF_NODE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
1847 "stream.event.context.face.branch has the correct field path");
1848 BT_PUT(ft_src);
1849
1850 /* stream.event.context.face.income */
1851 ft_src = get_ft(sec, "face", "income", NULL);
1852 ok(!validate_field_path(ft_src,
1853 CTF_NODE_TRACE_PACKET_HEADER, 0, FIELD_PATH_END),
1854 "stream.event.context.face.income has the correct field path");
1855 BT_PUT(ft_src);
1856
1857 /* stream.event.context.face.lucky */
1858 ft_src = get_ft(sec, "face", "lucky", NULL);
1859 ok(!validate_field_path(ft_src,
1860 CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
1861 "stream.event.context.face.lucky has the correct field path");
1862 BT_PUT(ft_src);
1863
1864 /* stream.event.context.dream */
1865 ft_src = get_ft(sec, "dream", NULL);
1866 ok(!validate_field_path(ft_src,
1867 CTF_NODE_STREAM_PACKET_CONTEXT, 0, FIELD_PATH_END),
1868 "stream.event.context.dream has the correct field path");
1869 BT_PUT(ft_src);
1870
1871 /* stream.event.context.dream.[element] */
1872 ft_src = get_ft(sec, "dream", "", NULL);
1873 ok(!validate_field_path(ft_src,
1874 CTF_NODE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
1875 "stream.event.context.dream.[element] has the correct field path");
1876 BT_PUT(ft_src);
1877
1878 /* stream.event.context.dream.[element].[element] */
1879 ft_src = get_ft(sec, "dream", "", "", NULL);
1880 ok(!validate_field_path(ft_src,
1881 CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
1882 "stream.event.context.dream.[element].[element] has the correct field path");
1883 BT_PUT(ft_src);
1884
1885 /* event.context.berry.porter */
1886 ft_src = get_ft(ectx, "berry", "porter", NULL);
1887 ok(!validate_field_path(ft_src,
1888 CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
1889 "event.context.berry.porter has the correct field path");
1890 BT_PUT(ft_src);
1891
1892 /* event.context.berry.porter */
1893 ft_src = get_ft(ectx, "berry", "porter", NULL);
1894 ok(!validate_field_path(ft_src,
1895 CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
1896 "event.context.berry.porter has the correct field path");
1897 BT_PUT(ft_src);
1898
1899 /* event.context.berry.mice */
1900 ft_src = get_ft(ectx, "berry", "mice", NULL);
1901 ok(!validate_field_path(ft_src,
1902 CTF_NODE_STREAM_EVENT_HEADER, 2, 0, FIELD_PATH_END),
1903 "event.context.berry.mice has the correct field path");
1904 BT_PUT(ft_src);
1905
1906 /* event.context.berry.guard */
1907 ft_src = get_ft(ectx, "berry", "guard", NULL);
1908 ok(!validate_field_path(ft_src,
1909 CTF_NODE_STREAM_PACKET_CONTEXT, 4, 0, FIELD_PATH_END),
1910 "event.context.berry.guard has the correct field path");
1911 BT_PUT(ft_src);
1912
1913 /* event.context.berry.one */
1914 ft_src = get_ft(ectx, "berry", "one", NULL);
1915 ok(!validate_field_path(ft_src,
1916 CTF_NODE_TRACE_PACKET_HEADER, 3, 3, 0, FIELD_PATH_END),
1917 "event.context.berry.one has the correct field path");
1918 BT_PUT(ft_src);
1919
1920 /* event.context.loud.toys */
1921 ft_src = get_ft(ectx, "loud", "toys", NULL);
1922 ok(!validate_field_path(ft_src,
1923 CTF_NODE_TRACE_PACKET_HEADER, 3, 3, 0, FIELD_PATH_END),
1924 "event.context.loud.toys has the correct field path");
1925 BT_PUT(ft_src);
1926
1927 /* event.context.loud.spoon */
1928 ft_src = get_ft(ectx, "loud", "spoon", NULL);
1929 ok(!validate_field_path(ft_src,
1930 CTF_NODE_STREAM_PACKET_CONTEXT, 4, 0, FIELD_PATH_END),
1931 "event.context.loud.spoon has the correct field path");
1932 BT_PUT(ft_src);
1933
1934 /* event.context.loud.turkey */
1935 ft_src = get_ft(ectx, "loud", "turkey", NULL);
1936 ok(!validate_field_path(ft_src,
1937 CTF_NODE_STREAM_EVENT_HEADER, 2, 0, FIELD_PATH_END),
1938 "event.context.loud.turkey has the correct field path");
1939 BT_PUT(ft_src);
1940
1941 /* event.context.loud.inform */
1942 ft_src = get_ft(ectx, "loud", "inform", NULL);
1943 ok(!validate_field_path(ft_src,
1944 CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
1945 "event.context.loud.inform has the correct field path");
1946 BT_PUT(ft_src);
1947
1948 /* event.context.loud.odd */
1949 ft_src = get_ft(ectx, "loud", "odd", NULL);
1950 ok(!validate_field_path(ft_src,
1951 CTF_NODE_EVENT_CONTEXT, 1, 3, FIELD_PATH_END),
1952 "event.context.loud.odd has the correct field path");
1953 BT_PUT(ft_src);
1954
1955 /* event.context.loud.amuck */
1956 ft_src = get_ft(ectx, "loud", "amuck", NULL);
1957 ok(!validate_field_path(ft_src,
1958 CTF_NODE_EVENT_CONTEXT, 0, FIELD_PATH_END),
1959 "event.context.loud.amuck has the correct field path");
1960 BT_PUT(ft_src);
1961
1962 /* event.fields.relative.equal */
1963 ft_src = get_ft(ep, "relative", "equal", NULL);
1964 ok(!validate_field_path(ft_src,
1965 CTF_NODE_EVENT_FIELDS, 0, FIELD_PATH_END),
1966 "event.fields.relative.equal has the correct field path");
1967 BT_PUT(ft_src);
1968
1969 /* event.fields.relative.amuck */
1970 ft_src = get_ft(ep, "relative", "amuck", NULL);
1971 ok(!validate_field_path(ft_src,
1972 CTF_NODE_STREAM_EVENT_HEADER, 0, FIELD_PATH_END),
1973 "event.fields.relative.amuck has the correct field path");
1974 BT_PUT(ft_src);
1975
1976 /* event.fields.relative.push */
1977 ft_src = get_ft(ep, "relative", "push", NULL);
1978 ok(!validate_field_path(ft_src,
1979 CTF_NODE_EVENT_CONTEXT, 1, 3, FIELD_PATH_END),
1980 "event.fields.relative.push has the correct field path");
1981 BT_PUT(ft_src);
1982
1983 /* event.fields.relative.brick */
1984 ft_src = get_ft(ep, "relative", "brick", NULL);
1985 ok(!validate_field_path(ft_src,
1986 CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
1987 "event.fields.relative.brick has the correct field path");
1988 BT_PUT(ft_src);
1989
1990 /* event.fields.relative.crush */
1991 ft_src = get_ft(ep, "relative", "crush", NULL);
1992 ok(!validate_field_path(ft_src,
1993 CTF_NODE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
1994 "event.fields.relative.crush has the correct field path");
1995 BT_PUT(ft_src);
1996
1997 /* event.fields.relative.canvas */
1998 ft_src = get_ft(ep, "relative", "canvas", NULL);
1999 ok(!validate_field_path(ft_src,
2000 CTF_NODE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
2001 "event.fields.relative.canvas has the correct field path");
2002 BT_PUT(ft_src);
2003
2004 /* event.fields.absolute.equal */
2005 ft_src = get_ft(ep, "absolute", "equal", NULL);
2006 ok(!validate_field_path(ft_src,
2007 CTF_NODE_EVENT_FIELDS, 0, FIELD_PATH_END),
2008 "event.fields.absolute.equal has the correct field path");
2009 BT_PUT(ft_src);
2010
2011 /* event.fields.absolute.amuck */
2012 ft_src = get_ft(ep, "absolute", "amuck", NULL);
2013 ok(!validate_field_path(ft_src,
2014 CTF_NODE_STREAM_EVENT_HEADER, 0, FIELD_PATH_END),
2015 "event.fields.absolute.amuck has the correct field path");
2016 BT_PUT(ft_src);
2017
2018 /* event.fields.absolute.push */
2019 ft_src = get_ft(ep, "absolute", "push", NULL);
2020 ok(!validate_field_path(ft_src,
2021 CTF_NODE_EVENT_CONTEXT, 1, 3, FIELD_PATH_END),
2022 "event.fields.absolute.push has the correct field path");
2023 BT_PUT(ft_src);
2024
2025 /* event.fields.absolute.brick */
2026 ft_src = get_ft(ep, "absolute", "brick", NULL);
2027 ok(!validate_field_path(ft_src,
2028 CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
2029 "event.fields.absolute.brick has the correct field path");
2030 BT_PUT(ft_src);
2031
2032 /* event.fields.absolute.crush */
2033 ft_src = get_ft(ep, "absolute", "crush", NULL);
2034 ok(!validate_field_path(ft_src,
2035 CTF_NODE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
2036 "event.fields.absolute.crush has the correct field path");
2037 BT_PUT(ft_src);
2038
2039 /* event.fields.absolute.canvas */
2040 ft_src = get_ft(ep, "absolute", "canvas", NULL);
2041 ok(!validate_field_path(ft_src,
2042 CTF_NODE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
2043 "event.fields.absolute.canvas has the correct field path");
2044 BT_PUT(ft_src);
2045
2046 BT_PUT(ft_src);
2047 BT_PUT(ft_target);
2048 BT_PUT(ph);
2049 BT_PUT(pc);
2050 BT_PUT(eh);
2051 BT_PUT(sec);
2052 BT_PUT(ectx);
2053 BT_PUT(ep);
2054 BT_PUT(sc);
2055 BT_PUT(ec);
2056 }
2057
2058 static
2059 void test_pass(void)
2060 {
2061 int ret;
2062 struct bt_ctf_trace *trace;
2063 struct bt_ctf_stream_class *sc;
2064 struct bt_ctf_event_class *ec;
2065 struct bt_ctf_field_type *ph;
2066 struct bt_ctf_field_type *pc;
2067 struct bt_ctf_field_type *eh;
2068 struct bt_ctf_field_type *sec;
2069 struct bt_ctf_field_type *ectx;
2070 struct bt_ctf_field_type *ep;
2071
2072 trace = bt_ctf_trace_create();
2073 assert(trace);
2074 sc = bt_ctf_stream_class_create("nice_piece_of_stream_class");
2075 assert(sc);
2076 ec = bt_ctf_event_class_create("oh_what_an_event_class");
2077 assert(ec);
2078
2079 ph = get_good_packet_header_type();
2080 assert(ph);
2081 pc = get_good_packet_context_type();
2082 assert(pc);
2083 eh = get_good_event_header_type();
2084 assert(eh);
2085 sec = get_good_stream_event_context_type();
2086 assert(sec);
2087 ectx = get_good_event_context_type();
2088 assert(ec);
2089 ep = get_good_event_payload_type();
2090 assert(ep);
2091
2092 ret = bt_ctf_trace_set_packet_header_type(trace, ph);
2093 assert(ret == 0);
2094 ret = bt_ctf_stream_class_set_packet_context_type(sc, pc);
2095 assert(ret == 0);
2096 ret = bt_ctf_stream_class_set_event_header_type(sc, eh);
2097 assert(ret == 0);
2098 ret = bt_ctf_stream_class_set_event_context_type(sc, sec);
2099 assert(ret == 0);
2100 ret = bt_ctf_event_class_set_context_type(ec, ectx);
2101 assert(ret == 0);
2102 ret = bt_ctf_event_class_set_payload_type(ec, ep);
2103 assert(ret == 0);
2104
2105 ret = bt_ctf_stream_class_add_event_class(sc, ec);
2106 assert(ret == 0);
2107
2108 /* Validation happens here */
2109 ret = bt_ctf_trace_add_stream_class(trace, sc);
2110 ok(ret == 0, "Valid type system is considered valid");
2111
2112 validate_test_pass(trace);
2113
2114 BT_PUT(ph);
2115 BT_PUT(pc);
2116 BT_PUT(eh);
2117 BT_PUT(sec);
2118 BT_PUT(ectx);
2119 BT_PUT(ep);
2120 BT_PUT(trace);
2121 BT_PUT(sc);
2122 BT_PUT(ec);
2123 }
2124
2125 static
2126 struct bt_ctf_event *create_event_with_context_and_payload(
2127 struct bt_ctf_field_type *ectx, struct bt_ctf_field_type *ep)
2128 {
2129 int ret;
2130 struct bt_ctf_stream_class *sc;
2131 struct bt_ctf_event_class *ec;
2132 struct bt_ctf_event *event;
2133
2134 sc = bt_ctf_stream_class_create("sc");
2135 assert(sc);
2136 ec = bt_ctf_event_class_create("ec");
2137 assert(ec);
2138
2139 if (ectx) {
2140 ret = bt_ctf_event_class_set_context_type(ec, ectx);
2141 assert(ret == 0);
2142 }
2143
2144 if (ep) {
2145 ret = bt_ctf_event_class_set_payload_type(ec, ep);
2146 assert(ret == 0);
2147 }
2148
2149 ret = bt_ctf_stream_class_add_event_class(sc, ec);
2150 assert(ret == 0);
2151
2152 /* Validation happens here */
2153 event = bt_ctf_event_create(ec);
2154
2155 BT_PUT(ec);
2156 BT_PUT(sc);
2157
2158 return event;
2159 }
2160
2161
2162 static
2163 struct bt_ctf_field_type *test_fail_unavailable_root_get_event_payload(void)
2164 {
2165 /*
2166 Generated by bt-ctfirtg using the following input:
2167
2168 class: struct
2169 fields:
2170 a:
2171 class: int
2172 size: 32
2173 b:
2174 class: array
2175 length: stream.event.context.lol
2176 element-type:
2177 class: string
2178 c:
2179 class: string
2180
2181 */
2182
2183 struct bt_ctf_field_type *root = NULL;
2184 struct bt_ctf_field_type *root_a = NULL;
2185 struct bt_ctf_field_type *root_b = NULL;
2186 struct bt_ctf_field_type *root_b_elem = NULL;
2187 struct bt_ctf_field_type *root_c = NULL;
2188
2189 int ret;
2190 root = bt_ctf_field_type_structure_create();
2191 assert(root);
2192 ret = bt_ctf_field_type_set_alignment(root, 8);
2193 assert(ret == 0);
2194 root_a = bt_ctf_field_type_integer_create(32);
2195 assert(root_a);
2196 ret = bt_ctf_field_type_integer_set_signed(root_a, 0);
2197 assert(ret == 0);
2198 ret = bt_ctf_field_type_integer_set_base(root_a, 10);
2199 assert(ret == 0);
2200 ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
2201 assert(ret == 0);
2202 ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2203 assert(ret == 0);
2204 ret = bt_ctf_field_type_set_alignment(root_a, 8);
2205 assert(ret == 0);
2206 ret = bt_ctf_field_type_structure_add_field(root, root_a, "a");
2207 assert(ret == 0);
2208 root_b_elem = bt_ctf_field_type_string_create();
2209 assert(root_b_elem);
2210 ret = bt_ctf_field_type_string_set_encoding(root_b_elem, CTF_STRING_UTF8);
2211 assert(ret == 0);
2212 root_b = bt_ctf_field_type_sequence_create(root_b_elem, "stream.event.context.lol");
2213 assert(root_b);
2214 ret = bt_ctf_field_type_structure_add_field(root, root_b, "b");
2215 assert(ret == 0);
2216 root_c = bt_ctf_field_type_string_create();
2217 assert(root_c);
2218 ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
2219 assert(ret == 0);
2220 ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
2221 assert(ret == 0);
2222
2223 BT_PUT(root_a);
2224 BT_PUT(root_b);
2225 BT_PUT(root_b_elem);
2226 BT_PUT(root_c);
2227
2228 return root;
2229 }
2230
2231 static
2232 void test_fail_unavailable_root(void)
2233 {
2234 struct bt_ctf_field_type *ep;
2235 struct bt_ctf_event *event;
2236
2237 ep = test_fail_unavailable_root_get_event_payload();
2238 assert(ep);
2239 event = create_event_with_context_and_payload(NULL, ep);
2240 ok(!event, "Sequence FT with length in unavailable root is invalid");
2241
2242 BT_PUT(ep);
2243 BT_PUT(event);
2244 }
2245
2246 static
2247 struct bt_ctf_field_type *test_fail_target_is_root_get_event_payload(void)
2248 {
2249 /*
2250 Generated by bt-ctfirtg using the following input:
2251
2252 class: struct
2253 fields:
2254 a:
2255 class: int
2256 size: 32
2257 b:
2258 class: array
2259 length: event.fields
2260 element-type:
2261 class: string
2262 c:
2263 class: string
2264
2265 */
2266
2267 struct bt_ctf_field_type *root = NULL;
2268 struct bt_ctf_field_type *root_a = NULL;
2269 struct bt_ctf_field_type *root_b = NULL;
2270 struct bt_ctf_field_type *root_b_elem = NULL;
2271 struct bt_ctf_field_type *root_c = NULL;
2272
2273 int ret;
2274 root = bt_ctf_field_type_structure_create();
2275 assert(root);
2276 ret = bt_ctf_field_type_set_alignment(root, 8);
2277 assert(ret == 0);
2278 root_a = bt_ctf_field_type_integer_create(32);
2279 assert(root_a);
2280 ret = bt_ctf_field_type_integer_set_signed(root_a, 0);
2281 assert(ret == 0);
2282 ret = bt_ctf_field_type_integer_set_base(root_a, 10);
2283 assert(ret == 0);
2284 ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
2285 assert(ret == 0);
2286 ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2287 assert(ret == 0);
2288 ret = bt_ctf_field_type_set_alignment(root_a, 8);
2289 assert(ret == 0);
2290 ret = bt_ctf_field_type_structure_add_field(root, root_a, "a");
2291 assert(ret == 0);
2292 root_b_elem = bt_ctf_field_type_string_create();
2293 assert(root_b_elem);
2294 ret = bt_ctf_field_type_string_set_encoding(root_b_elem, CTF_STRING_UTF8);
2295 assert(ret == 0);
2296 root_b = bt_ctf_field_type_sequence_create(root_b_elem, "event.fields");
2297 assert(root_b);
2298 ret = bt_ctf_field_type_structure_add_field(root, root_b, "b");
2299 assert(ret == 0);
2300 root_c = bt_ctf_field_type_string_create();
2301 assert(root_c);
2302 ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
2303 assert(ret == 0);
2304 ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
2305 assert(ret == 0);
2306
2307 BT_PUT(root_a);
2308 BT_PUT(root_b);
2309 BT_PUT(root_b_elem);
2310 BT_PUT(root_c);
2311
2312 return root;
2313 }
2314
2315 static
2316 void test_fail_target_is_root(void)
2317 {
2318 struct bt_ctf_field_type *ep;
2319 struct bt_ctf_event *event;
2320
2321 ep = test_fail_target_is_root_get_event_payload();
2322 assert(ep);
2323 event = create_event_with_context_and_payload(NULL, ep);
2324 ok(!event, "Sequence FT with root as its length is invalid");
2325
2326 BT_PUT(ep);
2327 BT_PUT(event);
2328 }
2329
2330 static
2331 struct bt_ctf_field_type *test_fail_target_is_after_source_get_ep(void)
2332 {
2333 /*
2334 Generated by bt-ctfirtg using the following input:
2335
2336 class: struct
2337 fields:
2338 a:
2339 class: int
2340 size: 32
2341 b:
2342 class: array
2343 length: d
2344 element-type:
2345 class: string
2346 c:
2347 class: string
2348 d:
2349 class: int
2350 size: 17
2351
2352 */
2353
2354 struct bt_ctf_field_type *root = NULL;
2355 struct bt_ctf_field_type *root_a = NULL;
2356 struct bt_ctf_field_type *root_b = NULL;
2357 struct bt_ctf_field_type *root_b_elem = NULL;
2358 struct bt_ctf_field_type *root_c = NULL;
2359 struct bt_ctf_field_type *root_d = NULL;
2360
2361 int ret;
2362 root = bt_ctf_field_type_structure_create();
2363 assert(root);
2364 ret = bt_ctf_field_type_set_alignment(root, 8);
2365 assert(ret == 0);
2366 root_a = bt_ctf_field_type_integer_create(32);
2367 assert(root_a);
2368 ret = bt_ctf_field_type_integer_set_signed(root_a, 0);
2369 assert(ret == 0);
2370 ret = bt_ctf_field_type_integer_set_base(root_a, 10);
2371 assert(ret == 0);
2372 ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
2373 assert(ret == 0);
2374 ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2375 assert(ret == 0);
2376 ret = bt_ctf_field_type_set_alignment(root_a, 8);
2377 assert(ret == 0);
2378 ret = bt_ctf_field_type_structure_add_field(root, root_a, "a");
2379 assert(ret == 0);
2380 root_b_elem = bt_ctf_field_type_string_create();
2381 assert(root_b_elem);
2382 ret = bt_ctf_field_type_string_set_encoding(root_b_elem, CTF_STRING_UTF8);
2383 assert(ret == 0);
2384 root_b = bt_ctf_field_type_sequence_create(root_b_elem, "d");
2385 assert(root_b);
2386 ret = bt_ctf_field_type_structure_add_field(root, root_b, "b");
2387 assert(ret == 0);
2388 root_c = bt_ctf_field_type_string_create();
2389 assert(root_c);
2390 ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
2391 assert(ret == 0);
2392 ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
2393 assert(ret == 0);
2394 root_d = bt_ctf_field_type_integer_create(17);
2395 assert(root_d);
2396 ret = bt_ctf_field_type_integer_set_signed(root_d, 0);
2397 assert(ret == 0);
2398 ret = bt_ctf_field_type_integer_set_base(root_d, 10);
2399 assert(ret == 0);
2400 ret = bt_ctf_field_type_integer_set_encoding(root_d, CTF_STRING_NONE);
2401 assert(ret == 0);
2402 ret = bt_ctf_field_type_set_byte_order(root_d, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2403 assert(ret == 0);
2404 ret = bt_ctf_field_type_set_alignment(root_d, 1);
2405 assert(ret == 0);
2406 ret = bt_ctf_field_type_structure_add_field(root, root_d, "d");
2407 assert(ret == 0);
2408
2409 BT_PUT(root_a);
2410 BT_PUT(root_b);
2411 BT_PUT(root_b_elem);
2412 BT_PUT(root_c);
2413 BT_PUT(root_d);
2414
2415 return root;
2416 }
2417
2418 static
2419 void test_fail_target_is_after_source(void)
2420 {
2421 struct bt_ctf_field_type *ep;
2422 struct bt_ctf_event *event;
2423
2424 ep = test_fail_target_is_after_source_get_ep();
2425 assert(ep);
2426 event = create_event_with_context_and_payload(NULL, ep);
2427 ok(!event, "Sequence FT with length after it is invalid");
2428
2429 BT_PUT(ep);
2430 BT_PUT(event);
2431 }
2432
2433 static
2434 struct bt_ctf_field_type *test_fail_target_is_ancestor_of_source_get_ep(void)
2435 {
2436 /*
2437 Generated by bt-ctfirtg using the following input:
2438
2439 class: struct
2440 fields:
2441 a:
2442 class: int
2443 size: 32
2444 z:
2445 class: struct
2446 fields:
2447 b:
2448 class: array
2449 length: z
2450 element-type:
2451 class: string
2452 c:
2453 class: string
2454 d:
2455 class: int
2456 size: 17
2457
2458 */
2459
2460 struct bt_ctf_field_type *root = NULL;
2461 struct bt_ctf_field_type *root_a = NULL;
2462 struct bt_ctf_field_type *root_z = NULL;
2463 struct bt_ctf_field_type *root_z_b = NULL;
2464 struct bt_ctf_field_type *root_z_b_elem = NULL;
2465 struct bt_ctf_field_type *root_c = NULL;
2466 struct bt_ctf_field_type *root_d = NULL;
2467
2468 int ret;
2469 root = bt_ctf_field_type_structure_create();
2470 assert(root);
2471 ret = bt_ctf_field_type_set_alignment(root, 8);
2472 assert(ret == 0);
2473 root_a = bt_ctf_field_type_integer_create(32);
2474 assert(root_a);
2475 ret = bt_ctf_field_type_integer_set_signed(root_a, 0);
2476 assert(ret == 0);
2477 ret = bt_ctf_field_type_integer_set_base(root_a, 10);
2478 assert(ret == 0);
2479 ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
2480 assert(ret == 0);
2481 ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2482 assert(ret == 0);
2483 ret = bt_ctf_field_type_set_alignment(root_a, 8);
2484 assert(ret == 0);
2485 ret = bt_ctf_field_type_structure_add_field(root, root_a, "a");
2486 assert(ret == 0);
2487 root_z = bt_ctf_field_type_structure_create();
2488 assert(root_z);
2489 ret = bt_ctf_field_type_set_alignment(root_z, 8);
2490 assert(ret == 0);
2491 root_z_b_elem = bt_ctf_field_type_string_create();
2492 assert(root_z_b_elem);
2493 ret = bt_ctf_field_type_string_set_encoding(root_z_b_elem, CTF_STRING_UTF8);
2494 assert(ret == 0);
2495 root_z_b = bt_ctf_field_type_sequence_create(root_z_b_elem, "z");
2496 assert(root_z_b);
2497 ret = bt_ctf_field_type_structure_add_field(root_z, root_z_b, "b");
2498 assert(ret == 0);
2499 ret = bt_ctf_field_type_structure_add_field(root, root_z, "z");
2500 assert(ret == 0);
2501 root_c = bt_ctf_field_type_string_create();
2502 assert(root_c);
2503 ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
2504 assert(ret == 0);
2505 ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
2506 assert(ret == 0);
2507 root_d = bt_ctf_field_type_integer_create(17);
2508 assert(root_d);
2509 ret = bt_ctf_field_type_integer_set_signed(root_d, 0);
2510 assert(ret == 0);
2511 ret = bt_ctf_field_type_integer_set_base(root_d, 10);
2512 assert(ret == 0);
2513 ret = bt_ctf_field_type_integer_set_encoding(root_d, CTF_STRING_NONE);
2514 assert(ret == 0);
2515 ret = bt_ctf_field_type_set_byte_order(root_d, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2516 assert(ret == 0);
2517 ret = bt_ctf_field_type_set_alignment(root_d, 1);
2518 assert(ret == 0);
2519 ret = bt_ctf_field_type_structure_add_field(root, root_d, "d");
2520 assert(ret == 0);
2521
2522 BT_PUT(root_a);
2523 BT_PUT(root_z);
2524 BT_PUT(root_z_b);
2525 BT_PUT(root_z_b_elem);
2526 BT_PUT(root_c);
2527 BT_PUT(root_d);
2528
2529 return root;
2530 }
2531
2532 static
2533 void test_fail_target_is_ancestor_of_source(void)
2534 {
2535 struct bt_ctf_field_type *ep;
2536 struct bt_ctf_event *event;
2537
2538 ep = test_fail_target_is_ancestor_of_source_get_ep();
2539 assert(ep);
2540 event = create_event_with_context_and_payload(NULL, ep);
2541 ok(!event, "Sequence FT with ancestor as its length is invalid");
2542
2543 BT_PUT(ep);
2544 BT_PUT(event);
2545 }
2546
2547 static
2548 struct bt_ctf_field_type *test_fail_target_is_source_get_event_payload(void)
2549 {
2550 /*
2551 Generated by bt-ctfirtg using the following input:
2552
2553 class: struct
2554 fields:
2555 a:
2556 class: int
2557 size: 32
2558 b:
2559 class: array
2560 length: event.fields.b
2561 element-type:
2562 class: string
2563 c:
2564 class: string
2565 d:
2566 class: int
2567 size: 17
2568
2569 */
2570
2571 struct bt_ctf_field_type *root = NULL;
2572 struct bt_ctf_field_type *root_a = NULL;
2573 struct bt_ctf_field_type *root_b = NULL;
2574 struct bt_ctf_field_type *root_b_elem = NULL;
2575 struct bt_ctf_field_type *root_c = NULL;
2576 struct bt_ctf_field_type *root_d = NULL;
2577
2578 int ret;
2579 root = bt_ctf_field_type_structure_create();
2580 assert(root);
2581 ret = bt_ctf_field_type_set_alignment(root, 8);
2582 assert(ret == 0);
2583 root_a = bt_ctf_field_type_integer_create(32);
2584 assert(root_a);
2585 ret = bt_ctf_field_type_integer_set_signed(root_a, 0);
2586 assert(ret == 0);
2587 ret = bt_ctf_field_type_integer_set_base(root_a, 10);
2588 assert(ret == 0);
2589 ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
2590 assert(ret == 0);
2591 ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2592 assert(ret == 0);
2593 ret = bt_ctf_field_type_set_alignment(root_a, 8);
2594 assert(ret == 0);
2595 ret = bt_ctf_field_type_structure_add_field(root, root_a, "a");
2596 assert(ret == 0);
2597 root_b_elem = bt_ctf_field_type_string_create();
2598 assert(root_b_elem);
2599 ret = bt_ctf_field_type_string_set_encoding(root_b_elem, CTF_STRING_UTF8);
2600 assert(ret == 0);
2601 root_b = bt_ctf_field_type_sequence_create(root_b_elem, "event.fields.b");
2602 assert(root_b);
2603 ret = bt_ctf_field_type_structure_add_field(root, root_b, "b");
2604 assert(ret == 0);
2605 root_c = bt_ctf_field_type_string_create();
2606 assert(root_c);
2607 ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
2608 assert(ret == 0);
2609 ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
2610 assert(ret == 0);
2611 root_d = bt_ctf_field_type_integer_create(17);
2612 assert(root_d);
2613 ret = bt_ctf_field_type_integer_set_signed(root_d, 0);
2614 assert(ret == 0);
2615 ret = bt_ctf_field_type_integer_set_base(root_d, 10);
2616 assert(ret == 0);
2617 ret = bt_ctf_field_type_integer_set_encoding(root_d, CTF_STRING_NONE);
2618 assert(ret == 0);
2619 ret = bt_ctf_field_type_set_byte_order(root_d, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2620 assert(ret == 0);
2621 ret = bt_ctf_field_type_set_alignment(root_d, 1);
2622 assert(ret == 0);
2623 ret = bt_ctf_field_type_structure_add_field(root, root_d, "d");
2624 assert(ret == 0);
2625
2626 BT_PUT(root_a);
2627 BT_PUT(root_b);
2628 BT_PUT(root_b_elem);
2629 BT_PUT(root_c);
2630 BT_PUT(root_d);
2631
2632 return root;
2633 }
2634
2635 static
2636 void test_fail_target_is_source(void)
2637 {
2638 struct bt_ctf_field_type *ep;
2639 struct bt_ctf_event *event;
2640
2641 ep = test_fail_target_is_source_get_event_payload();
2642 assert(ep);
2643 event = create_event_with_context_and_payload(NULL, ep);
2644 ok(!event, "Sequence FT with itself as its length is invalid");
2645
2646 BT_PUT(ep);
2647 BT_PUT(event);
2648 }
2649
2650 static
2651 struct bt_ctf_field_type *test_fail_variant_tag_is_not_enum_get_ep(void)
2652 {
2653 /*
2654 Generated by bt-ctfirtg using the following input:
2655
2656 class: struct
2657 fields:
2658 a:
2659 class: int
2660 size: 32
2661 b:
2662 class: variant
2663 tag: a
2664 types:
2665 HELLO:
2666 class: string
2667 c:
2668 class: string
2669 d:
2670 class: int
2671 size: 17
2672
2673 */
2674
2675 struct bt_ctf_field_type *root = NULL;
2676 struct bt_ctf_field_type *root_a = NULL;
2677 struct bt_ctf_field_type *root_b = NULL;
2678 struct bt_ctf_field_type *root_b_HELLO = NULL;
2679 struct bt_ctf_field_type *root_c = NULL;
2680 struct bt_ctf_field_type *root_d = NULL;
2681
2682 int ret;
2683 root = bt_ctf_field_type_structure_create();
2684 assert(root);
2685 ret = bt_ctf_field_type_set_alignment(root, 8);
2686 assert(ret == 0);
2687 root_a = bt_ctf_field_type_integer_create(32);
2688 assert(root_a);
2689 ret = bt_ctf_field_type_integer_set_signed(root_a, 0);
2690 assert(ret == 0);
2691 ret = bt_ctf_field_type_integer_set_base(root_a, 10);
2692 assert(ret == 0);
2693 ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
2694 assert(ret == 0);
2695 ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2696 assert(ret == 0);
2697 ret = bt_ctf_field_type_set_alignment(root_a, 8);
2698 assert(ret == 0);
2699 ret = bt_ctf_field_type_structure_add_field(root, root_a, "a");
2700 assert(ret == 0);
2701 root_b = bt_ctf_field_type_variant_create(NULL, "a");
2702 assert(root_b);
2703 root_b_HELLO = bt_ctf_field_type_string_create();
2704 assert(root_b_HELLO);
2705 ret = bt_ctf_field_type_string_set_encoding(root_b_HELLO, CTF_STRING_UTF8);
2706 assert(ret == 0);
2707 ret = bt_ctf_field_type_variant_add_field(root_b, root_b_HELLO, "HELLO");
2708 assert(ret == 0);
2709 ret = bt_ctf_field_type_structure_add_field(root, root_b, "b");
2710 assert(ret == 0);
2711 root_c = bt_ctf_field_type_string_create();
2712 assert(root_c);
2713 ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
2714 assert(ret == 0);
2715 ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
2716 assert(ret == 0);
2717 root_d = bt_ctf_field_type_integer_create(17);
2718 assert(root_d);
2719 ret = bt_ctf_field_type_integer_set_signed(root_d, 0);
2720 assert(ret == 0);
2721 ret = bt_ctf_field_type_integer_set_base(root_d, 10);
2722 assert(ret == 0);
2723 ret = bt_ctf_field_type_integer_set_encoding(root_d, CTF_STRING_NONE);
2724 assert(ret == 0);
2725 ret = bt_ctf_field_type_set_byte_order(root_d, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2726 assert(ret == 0);
2727 ret = bt_ctf_field_type_set_alignment(root_d, 1);
2728 assert(ret == 0);
2729 ret = bt_ctf_field_type_structure_add_field(root, root_d, "d");
2730 assert(ret == 0);
2731
2732 BT_PUT(root_a);
2733 BT_PUT(root_b);
2734 BT_PUT(root_b_HELLO);
2735 BT_PUT(root_c);
2736 BT_PUT(root_d);
2737
2738 return root;
2739 }
2740
2741 static
2742 void test_fail_variant_tag_is_not_enum(void)
2743 {
2744 struct bt_ctf_field_type *ep;
2745 struct bt_ctf_event *event;
2746
2747 ep = test_fail_variant_tag_is_not_enum_get_ep();
2748 assert(ep);
2749 event = create_event_with_context_and_payload(NULL, ep);
2750 ok(!event, "Variant FT with non-enum FT as its tag FT is invalid");
2751
2752 BT_PUT(ep);
2753 BT_PUT(event);
2754 }
2755
2756 static
2757 struct bt_ctf_field_type *test_fail_variant_tag_mismatch_mappings_get_ep(void)
2758 {
2759 /*
2760 Generated by bt-ctfirtg using the following input:
2761
2762 class: struct
2763 fields:
2764 a:
2765 class: enum
2766 value-type:
2767 class: int
2768 size: 16
2769 members:
2770 - GLASS
2771 - OF
2772 - WATER
2773 b:
2774 class: variant
2775 tag: a
2776 types:
2777 GLASS:
2778 class: string
2779 OF:
2780 class: int
2781 size: 2
2782 c:
2783 class: string
2784
2785 */
2786
2787 struct bt_ctf_field_type *root = NULL;
2788 struct bt_ctf_field_type *root_a = NULL;
2789 struct bt_ctf_field_type *root_a_int = NULL;
2790 struct bt_ctf_field_type *root_b = NULL;
2791 struct bt_ctf_field_type *root_b_GLASS = NULL;
2792 struct bt_ctf_field_type *root_b_OF = NULL;
2793 struct bt_ctf_field_type *root_c = NULL;
2794
2795 int ret;
2796 root = bt_ctf_field_type_structure_create();
2797 assert(root);
2798 ret = bt_ctf_field_type_set_alignment(root, 8);
2799 assert(ret == 0);
2800 root_a_int = bt_ctf_field_type_integer_create(16);
2801 assert(root_a_int);
2802 ret = bt_ctf_field_type_integer_set_signed(root_a_int, 0);
2803 assert(ret == 0);
2804 ret = bt_ctf_field_type_integer_set_base(root_a_int, 10);
2805 assert(ret == 0);
2806 ret = bt_ctf_field_type_integer_set_encoding(root_a_int, CTF_STRING_NONE);
2807 assert(ret == 0);
2808 ret = bt_ctf_field_type_set_byte_order(root_a_int, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2809 assert(ret == 0);
2810 ret = bt_ctf_field_type_set_alignment(root_a_int, 8);
2811 assert(ret == 0);
2812 root_a = bt_ctf_field_type_enumeration_create(root_a_int);
2813 assert(root_a);
2814 ret = bt_ctf_field_type_enumeration_add_mapping(root_a, "GLASS", 0, 0);
2815 assert(ret == 0);
2816 ret = bt_ctf_field_type_enumeration_add_mapping(root_a, "OF", 1, 1);
2817 assert(ret == 0);
2818 ret = bt_ctf_field_type_enumeration_add_mapping(root_a, "WATER", 2, 2);
2819 assert(ret == 0);
2820 ret = bt_ctf_field_type_structure_add_field(root, root_a, "a");
2821 assert(ret == 0);
2822 root_b = bt_ctf_field_type_variant_create(NULL, "a");
2823 assert(root_b);
2824 root_b_GLASS = bt_ctf_field_type_string_create();
2825 assert(root_b_GLASS);
2826 ret = bt_ctf_field_type_string_set_encoding(root_b_GLASS, CTF_STRING_UTF8);
2827 assert(ret == 0);
2828 ret = bt_ctf_field_type_variant_add_field(root_b, root_b_GLASS, "GLASS");
2829 assert(ret == 0);
2830 root_b_OF = bt_ctf_field_type_integer_create(2);
2831 assert(root_b_OF);
2832 ret = bt_ctf_field_type_integer_set_signed(root_b_OF, 0);
2833 assert(ret == 0);
2834 ret = bt_ctf_field_type_integer_set_base(root_b_OF, 10);
2835 assert(ret == 0);
2836 ret = bt_ctf_field_type_integer_set_encoding(root_b_OF, CTF_STRING_NONE);
2837 assert(ret == 0);
2838 ret = bt_ctf_field_type_set_byte_order(root_b_OF, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
2839 assert(ret == 0);
2840 ret = bt_ctf_field_type_set_alignment(root_b_OF, 1);
2841 assert(ret == 0);
2842 ret = bt_ctf_field_type_variant_add_field(root_b, root_b_OF, "OF");
2843 assert(ret == 0);
2844 ret = bt_ctf_field_type_structure_add_field(root, root_b, "b");
2845 assert(ret == 0);
2846 root_c = bt_ctf_field_type_string_create();
2847 assert(root_c);
2848 ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
2849 assert(ret == 0);
2850 ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
2851 assert(ret == 0);
2852
2853 BT_PUT(root_a);
2854 BT_PUT(root_a_int);
2855 BT_PUT(root_b);
2856 BT_PUT(root_b_GLASS);
2857 BT_PUT(root_b_OF);
2858 BT_PUT(root_c);
2859
2860 return root;
2861 }
2862
2863 static
2864 void test_fail_variant_tag_mismatch_mappings(void)
2865 {
2866 struct bt_ctf_field_type *ep;
2867 struct bt_ctf_event *event;
2868
2869 ep = test_fail_variant_tag_mismatch_mappings_get_ep();
2870 assert(ep);
2871 event = create_event_with_context_and_payload(NULL, ep);
2872 ok(!event, "Variant FT with mismatching tag FT is invalid");
2873
2874 BT_PUT(ep);
2875 BT_PUT(event);
2876 }
2877
2878 static
2879 struct bt_ctf_field_type *test_fail_sequence_tag_is_not_int_get_ep(void)
2880 {
2881 /*
2882 Generated by bt-ctfirtg using the following input:
2883
2884 class: struct
2885 fields:
2886 a:
2887 class: string
2888 b:
2889 class: array
2890 length: a
2891 element-type:
2892 class: string
2893 c:
2894 class: string
2895
2896 */
2897
2898 struct bt_ctf_field_type *root = NULL;
2899 struct bt_ctf_field_type *root_a = NULL;
2900 struct bt_ctf_field_type *root_b = NULL;
2901 struct bt_ctf_field_type *root_b_elem = NULL;
2902 struct bt_ctf_field_type *root_c = NULL;
2903
2904 int ret;
2905 root = bt_ctf_field_type_structure_create();
2906 assert(root);
2907 ret = bt_ctf_field_type_set_alignment(root, 8);
2908 assert(ret == 0);
2909 root_a = bt_ctf_field_type_string_create();
2910 assert(root_a);
2911 ret = bt_ctf_field_type_string_set_encoding(root_a, CTF_STRING_UTF8);
2912 assert(ret == 0);
2913 ret = bt_ctf_field_type_structure_add_field(root, root_a, "a");
2914 assert(ret == 0);
2915 root_b_elem = bt_ctf_field_type_string_create();
2916 assert(root_b_elem);
2917 ret = bt_ctf_field_type_string_set_encoding(root_b_elem, CTF_STRING_UTF8);
2918 assert(ret == 0);
2919 root_b = bt_ctf_field_type_sequence_create(root_b_elem, "a");
2920 assert(root_b);
2921 ret = bt_ctf_field_type_structure_add_field(root, root_b, "b");
2922 assert(ret == 0);
2923 root_c = bt_ctf_field_type_string_create();
2924 assert(root_c);
2925 ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
2926 assert(ret == 0);
2927 ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
2928 assert(ret == 0);
2929
2930 BT_PUT(root_a);
2931 BT_PUT(root_b);
2932 BT_PUT(root_b_elem);
2933 BT_PUT(root_c);
2934
2935 return root;
2936 }
2937
2938 static
2939 void test_fail_sequence_tag_is_not_int(void)
2940 {
2941 struct bt_ctf_field_type *ep;
2942 struct bt_ctf_event *event;
2943
2944 ep = test_fail_sequence_tag_is_not_int_get_ep();
2945 assert(ep);
2946 event = create_event_with_context_and_payload(NULL, ep);
2947 ok(!event, "Sequence FT with non-enum length FT is invalid");
2948
2949 BT_PUT(ep);
2950 BT_PUT(event);
2951 }
2952
2953 static
2954 void test_fail(void)
2955 {
2956 test_fail_unavailable_root();
2957 test_fail_target_is_root();
2958 test_fail_target_is_after_source();
2959 test_fail_target_is_ancestor_of_source();
2960 test_fail_target_is_source();
2961 test_fail_variant_tag_is_not_enum();
2962 test_fail_variant_tag_mismatch_mappings();
2963 test_fail_sequence_tag_is_not_int();
2964 }
2965
2966 int main(void)
2967 {
2968 plan_no_plan();
2969
2970 test_pass();
2971 test_fail();
2972
2973 return 0;
2974 }
BabelTrace - Trace Format Babel Tower
This page took 0.157246 seconds and 5 git commands to generate.