#include <babeltrace/graph/component-class.h>
#include <babeltrace/values.h>
#include <babeltrace/ref.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
+#include <babeltrace/assert-internal.h>
static enum bt_component_status sink_consume(
struct bt_private_component *private_component)
};
int iret;
- assert(ret.result);
+ BT_ASSERT(ret.result);
iret = bt_value_array_append_string(ret.result, object);
- assert(iret == 0);
+ BT_ASSERT(iret == 0);
iret = bt_value_array_append(ret.result, params);
- assert(iret == 0);
+ BT_ASSERT(iret == 0);
return ret;
}
#include <babeltrace/ctf-ir/event-class.h>
#include <babeltrace/ctf-ir/stream-class.h>
#include <babeltrace/ctf-ir/trace.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include <stdbool.h>
#include <string.h>
#include <stdarg.h>
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_magic = bt_field_type_integer_create(32);
- assert(root_magic);
+ BT_ASSERT(root_magic);
ret = bt_field_type_integer_set_is_signed(root_magic, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_magic, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_magic, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_magic, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_magic, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_magic, "magic");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_uuid_elem = bt_field_type_integer_create(8);
- assert(root_uuid_elem);
+ BT_ASSERT(root_uuid_elem);
ret = bt_field_type_integer_set_is_signed(root_uuid_elem, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_uuid_elem, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_uuid_elem, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_uuid_elem, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_uuid_elem, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_uuid = bt_field_type_array_create(root_uuid_elem, 16);
- assert(root_uuid);
+ BT_ASSERT(root_uuid);
ret = bt_field_type_structure_add_field(root, root_uuid, "uuid");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_stream_id = bt_field_type_integer_create(32);
- assert(root_stream_id);
+ BT_ASSERT(root_stream_id);
ret = bt_field_type_integer_set_is_signed(root_stream_id, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_stream_id, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_stream_id, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_stream_id, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_stream_id, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_stream_id, "stream_id");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron = bt_field_type_structure_create();
- assert(root_iron);
+ BT_ASSERT(root_iron);
ret = bt_field_type_set_alignment(root_iron, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_listen = bt_field_type_string_create();
- assert(root_iron_listen);
+ BT_ASSERT(root_iron_listen);
ret = bt_field_type_string_set_encoding(root_iron_listen, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_iron, root_iron_listen, "listen");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_dust = bt_field_type_integer_create(23);
- assert(root_iron_dust);
+ BT_ASSERT(root_iron_dust);
ret = bt_field_type_integer_set_is_signed(root_iron_dust, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_iron_dust, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_iron_dust, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_iron_dust, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_iron_dust, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_iron, root_iron_dust, "dust");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_parallel_int = bt_field_type_integer_create(10);
- assert(root_iron_parallel_int);
+ BT_ASSERT(root_iron_parallel_int);
ret = bt_field_type_integer_set_is_signed(root_iron_parallel_int, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_iron_parallel_int, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_iron_parallel_int, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_iron_parallel_int, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_iron_parallel_int, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_parallel = bt_field_type_enumeration_create(root_iron_parallel_int);
- assert(root_iron_parallel);
+ BT_ASSERT(root_iron_parallel);
ret = bt_field_type_enumeration_unsigned_add_mapping(root_iron_parallel, "RED", 0, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_enumeration_unsigned_add_mapping(root_iron_parallel, "BLUE", 1, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_enumeration_unsigned_add_mapping(root_iron_parallel, "YELLOW", 2, 2);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_iron, root_iron_parallel, "parallel");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_fire = bt_field_type_structure_create();
- assert(root_iron_fire);
+ BT_ASSERT(root_iron_fire);
ret = bt_field_type_set_alignment(root_iron_fire, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_fire_word = bt_field_type_integer_create(17);
- assert(root_iron_fire_word);
+ BT_ASSERT(root_iron_fire_word);
ret = bt_field_type_integer_set_is_signed(root_iron_fire_word, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_iron_fire_word, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_iron_fire_word, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_iron_fire_word, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_iron_fire_word, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_iron_fire, root_iron_fire_word, "word");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_fire_rabbit = bt_field_type_string_create();
- assert(root_iron_fire_rabbit);
+ BT_ASSERT(root_iron_fire_rabbit);
ret = bt_field_type_string_set_encoding(root_iron_fire_rabbit, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_iron_fire, root_iron_fire_rabbit, "rabbit");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_fire_keen_elem = bt_field_type_variant_create(NULL, "iron.parallel");
- assert(root_iron_fire_keen_elem);
+ BT_ASSERT(root_iron_fire_keen_elem);
root_iron_fire_keen_elem_RED = bt_field_type_string_create();
- assert(root_iron_fire_keen_elem_RED);
+ BT_ASSERT(root_iron_fire_keen_elem_RED);
ret = bt_field_type_string_set_encoding(root_iron_fire_keen_elem_RED, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_variant_add_field(root_iron_fire_keen_elem, root_iron_fire_keen_elem_RED, "RED");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_fire_keen_elem_BLUE_elem = bt_field_type_integer_create(5);
- assert(root_iron_fire_keen_elem_BLUE_elem);
+ BT_ASSERT(root_iron_fire_keen_elem_BLUE_elem);
ret = bt_field_type_integer_set_is_signed(root_iron_fire_keen_elem_BLUE_elem, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_iron_fire_keen_elem_BLUE_elem, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_iron_fire_keen_elem_BLUE_elem, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_iron_fire_keen_elem_BLUE_elem, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_iron_fire_keen_elem_BLUE_elem, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_fire_keen_elem_BLUE = bt_field_type_sequence_create(root_iron_fire_keen_elem_BLUE_elem, "magic");
- assert(root_iron_fire_keen_elem_BLUE);
+ BT_ASSERT(root_iron_fire_keen_elem_BLUE);
ret = bt_field_type_variant_add_field(root_iron_fire_keen_elem, root_iron_fire_keen_elem_BLUE, "BLUE");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_fire_keen_elem_YELLOW = bt_field_type_structure_create();
- assert(root_iron_fire_keen_elem_YELLOW);
+ BT_ASSERT(root_iron_fire_keen_elem_YELLOW);
ret = bt_field_type_set_alignment(root_iron_fire_keen_elem_YELLOW, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_variant_add_field(root_iron_fire_keen_elem, root_iron_fire_keen_elem_YELLOW, "YELLOW");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_fire_keen = bt_field_type_sequence_create(root_iron_fire_keen_elem, "word");
- assert(root_iron_fire_keen);
+ BT_ASSERT(root_iron_fire_keen);
ret = bt_field_type_structure_add_field(root_iron_fire, root_iron_fire_keen, "keen");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_iron, root_iron_fire, "fire");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_report_elem = bt_field_type_string_create();
- assert(root_iron_report_elem);
+ BT_ASSERT(root_iron_report_elem);
ret = bt_field_type_string_set_encoding(root_iron_report_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_report = bt_field_type_sequence_create(root_iron_report_elem, "trace.packet.header.iron.dust");
- assert(root_iron_report);
+ BT_ASSERT(root_iron_report);
ret = bt_field_type_structure_add_field(root_iron, root_iron_report, "report");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_group_elem = bt_field_type_string_create();
- assert(root_iron_group_elem);
+ BT_ASSERT(root_iron_group_elem);
ret = bt_field_type_string_set_encoding(root_iron_group_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_iron_group = bt_field_type_sequence_create(root_iron_group_elem, "trace.packet.header.stream_id");
- assert(root_iron_group);
+ BT_ASSERT(root_iron_group);
ret = bt_field_type_structure_add_field(root_iron, root_iron_group, "group");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_iron, "iron");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_serious = bt_field_type_integer_create(1);
- assert(root_serious);
+ BT_ASSERT(root_serious);
ret = bt_field_type_integer_set_is_signed(root_serious, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_serious, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_serious, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_serious, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_serious, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_serious, "serious");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_magic);
BT_PUT(root_uuid);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_placid = bt_field_type_integer_create(32);
- assert(root_placid);
+ BT_ASSERT(root_placid);
ret = bt_field_type_integer_set_is_signed(root_placid, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_placid, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_placid, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_placid, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_placid, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_placid, "placid");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_meow = bt_field_type_string_create();
- assert(root_meow);
+ BT_ASSERT(root_meow);
ret = bt_field_type_string_set_encoding(root_meow, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_meow, "meow");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_serious = bt_field_type_integer_create(11);
- assert(root_serious);
+ BT_ASSERT(root_serious);
ret = bt_field_type_integer_set_is_signed(root_serious, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_serious, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_serious, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_serious, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_serious, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_serious, "serious");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_naive_elem_elem = bt_field_type_string_create();
- assert(root_naive_elem_elem);
+ BT_ASSERT(root_naive_elem_elem);
ret = bt_field_type_string_set_encoding(root_naive_elem_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_naive_elem = bt_field_type_sequence_create(root_naive_elem_elem, "placid");
- assert(root_naive_elem);
+ BT_ASSERT(root_naive_elem);
root_naive = bt_field_type_array_create(root_naive_elem, 17);
- assert(root_naive);
+ BT_ASSERT(root_naive);
ret = bt_field_type_structure_add_field(root, root_naive, "naive");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover = bt_field_type_structure_create();
- assert(root_clover);
+ BT_ASSERT(root_clover);
ret = bt_field_type_set_alignment(root_clover, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover_oval = bt_field_type_integer_create(17);
- assert(root_clover_oval);
+ BT_ASSERT(root_clover_oval);
ret = bt_field_type_integer_set_is_signed(root_clover_oval, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_clover_oval, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_clover_oval, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_clover_oval, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_clover_oval, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_clover, root_clover_oval, "oval");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover_whole = bt_field_type_variant_create(NULL, "iron.parallel");
- assert(root_clover_whole);
+ BT_ASSERT(root_clover_whole);
root_clover_whole_BLUE_elem = bt_field_type_string_create();
- assert(root_clover_whole_BLUE_elem);
+ BT_ASSERT(root_clover_whole_BLUE_elem);
ret = bt_field_type_string_set_encoding(root_clover_whole_BLUE_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover_whole_BLUE = bt_field_type_sequence_create(root_clover_whole_BLUE_elem, "trace.packet.header.iron.fire.word");
- assert(root_clover_whole_BLUE);
+ BT_ASSERT(root_clover_whole_BLUE);
ret = bt_field_type_variant_add_field(root_clover_whole, root_clover_whole_BLUE, "BLUE");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover_whole_RED = bt_field_type_integer_create(44);
- assert(root_clover_whole_RED);
+ BT_ASSERT(root_clover_whole_RED);
ret = bt_field_type_integer_set_is_signed(root_clover_whole_RED, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_clover_whole_RED, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_clover_whole_RED, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_clover_whole_RED, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_clover_whole_RED, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_variant_add_field(root_clover_whole, root_clover_whole_RED, "RED");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover_whole_YELLOW = bt_field_type_string_create();
- assert(root_clover_whole_YELLOW);
+ BT_ASSERT(root_clover_whole_YELLOW);
ret = bt_field_type_string_set_encoding(root_clover_whole_YELLOW, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_variant_add_field(root_clover_whole, root_clover_whole_YELLOW, "YELLOW");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_clover, root_clover_whole, "whole");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover_egg_elem = bt_field_type_integer_create(55);
- assert(root_clover_egg_elem);
+ BT_ASSERT(root_clover_egg_elem);
ret = bt_field_type_integer_set_is_signed(root_clover_egg_elem, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_clover_egg_elem, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_clover_egg_elem, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_clover_egg_elem, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_clover_egg_elem, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover_egg = bt_field_type_sequence_create(root_clover_egg_elem, "stream.packet.context.clover.oval");
- assert(root_clover_egg);
+ BT_ASSERT(root_clover_egg);
ret = bt_field_type_structure_add_field(root_clover, root_clover_egg, "egg");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover_square_int = bt_field_type_integer_create(12);
- assert(root_clover_square_int);
+ BT_ASSERT(root_clover_square_int);
ret = bt_field_type_integer_set_is_signed(root_clover_square_int, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_clover_square_int, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_clover_square_int, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_clover_square_int, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_clover_square_int, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover_square = bt_field_type_enumeration_create(root_clover_square_int);
- assert(root_clover_square);
+ BT_ASSERT(root_clover_square);
ret = bt_field_type_enumeration_unsigned_add_mapping(root_clover_square, "YOUNG", 0, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_enumeration_unsigned_add_mapping(root_clover_square, "OLD", 1, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_clover, root_clover_square, "square");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover_useful_elem = bt_field_type_integer_create(2);
- assert(root_clover_useful_elem);
+ BT_ASSERT(root_clover_useful_elem);
ret = bt_field_type_integer_set_is_signed(root_clover_useful_elem, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_clover_useful_elem, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_clover_useful_elem, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_clover_useful_elem, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_clover_useful_elem, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_clover_useful = bt_field_type_sequence_create(root_clover_useful_elem, "serious");
- assert(root_clover_useful);
+ BT_ASSERT(root_clover_useful);
ret = bt_field_type_structure_add_field(root_clover, root_clover_useful, "useful");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_clover, "clover");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_tart = bt_field_type_string_create();
- assert(root_tart);
+ BT_ASSERT(root_tart);
ret = bt_field_type_string_set_encoding(root_tart, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_tart, "tart");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_placid);
BT_PUT(root_meow);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_id = bt_field_type_integer_create(17);
- assert(root_id);
+ BT_ASSERT(root_id);
ret = bt_field_type_integer_set_is_signed(root_id, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_id, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_id, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_id, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_id, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_id, "id");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_timestamp = bt_field_type_integer_create(64);
- assert(root_timestamp);
+ BT_ASSERT(root_timestamp);
ret = bt_field_type_integer_set_is_signed(root_timestamp, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_timestamp, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_timestamp, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_timestamp, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_timestamp, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_timestamp, "timestamp");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_action = bt_field_type_structure_create();
- assert(root_action);
+ BT_ASSERT(root_action);
ret = bt_field_type_set_alignment(root_action, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_action_special = bt_field_type_integer_create(17);
- assert(root_action_special);
+ BT_ASSERT(root_action_special);
ret = bt_field_type_integer_set_is_signed(root_action_special, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_action_special, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_action_special, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_action_special, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_action_special, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_action, root_action_special, "special");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_action_lucky_elem = bt_field_type_string_create();
- assert(root_action_lucky_elem);
+ BT_ASSERT(root_action_lucky_elem);
ret = bt_field_type_string_set_encoding(root_action_lucky_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_action_lucky = bt_field_type_sequence_create(root_action_lucky_elem, "stream.packet.context.placid");
- assert(root_action_lucky);
+ BT_ASSERT(root_action_lucky);
ret = bt_field_type_structure_add_field(root_action, root_action_lucky, "lucky");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_action_dream = bt_field_type_string_create();
- assert(root_action_dream);
+ BT_ASSERT(root_action_dream);
ret = bt_field_type_string_set_encoding(root_action_dream, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_action, root_action_dream, "dream");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_action_grandiose_elem = bt_field_type_integer_create(3);
- assert(root_action_grandiose_elem);
+ BT_ASSERT(root_action_grandiose_elem);
ret = bt_field_type_integer_set_is_signed(root_action_grandiose_elem, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_action_grandiose_elem, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_action_grandiose_elem, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_action_grandiose_elem, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_action_grandiose_elem, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_action_grandiose = bt_field_type_sequence_create(root_action_grandiose_elem, "trace.packet.header.serious");
- assert(root_action_grandiose);
+ BT_ASSERT(root_action_grandiose);
ret = bt_field_type_structure_add_field(root_action, root_action_grandiose, "grandiose");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_action, "action");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_stiff_elem = bt_field_type_string_create();
- assert(root_stiff_elem);
+ BT_ASSERT(root_stiff_elem);
ret = bt_field_type_string_set_encoding(root_stiff_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_stiff = bt_field_type_sequence_create(root_stiff_elem, "clover.whole.RED");
- assert(root_stiff);
+ BT_ASSERT(root_stiff);
ret = bt_field_type_structure_add_field(root, root_stiff, "stiff");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_fruit = bt_field_type_structure_create();
- assert(root_fruit);
+ BT_ASSERT(root_fruit);
ret = bt_field_type_set_alignment(root_fruit, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_fruit_apple_elem = bt_field_type_integer_create(5);
- assert(root_fruit_apple_elem);
+ BT_ASSERT(root_fruit_apple_elem);
ret = bt_field_type_integer_set_is_signed(root_fruit_apple_elem, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_fruit_apple_elem, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_fruit_apple_elem, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_fruit_apple_elem, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_fruit_apple_elem, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_fruit_apple = bt_field_type_sequence_create(root_fruit_apple_elem, "action.special");
- assert(root_fruit_apple);
+ BT_ASSERT(root_fruit_apple);
ret = bt_field_type_structure_add_field(root_fruit, root_fruit_apple, "apple");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_fruit, "fruit");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_id);
BT_PUT(root_timestamp);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_face = bt_field_type_structure_create();
- assert(root_face);
+ BT_ASSERT(root_face);
ret = bt_field_type_set_alignment(root_face, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_face_branch_elem = bt_field_type_string_create();
- assert(root_face_branch_elem);
+ BT_ASSERT(root_face_branch_elem);
ret = bt_field_type_string_set_encoding(root_face_branch_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_face_branch = bt_field_type_sequence_create(root_face_branch_elem, "serious");
- assert(root_face_branch);
+ BT_ASSERT(root_face_branch);
ret = bt_field_type_structure_add_field(root_face, root_face_branch, "branch");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_face_income_elem = bt_field_type_string_create();
- assert(root_face_income_elem);
+ BT_ASSERT(root_face_income_elem);
ret = bt_field_type_string_set_encoding(root_face_income_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_face_income = bt_field_type_sequence_create(root_face_income_elem, "magic");
- assert(root_face_income);
+ BT_ASSERT(root_face_income);
ret = bt_field_type_structure_add_field(root_face, root_face_income, "income");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_face_magic = bt_field_type_integer_create(23);
- assert(root_face_magic);
+ BT_ASSERT(root_face_magic);
ret = bt_field_type_integer_set_is_signed(root_face_magic, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_face_magic, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_face_magic, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_face_magic, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_face_magic, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_face, root_face_magic, "magic");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_face_lucky_elem = bt_field_type_string_create();
- assert(root_face_lucky_elem);
+ BT_ASSERT(root_face_lucky_elem);
ret = bt_field_type_string_set_encoding(root_face_lucky_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_face_lucky = bt_field_type_sequence_create(root_face_lucky_elem, "magic");
- assert(root_face_lucky);
+ BT_ASSERT(root_face_lucky);
ret = bt_field_type_structure_add_field(root_face, root_face_lucky, "lucky");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_face, "face");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_cats = bt_field_type_integer_create(5);
- assert(root_cats);
+ BT_ASSERT(root_cats);
ret = bt_field_type_integer_set_is_signed(root_cats, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_cats, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_cats, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_cats, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_cats, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_cats, "cats");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_dream_elem_elem_elem = bt_field_type_string_create();
- assert(root_dream_elem_elem_elem);
+ BT_ASSERT(root_dream_elem_elem_elem);
ret = bt_field_type_string_set_encoding(root_dream_elem_elem_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_dream_elem_elem = bt_field_type_sequence_create(root_dream_elem_elem_elem, "stream.event.context.face.magic");
- assert(root_dream_elem_elem);
+ BT_ASSERT(root_dream_elem_elem);
root_dream_elem = bt_field_type_sequence_create(root_dream_elem_elem, "trace.packet.header.iron.dust");
- assert(root_dream_elem);
+ BT_ASSERT(root_dream_elem);
root_dream = bt_field_type_sequence_create(root_dream_elem, "stream.packet.context.placid");
- assert(root_dream);
+ BT_ASSERT(root_dream);
ret = bt_field_type_structure_add_field(root, root_dream, "dream");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_stream_id = bt_field_type_integer_create(9);
- assert(root_stream_id);
+ BT_ASSERT(root_stream_id);
ret = bt_field_type_integer_set_is_signed(root_stream_id, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_stream_id, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_stream_id, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_stream_id, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_stream_id, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_stream_id, "stream_id");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_face);
BT_PUT(root_face_branch);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_film = bt_field_type_integer_create(19);
- assert(root_film);
+ BT_ASSERT(root_film);
ret = bt_field_type_integer_set_is_signed(root_film, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_film, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_film, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_film, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_film, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_film, "film");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry = bt_field_type_structure_create();
- assert(root_berry);
+ BT_ASSERT(root_berry);
ret = bt_field_type_set_alignment(root_berry, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry_pine_elem = bt_field_type_string_create();
- assert(root_berry_pine_elem);
+ BT_ASSERT(root_berry_pine_elem);
ret = bt_field_type_string_set_encoding(root_berry_pine_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry_pine = bt_field_type_sequence_create(root_berry_pine_elem, "stream_id");
- assert(root_berry_pine);
+ BT_ASSERT(root_berry_pine);
ret = bt_field_type_structure_add_field(root_berry, root_berry_pine, "pine");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry_porter_elem = bt_field_type_string_create();
- assert(root_berry_porter_elem);
+ BT_ASSERT(root_berry_porter_elem);
ret = bt_field_type_string_set_encoding(root_berry_porter_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry_porter = bt_field_type_sequence_create(root_berry_porter_elem, "face.magic");
- assert(root_berry_porter);
+ BT_ASSERT(root_berry_porter);
ret = bt_field_type_structure_add_field(root_berry, root_berry_porter, "porter");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry_mice_elem = bt_field_type_string_create();
- assert(root_berry_mice_elem);
+ BT_ASSERT(root_berry_mice_elem);
ret = bt_field_type_string_set_encoding(root_berry_mice_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry_mice = bt_field_type_sequence_create(root_berry_mice_elem, "action.special");
- assert(root_berry_mice);
+ BT_ASSERT(root_berry_mice);
ret = bt_field_type_structure_add_field(root_berry, root_berry_mice, "mice");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry_third = bt_field_type_integer_create(18);
- assert(root_berry_third);
+ BT_ASSERT(root_berry_third);
ret = bt_field_type_integer_set_is_signed(root_berry_third, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_berry_third, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_berry_third, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_berry_third, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_berry_third, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root_berry, root_berry_third, "third");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry_guard_elem = bt_field_type_string_create();
- assert(root_berry_guard_elem);
+ BT_ASSERT(root_berry_guard_elem);
ret = bt_field_type_string_set_encoding(root_berry_guard_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry_guard = bt_field_type_sequence_create(root_berry_guard_elem, "clover.oval");
- assert(root_berry_guard);
+ BT_ASSERT(root_berry_guard);
ret = bt_field_type_structure_add_field(root_berry, root_berry_guard, "guard");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry_one_elem = bt_field_type_string_create();
- assert(root_berry_one_elem);
+ BT_ASSERT(root_berry_one_elem);
ret = bt_field_type_string_set_encoding(root_berry_one_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_berry_one = bt_field_type_sequence_create(root_berry_one_elem, "iron.fire.word");
- assert(root_berry_one);
+ BT_ASSERT(root_berry_one);
ret = bt_field_type_structure_add_field(root_berry, root_berry_one, "one");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_berry, "berry");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_cats = bt_field_type_integer_create(55);
- assert(root_cats);
+ BT_ASSERT(root_cats);
ret = bt_field_type_integer_set_is_signed(root_cats, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_cats, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_cats, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_cats, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_cats, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_cats, "cats");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud = bt_field_type_structure_create();
- assert(root_loud);
+ BT_ASSERT(root_loud);
ret = bt_field_type_set_alignment(root_loud, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_toys_elem = bt_field_type_string_create();
- assert(root_loud_toys_elem);
+ BT_ASSERT(root_loud_toys_elem);
ret = bt_field_type_string_set_encoding(root_loud_toys_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_toys = bt_field_type_sequence_create(root_loud_toys_elem, "trace.packet.header.iron.fire.word");
- assert(root_loud_toys);
+ BT_ASSERT(root_loud_toys);
ret = bt_field_type_structure_add_field(root_loud, root_loud_toys, "toys");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_spoon_elem = bt_field_type_string_create();
- assert(root_loud_spoon_elem);
+ BT_ASSERT(root_loud_spoon_elem);
ret = bt_field_type_string_set_encoding(root_loud_spoon_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_spoon = bt_field_type_sequence_create(root_loud_spoon_elem, "stream.packet.context.clover.oval");
- assert(root_loud_spoon);
+ BT_ASSERT(root_loud_spoon);
ret = bt_field_type_structure_add_field(root_loud, root_loud_spoon, "spoon");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_turkey_elem = bt_field_type_string_create();
- assert(root_loud_turkey_elem);
+ BT_ASSERT(root_loud_turkey_elem);
ret = bt_field_type_string_set_encoding(root_loud_turkey_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_turkey = bt_field_type_sequence_create(root_loud_turkey_elem, "stream.event.header.action.special");
- assert(root_loud_turkey);
+ BT_ASSERT(root_loud_turkey);
ret = bt_field_type_structure_add_field(root_loud, root_loud_turkey, "turkey");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_inform_elem = bt_field_type_string_create();
- assert(root_loud_inform_elem);
+ BT_ASSERT(root_loud_inform_elem);
ret = bt_field_type_string_set_encoding(root_loud_inform_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_inform = bt_field_type_sequence_create(root_loud_inform_elem, "stream.event.context.face.magic");
- assert(root_loud_inform);
+ BT_ASSERT(root_loud_inform);
ret = bt_field_type_structure_add_field(root_loud, root_loud_inform, "inform");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_odd_elem = bt_field_type_string_create();
- assert(root_loud_odd_elem);
+ BT_ASSERT(root_loud_odd_elem);
ret = bt_field_type_string_set_encoding(root_loud_odd_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_odd = bt_field_type_sequence_create(root_loud_odd_elem, "berry.third");
- assert(root_loud_odd);
+ BT_ASSERT(root_loud_odd);
ret = bt_field_type_structure_add_field(root_loud, root_loud_odd, "odd");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_amuck_elem = bt_field_type_string_create();
- assert(root_loud_amuck_elem);
+ BT_ASSERT(root_loud_amuck_elem);
ret = bt_field_type_string_set_encoding(root_loud_amuck_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_loud_amuck = bt_field_type_sequence_create(root_loud_amuck_elem, "event.context.film");
- assert(root_loud_amuck);
+ BT_ASSERT(root_loud_amuck);
ret = bt_field_type_structure_add_field(root_loud, root_loud_amuck, "amuck");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_loud, "loud");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_film);
BT_PUT(root_berry);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_splendid = bt_field_type_integer_create(12);
- assert(root_splendid);
+ BT_ASSERT(root_splendid);
ret = bt_field_type_integer_set_is_signed(root_splendid, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_splendid, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_splendid, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_splendid, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_splendid, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_splendid, "splendid");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative = bt_field_type_structure_create();
- assert(root_relative);
+ BT_ASSERT(root_relative);
ret = bt_field_type_set_alignment(root_relative, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_equal_elem = bt_field_type_string_create();
- assert(root_relative_equal_elem);
+ BT_ASSERT(root_relative_equal_elem);
ret = bt_field_type_string_set_encoding(root_relative_equal_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_equal = bt_field_type_sequence_create(root_relative_equal_elem, "splendid");
- assert(root_relative_equal);
+ BT_ASSERT(root_relative_equal);
ret = bt_field_type_structure_add_field(root_relative, root_relative_equal, "equal");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_amuck_elem = bt_field_type_string_create();
- assert(root_relative_amuck_elem);
+ BT_ASSERT(root_relative_amuck_elem);
ret = bt_field_type_string_set_encoding(root_relative_amuck_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_amuck = bt_field_type_sequence_create(root_relative_amuck_elem, "id");
- assert(root_relative_amuck);
+ BT_ASSERT(root_relative_amuck);
ret = bt_field_type_structure_add_field(root_relative, root_relative_amuck, "amuck");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_push_elem = bt_field_type_string_create();
- assert(root_relative_push_elem);
+ BT_ASSERT(root_relative_push_elem);
ret = bt_field_type_string_set_encoding(root_relative_push_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_push = bt_field_type_sequence_create(root_relative_push_elem, "berry.third");
- assert(root_relative_push);
+ BT_ASSERT(root_relative_push);
ret = bt_field_type_structure_add_field(root_relative, root_relative_push, "push");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_brick_elem = bt_field_type_string_create();
- assert(root_relative_brick_elem);
+ BT_ASSERT(root_relative_brick_elem);
ret = bt_field_type_string_set_encoding(root_relative_brick_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_brick = bt_field_type_sequence_create(root_relative_brick_elem, "face.magic");
- assert(root_relative_brick);
+ BT_ASSERT(root_relative_brick);
ret = bt_field_type_structure_add_field(root_relative, root_relative_brick, "brick");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_crush_elem = bt_field_type_string_create();
- assert(root_relative_crush_elem);
+ BT_ASSERT(root_relative_crush_elem);
ret = bt_field_type_string_set_encoding(root_relative_crush_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_crush = bt_field_type_sequence_create(root_relative_crush_elem, "serious");
- assert(root_relative_crush);
+ BT_ASSERT(root_relative_crush);
ret = bt_field_type_structure_add_field(root_relative, root_relative_crush, "crush");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_canvas_elem = bt_field_type_string_create();
- assert(root_relative_canvas_elem);
+ BT_ASSERT(root_relative_canvas_elem);
ret = bt_field_type_string_set_encoding(root_relative_canvas_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_relative_canvas = bt_field_type_sequence_create(root_relative_canvas_elem, "iron.dust");
- assert(root_relative_canvas);
+ BT_ASSERT(root_relative_canvas);
ret = bt_field_type_structure_add_field(root_relative, root_relative_canvas, "canvas");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_relative, "relative");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute = bt_field_type_structure_create();
- assert(root_absolute);
+ BT_ASSERT(root_absolute);
ret = bt_field_type_set_alignment(root_absolute, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_equal_elem = bt_field_type_string_create();
- assert(root_absolute_equal_elem);
+ BT_ASSERT(root_absolute_equal_elem);
ret = bt_field_type_string_set_encoding(root_absolute_equal_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_equal = bt_field_type_sequence_create(root_absolute_equal_elem, "event.fields.splendid");
- assert(root_absolute_equal);
+ BT_ASSERT(root_absolute_equal);
ret = bt_field_type_structure_add_field(root_absolute, root_absolute_equal, "equal");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_amuck_elem = bt_field_type_string_create();
- assert(root_absolute_amuck_elem);
+ BT_ASSERT(root_absolute_amuck_elem);
ret = bt_field_type_string_set_encoding(root_absolute_amuck_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_amuck = bt_field_type_sequence_create(root_absolute_amuck_elem, "stream.event.header.id");
- assert(root_absolute_amuck);
+ BT_ASSERT(root_absolute_amuck);
ret = bt_field_type_structure_add_field(root_absolute, root_absolute_amuck, "amuck");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_push_elem = bt_field_type_string_create();
- assert(root_absolute_push_elem);
+ BT_ASSERT(root_absolute_push_elem);
ret = bt_field_type_string_set_encoding(root_absolute_push_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_push = bt_field_type_sequence_create(root_absolute_push_elem, "event.context.berry.third");
- assert(root_absolute_push);
+ BT_ASSERT(root_absolute_push);
ret = bt_field_type_structure_add_field(root_absolute, root_absolute_push, "push");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_brick_elem = bt_field_type_string_create();
- assert(root_absolute_brick_elem);
+ BT_ASSERT(root_absolute_brick_elem);
ret = bt_field_type_string_set_encoding(root_absolute_brick_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_brick = bt_field_type_sequence_create(root_absolute_brick_elem, "stream.event.context.face.magic");
- assert(root_absolute_brick);
+ BT_ASSERT(root_absolute_brick);
ret = bt_field_type_structure_add_field(root_absolute, root_absolute_brick, "brick");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_crush_elem = bt_field_type_string_create();
- assert(root_absolute_crush_elem);
+ BT_ASSERT(root_absolute_crush_elem);
ret = bt_field_type_string_set_encoding(root_absolute_crush_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_crush = bt_field_type_sequence_create(root_absolute_crush_elem, "stream.packet.context.serious");
- assert(root_absolute_crush);
+ BT_ASSERT(root_absolute_crush);
ret = bt_field_type_structure_add_field(root_absolute, root_absolute_crush, "crush");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_canvas_elem = bt_field_type_string_create();
- assert(root_absolute_canvas_elem);
+ BT_ASSERT(root_absolute_canvas_elem);
ret = bt_field_type_string_set_encoding(root_absolute_canvas_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_absolute_canvas = bt_field_type_sequence_create(root_absolute_canvas_elem, "trace.packet.header.iron.dust");
- assert(root_absolute_canvas);
+ BT_ASSERT(root_absolute_canvas);
ret = bt_field_type_structure_add_field(root_absolute, root_absolute_canvas, "canvas");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_absolute, "absolute");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_splendid);
BT_PUT(root_relative);
break;
}
- assert(ft);
+ BT_ASSERT(ft);
return ft;
}
struct bt_field_type *ft_tag = NULL;
sc = bt_trace_get_stream_class_by_index(trace, 0);
- assert(sc);
+ BT_ASSERT(sc);
ec = bt_stream_class_get_event_class_by_index(sc, 0);
- assert(ec);
+ BT_ASSERT(ec);
ph = bt_trace_get_packet_header_field_type(trace);
ok(ph, "Trace packet header still exists after successful validation");
struct bt_field_type *ep;
trace = bt_trace_create();
- assert(trace);
+ BT_ASSERT(trace);
sc = bt_stream_class_create("nice_piece_of_stream_class");
- assert(sc);
+ BT_ASSERT(sc);
ec = bt_event_class_create("oh_what_an_event_class");
- assert(ec);
+ BT_ASSERT(ec);
ph = get_good_packet_header_field_type();
- assert(ph);
+ BT_ASSERT(ph);
pc = get_good_packet_context_field_type();
- assert(pc);
+ BT_ASSERT(pc);
eh = get_good_event_header_field_type();
- assert(eh);
+ BT_ASSERT(eh);
sec = get_good_stream_event_context_field_type();
- assert(sec);
+ BT_ASSERT(sec);
ectx = get_good_event_context_field_type();
- assert(ec);
+ BT_ASSERT(ec);
ep = get_good_event_payload_field_type();
- assert(ep);
+ BT_ASSERT(ep);
ret = bt_trace_set_packet_header_field_type(trace, ph);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_set_packet_context_field_type(sc, pc);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_set_event_header_field_type(sc, eh);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_set_event_context_field_type(sc, sec);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_event_class_set_context_field_type(ec, ectx);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_event_class_set_payload_field_type(ec, ep);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_add_event_class(sc, ec);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
/* Validation happens here */
ret = bt_trace_add_stream_class(trace, sc);
struct bt_event_class *ec;
trace = bt_trace_create();
- assert(trace);
+ BT_ASSERT(trace);
sc = bt_stream_class_create("sc");
- assert(sc);
+ BT_ASSERT(sc);
ec = bt_event_class_create("ec");
- assert(ec);
+ BT_ASSERT(ec);
if (ectx) {
ret = bt_event_class_set_context_field_type(ec, ectx);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
}
if (ep) {
ret = bt_event_class_set_payload_field_type(ec, ep);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
}
ret = bt_stream_class_add_event_class(sc, ec);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_trace_add_stream_class(trace, sc);
BT_PUT(ec);
BT_PUT(sc);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_a = bt_field_type_integer_create(32);
- assert(root_a);
+ BT_ASSERT(root_a);
ret = bt_field_type_integer_set_is_signed(root_a, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_a, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_a, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_a, "a");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b_elem = bt_field_type_string_create();
- assert(root_b_elem);
+ BT_ASSERT(root_b_elem);
ret = bt_field_type_string_set_encoding(root_b_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b = bt_field_type_sequence_create(root_b_elem, "stream.event.context.lol");
- assert(root_b);
+ BT_ASSERT(root_b);
ret = bt_field_type_structure_add_field(root, root_b, "b");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_c = bt_field_type_string_create();
- assert(root_c);
+ BT_ASSERT(root_c);
ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_c, "c");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_a);
BT_PUT(root_b);
struct bt_field_type *ep;
ep = test_fail_unavailable_root_get_event_payload();
- assert(ep);
+ BT_ASSERT(ep);
ok(try_add_event_class_to_trace(NULL, ep),
"Sequence FT with length in unavailable root is invalid");
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_a = bt_field_type_integer_create(32);
- assert(root_a);
+ BT_ASSERT(root_a);
ret = bt_field_type_integer_set_is_signed(root_a, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_a, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_a, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_a, "a");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b_elem = bt_field_type_string_create();
- assert(root_b_elem);
+ BT_ASSERT(root_b_elem);
ret = bt_field_type_string_set_encoding(root_b_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b = bt_field_type_sequence_create(root_b_elem, "event.fields");
- assert(root_b);
+ BT_ASSERT(root_b);
ret = bt_field_type_structure_add_field(root, root_b, "b");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_c = bt_field_type_string_create();
- assert(root_c);
+ BT_ASSERT(root_c);
ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_c, "c");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_a);
BT_PUT(root_b);
struct bt_field_type *ep;
ep = test_fail_target_is_root_get_event_payload();
- assert(ep);
+ BT_ASSERT(ep);
ok(try_add_event_class_to_trace(NULL, ep),
"Sequence FT with root as its length is invalid");
BT_PUT(ep);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_a = bt_field_type_integer_create(32);
- assert(root_a);
+ BT_ASSERT(root_a);
ret = bt_field_type_integer_set_is_signed(root_a, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_a, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_a, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_a, "a");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b_elem = bt_field_type_string_create();
- assert(root_b_elem);
+ BT_ASSERT(root_b_elem);
ret = bt_field_type_string_set_encoding(root_b_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b = bt_field_type_sequence_create(root_b_elem, "d");
- assert(root_b);
+ BT_ASSERT(root_b);
ret = bt_field_type_structure_add_field(root, root_b, "b");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_c = bt_field_type_string_create();
- assert(root_c);
+ BT_ASSERT(root_c);
ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_c, "c");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_d = bt_field_type_integer_create(17);
- assert(root_d);
+ BT_ASSERT(root_d);
ret = bt_field_type_integer_set_is_signed(root_d, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_d, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_d, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_d, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_d, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_d, "d");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_a);
BT_PUT(root_b);
struct bt_field_type *ep;
ep = test_fail_target_is_after_source_get_ep();
- assert(ep);
+ BT_ASSERT(ep);
ok(try_add_event_class_to_trace(NULL, ep),
"Sequence FT with length after it is invalid");
BT_PUT(ep);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_a = bt_field_type_integer_create(32);
- assert(root_a);
+ BT_ASSERT(root_a);
ret = bt_field_type_integer_set_is_signed(root_a, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_a, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_a, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_a, "a");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_z = bt_field_type_structure_create();
- assert(root_z);
+ BT_ASSERT(root_z);
ret = bt_field_type_set_alignment(root_z, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_z_b_elem = bt_field_type_string_create();
- assert(root_z_b_elem);
+ BT_ASSERT(root_z_b_elem);
ret = bt_field_type_string_set_encoding(root_z_b_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_z_b = bt_field_type_sequence_create(root_z_b_elem, "z");
- assert(root_z_b);
+ BT_ASSERT(root_z_b);
ret = bt_field_type_structure_add_field(root_z, root_z_b, "b");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_z, "z");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_c = bt_field_type_string_create();
- assert(root_c);
+ BT_ASSERT(root_c);
ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_c, "c");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_d = bt_field_type_integer_create(17);
- assert(root_d);
+ BT_ASSERT(root_d);
ret = bt_field_type_integer_set_is_signed(root_d, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_d, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_d, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_d, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_d, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_d, "d");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_a);
BT_PUT(root_z);
struct bt_field_type *ep;
ep = test_fail_target_is_ancestor_of_source_get_ep();
- assert(ep);
+ BT_ASSERT(ep);
ok(try_add_event_class_to_trace(NULL, ep),
"Sequence FT with ancestor as its length is invalid");
BT_PUT(ep);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_a = bt_field_type_integer_create(32);
- assert(root_a);
+ BT_ASSERT(root_a);
ret = bt_field_type_integer_set_is_signed(root_a, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_a, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_a, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_a, "a");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b_elem = bt_field_type_string_create();
- assert(root_b_elem);
+ BT_ASSERT(root_b_elem);
ret = bt_field_type_string_set_encoding(root_b_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b = bt_field_type_sequence_create(root_b_elem, "event.fields.b");
- assert(root_b);
+ BT_ASSERT(root_b);
ret = bt_field_type_structure_add_field(root, root_b, "b");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_c = bt_field_type_string_create();
- assert(root_c);
+ BT_ASSERT(root_c);
ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_c, "c");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_d = bt_field_type_integer_create(17);
- assert(root_d);
+ BT_ASSERT(root_d);
ret = bt_field_type_integer_set_is_signed(root_d, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_d, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_d, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_d, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_d, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_d, "d");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_a);
BT_PUT(root_b);
struct bt_field_type *ep;
ep = test_fail_target_is_source_get_event_payload();
- assert(ep);
+ BT_ASSERT(ep);
ok(try_add_event_class_to_trace(NULL, ep),
"Sequence FT with itself as its length is invalid");
BT_PUT(ep);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_a = bt_field_type_integer_create(32);
- assert(root_a);
+ BT_ASSERT(root_a);
ret = bt_field_type_integer_set_is_signed(root_a, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_a, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_a, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_a, "a");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b = bt_field_type_variant_create(NULL, "a");
- assert(root_b);
+ BT_ASSERT(root_b);
root_b_HELLO = bt_field_type_string_create();
- assert(root_b_HELLO);
+ BT_ASSERT(root_b_HELLO);
ret = bt_field_type_string_set_encoding(root_b_HELLO, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_variant_add_field(root_b, root_b_HELLO, "HELLO");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_b, "b");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_c = bt_field_type_string_create();
- assert(root_c);
+ BT_ASSERT(root_c);
ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_c, "c");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_d = bt_field_type_integer_create(17);
- assert(root_d);
+ BT_ASSERT(root_d);
ret = bt_field_type_integer_set_is_signed(root_d, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_d, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_d, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_d, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_d, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_d, "d");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_a);
BT_PUT(root_b);
struct bt_field_type *ep;
ep = test_fail_variant_tag_is_not_enum_get_ep();
- assert(ep);
+ BT_ASSERT(ep);
ok(try_add_event_class_to_trace(NULL, ep),
"Variant FT with non-enum FT as its tag FT is invalid");
BT_PUT(ep);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_a_int = bt_field_type_integer_create(16);
- assert(root_a_int);
+ BT_ASSERT(root_a_int);
ret = bt_field_type_integer_set_is_signed(root_a_int, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_a_int, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_a_int, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_a_int, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_a_int, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_a = bt_field_type_enumeration_create(root_a_int);
- assert(root_a);
+ BT_ASSERT(root_a);
ret = bt_field_type_enumeration_unsigned_add_mapping(root_a, "GLASS", 0, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_enumeration_unsigned_add_mapping(root_a, "OF", 1, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_enumeration_unsigned_add_mapping(root_a, "WATER", 2, 2);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_a, "a");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b = bt_field_type_variant_create(NULL, "a");
- assert(root_b);
+ BT_ASSERT(root_b);
root_b_GLASS = bt_field_type_string_create();
- assert(root_b_GLASS);
+ BT_ASSERT(root_b_GLASS);
ret = bt_field_type_string_set_encoding(root_b_GLASS, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_variant_add_field(root_b, root_b_GLASS, "GLASS");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b_OF = bt_field_type_integer_create(2);
- assert(root_b_OF);
+ BT_ASSERT(root_b_OF);
ret = bt_field_type_integer_set_is_signed(root_b_OF, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_base(root_b_OF, 10);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_encoding(root_b_OF, BT_STRING_ENCODING_NONE);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_byte_order(root_b_OF, BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_set_alignment(root_b_OF, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_variant_add_field(root_b, root_b_OF, "OF");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_b, "b");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_c = bt_field_type_string_create();
- assert(root_c);
+ BT_ASSERT(root_c);
ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_c, "c");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_a);
BT_PUT(root_a_int);
struct bt_field_type *ep;
ep = test_fail_variant_tag_mismatch_mappings_get_ep();
- assert(ep);
+ BT_ASSERT(ep);
ok(try_add_event_class_to_trace(NULL, ep) == 0,
"Variant FT with mismatching tag FT is valid");
BT_PUT(ep);
int ret;
root = bt_field_type_structure_create();
- assert(root);
+ BT_ASSERT(root);
ret = bt_field_type_set_alignment(root, 8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_a = bt_field_type_string_create();
- assert(root_a);
+ BT_ASSERT(root_a);
ret = bt_field_type_string_set_encoding(root_a, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_a, "a");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b_elem = bt_field_type_string_create();
- assert(root_b_elem);
+ BT_ASSERT(root_b_elem);
ret = bt_field_type_string_set_encoding(root_b_elem, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_b = bt_field_type_sequence_create(root_b_elem, "a");
- assert(root_b);
+ BT_ASSERT(root_b);
ret = bt_field_type_structure_add_field(root, root_b, "b");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
root_c = bt_field_type_string_create();
- assert(root_c);
+ BT_ASSERT(root_c);
ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_structure_add_field(root, root_c, "c");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
BT_PUT(root_a);
BT_PUT(root_b);
struct bt_field_type *ep;
ep = test_fail_sequence_tag_is_not_int_get_ep();
- assert(ep);
+ BT_ASSERT(ep);
ok(try_add_event_class_to_trace(NULL, ep),
"Sequence FT with non-enum length FT is invalid");
BT_PUT(ep);
#include <stdbool.h>
#include <inttypes.h>
#include <string.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include <babeltrace/ctf-ir/event-class.h>
#include <babeltrace/ctf-ir/event.h>
#include <babeltrace/ctf-ir/field-types.h>
const struct test_event *expected_event = expected_events;
size_t i = 0;
- assert(expected_events);
+ BT_ASSERT(expected_events);
while (true) {
const struct test_event *event;
/* Test events */
test_events = g_array_new(FALSE, TRUE, sizeof(struct test_event));
- assert(test_events);
+ BT_ASSERT(test_events);
/* Metadata */
empty_struct_ft = bt_field_type_structure_create();
- assert(empty_struct_ft);
+ BT_ASSERT(empty_struct_ft);
trace = bt_trace_create();
- assert(trace);
+ BT_ASSERT(trace);
ret = bt_trace_set_packet_header_field_type(trace, empty_struct_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
src_empty_cc_prio_map = bt_clock_class_priority_map_create();
- assert(src_empty_cc_prio_map);
+ BT_ASSERT(src_empty_cc_prio_map);
src_stream_class = bt_stream_class_create("my-stream-class");
- assert(src_stream_class);
+ BT_ASSERT(src_stream_class);
ret = bt_stream_class_set_packet_context_field_type(src_stream_class,
empty_struct_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_set_event_header_field_type(src_stream_class,
empty_struct_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_set_event_context_field_type(src_stream_class,
empty_struct_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
src_event_class = bt_event_class_create("my-event-class");
ret = bt_event_class_set_context_field_type(src_event_class,
empty_struct_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_event_class_set_payload_field_type(src_event_class,
empty_struct_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_add_event_class(src_stream_class,
src_event_class);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_trace_add_stream_class(trace, src_stream_class);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
src_stream1 = bt_stream_create(src_stream_class, "stream-1", 0);
- assert(src_stream1);
+ BT_ASSERT(src_stream1);
src_stream2 = bt_stream_create(src_stream_class, "stream-2", 1);
- assert(src_stream2);
+ BT_ASSERT(src_stream2);
src_stream1_packet1 = bt_packet_create(src_stream1);
- assert(src_stream1_packet1);
+ BT_ASSERT(src_stream1_packet1);
src_stream1_packet2 = bt_packet_create(src_stream1);
- assert(src_stream1_packet2);
+ BT_ASSERT(src_stream1_packet2);
src_stream2_packet1 = bt_packet_create(src_stream2);
- assert(src_stream2_packet1);
+ BT_ASSERT(src_stream2_packet1);
src_stream2_packet2 = bt_packet_create(src_stream2);
- assert(src_stream2_packet2);
+ BT_ASSERT(src_stream2_packet2);
if (debug) {
fprintf(stderr, ":: stream 1: %p\n", src_stream1);
g_new0(struct src_iter_user_data, 1);
int ret;
- assert(user_data);
+ BT_ASSERT(user_data);
ret = bt_private_connection_private_notification_iterator_set_user_data(
priv_notif_iter, user_data);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
switch (current_test) {
case TEST_NO_AUTO_NOTIFS:
int64_t cur_ts_ns;
struct bt_packet *event_packet = NULL;
- assert(user_data->seq);
+ BT_ASSERT(user_data->seq);
cur_ts_ns = user_data->seq[user_data->at];
switch (cur_ts_ns) {
next_return.notification =
bt_notification_inactivity_create(graph,
src_empty_cc_prio_map);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM1_BEGIN:
next_return.notification =
bt_notification_stream_begin_create(graph, src_stream1);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM2_BEGIN:
next_return.notification =
bt_notification_stream_begin_create(graph, src_stream2);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM1_END:
next_return.notification =
bt_notification_stream_end_create(graph, src_stream1);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM2_END:
next_return.notification =
bt_notification_stream_end_create(graph, src_stream2);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM1_PACKET1_BEGIN:
next_return.notification =
bt_notification_packet_begin_create(graph,
src_stream1_packet1);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM1_PACKET2_BEGIN:
next_return.notification =
bt_notification_packet_begin_create(graph,
src_stream1_packet2);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM2_PACKET1_BEGIN:
next_return.notification =
bt_notification_packet_begin_create(graph,
src_stream2_packet1);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM2_PACKET2_BEGIN:
next_return.notification =
bt_notification_packet_begin_create(graph,
src_stream2_packet2);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM1_PACKET1_END:
next_return.notification =
bt_notification_packet_end_create(graph,
src_stream1_packet1);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM1_PACKET2_END:
next_return.notification =
bt_notification_packet_end_create(graph,
src_stream1_packet2);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM2_PACKET1_END:
next_return.notification =
bt_notification_packet_end_create(graph,
src_stream2_packet1);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM2_PACKET2_END:
next_return.notification =
bt_notification_packet_end_create(graph,
src_stream2_packet2);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_EVENT_STREAM1_PACKET1:
event_packet = src_stream1_packet1;
if (event_packet) {
next_return.notification =
bt_notification_event_create(graph, src_event_class,
- event_packet, src_empty_cc_prio_map);
- assert(next_return.notification);
+ event_packet, src_empty_cc_prio_map);
+ BT_ASSERT(next_return.notification);
}
if (next_return.status != BT_NOTIFICATION_ITERATOR_STATUS_END) {
struct src_iter_user_data *user_data =
bt_private_connection_private_notification_iterator_get_user_data(priv_iterator);
- assert(user_data);
+ BT_ASSERT(user_data);
next_return = src_iter_next_seq(user_data);
return next_return;
}
ret = bt_private_component_source_add_output_private_port(
private_component, "out", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
return BT_COMPONENT_STATUS_OK;
}
struct bt_notification *notification = NULL;
struct test_event test_event = { 0 };
bool do_append_test_event = true;
- assert(notif_iter);
+ BT_ASSERT(notif_iter);
ret = bt_notification_iterator_next(notif_iter);
if (ret < 0) {
notification = bt_notification_iterator_get_notification(
notif_iter);
- assert(notification);
+ BT_ASSERT(notification);
switch (bt_notification_get_type(notification)) {
case BT_NOTIFICATION_TYPE_EVENT:
test_event.type = TEST_EV_TYPE_NOTIF_EVENT;
event = bt_notification_event_borrow_event(notification);
- assert(event);
+ BT_ASSERT(event);
test_event.packet = bt_event_borrow_packet(event);
- assert(test_event.packet);
+ BT_ASSERT(test_event.packet);
break;
}
case BT_NOTIFICATION_TYPE_INACTIVITY:
test_event.type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN;
test_event.stream =
bt_notification_stream_begin_borrow_stream(notification);
- assert(test_event.stream);
+ BT_ASSERT(test_event.stream);
break;
case BT_NOTIFICATION_TYPE_STREAM_END:
test_event.type = TEST_EV_TYPE_NOTIF_STREAM_END;
test_event.stream =
bt_notification_stream_end_borrow_stream(notification);
- assert(test_event.stream);
+ BT_ASSERT(test_event.stream);
break;
case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
test_event.type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN;
test_event.packet =
bt_notification_packet_begin_borrow_packet(notification);
- assert(test_event.packet);
+ BT_ASSERT(test_event.packet);
break;
case BT_NOTIFICATION_TYPE_PACKET_END:
test_event.type = TEST_EV_TYPE_NOTIF_PACKET_END;
test_event.packet =
bt_notification_packet_end_borrow_packet(notification);
- assert(test_event.packet);
+ BT_ASSERT(test_event.packet);
break;
default:
test_event.type = TEST_EV_TYPE_NOTIF_UNEXPECTED;
if (test_event.packet) {
test_event.stream = bt_packet_borrow_stream(test_event.packet);
- assert(test_event.stream);
+ BT_ASSERT(test_event.stream);
}
end:
bt_private_component_get_user_data(priv_component);
enum bt_notification_iterator_status it_ret;
- assert(user_data && user_data->notif_iter);
+ BT_ASSERT(user_data && user_data->notif_iter);
it_ret = common_consume(user_data->notif_iter);
if (it_ret < 0) {
private_component);
enum bt_connection_status conn_status;
- assert(user_data);
- assert(priv_conn);
+ BT_ASSERT(user_data);
+ BT_ASSERT(priv_conn);
conn_status = bt_private_connection_create_notification_iterator(
priv_conn, &user_data->notif_iter);
- assert(conn_status == 0);
+ BT_ASSERT(conn_status == 0);
bt_put(priv_conn);
}
struct sink_user_data *user_data = g_new0(struct sink_user_data, 1);
int ret;
- assert(user_data);
+ BT_ASSERT(user_data);
ret = bt_private_component_set_user_data(private_component,
user_data);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_private_component_sink_add_input_private_port(
private_component, "in", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
return BT_COMPONENT_STATUS_OK;
}
if (source) {
src_comp_class = bt_component_class_source_create("src",
src_iter_next);
- assert(src_comp_class);
+ BT_ASSERT(src_comp_class);
ret = bt_component_class_set_init_method(src_comp_class,
src_init);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_set_finalize_method(src_comp_class,
src_finalize);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_source_set_notification_iterator_init_method(
src_comp_class, src_iter_init);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_source_set_notification_iterator_finalize_method(
src_comp_class, src_iter_finalize);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_graph_add_component(graph, src_comp_class, "source",
NULL, source);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(src_comp_class);
}
if (sink) {
sink_comp_class = bt_component_class_sink_create("sink",
sink_consume);
- assert(sink_comp_class);
+ BT_ASSERT(sink_comp_class);
ret = bt_component_class_set_init_method(sink_comp_class,
sink_init);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_set_finalize_method(sink_comp_class,
sink_finalize);
ret = bt_component_class_set_port_connected_method(
sink_comp_class, sink_port_connected);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_graph_add_component(graph, sink_comp_class, "sink",
NULL, sink);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(sink_comp_class);
}
}
clear_test_events();
current_test = test;
diag("test: %s", name);
- assert(!graph);
+ BT_ASSERT(!graph);
graph = bt_graph_create();
- assert(graph);
+ BT_ASSERT(graph);
create_source_sink(graph, &src_comp, &sink_comp);
/* Connect source to sink */
upstream_port = bt_component_source_get_output_port_by_name(src_comp, "out");
- assert(upstream_port);
+ BT_ASSERT(upstream_port);
downstream_port = bt_component_sink_get_input_port_by_name(sink_comp, "in");
- assert(downstream_port);
+ BT_ASSERT(downstream_port);
graph_status = bt_graph_connect_ports(graph, upstream_port,
downstream_port, NULL);
bt_put(upstream_port);
clear_test_events();
current_test = TEST_OUTPUT_PORT_NOTIFICATION_ITERATOR;
diag("test: output port notification iterator");
- assert(!graph);
+ BT_ASSERT(!graph);
graph = bt_graph_create();
- assert(graph);
+ BT_ASSERT(graph);
create_source_sink(graph, &src_comp, NULL);
/* Create notification iterator on source's output port */
clear_test_events();
current_test = TEST_OUTPUT_PORT_NOTIFICATION_ITERATOR;
diag("test: cannot consume graph with existing output port notification iterator");
- assert(!graph);
+ BT_ASSERT(!graph);
graph = bt_graph_create();
- assert(graph);
+ BT_ASSERT(graph);
create_source_sink(graph, &src_comp, NULL);
/* Create notification iterator on source's output port */
upstream_port = bt_component_source_get_output_port_by_name(src_comp, "out");
notif_iter = bt_output_port_notification_iterator_create(upstream_port,
NULL);
- assert(notif_iter);
+ BT_ASSERT(notif_iter);
bt_put(upstream_port);
/*
#include <babeltrace/ref.h>
#include <babeltrace/values.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include <string.h>
#include "tap/tap.h"
ret = bt_value_bool_get(obj, &value);
ok(!ret && !value, "default boolean value object value is BT_FALSE");
- assert(!bt_value_bool_set(obj, BT_FALSE));
+ BT_ASSERT(!bt_value_bool_set(obj, BT_FALSE));
ret = bt_value_bool_set(obj, BT_TRUE);
ok(!ret, "bt_value_bool_set() succeeds");
ret = bt_value_bool_get(obj, &value);
"bt_value_array_get() returns an value object with the appropriate type (null)");
obj = bt_value_integer_create_init(1001);
- assert(obj);
+ BT_ASSERT(obj);
ok(!bt_value_array_set(array_obj, 2, obj),
"bt_value_array_set() succeeds");
BT_PUT(obj);
ok(obj && bt_value_is_integer(obj),
"bt_value_array_set() inserts an value object with the appropriate type");
ret = bt_value_integer_get(obj, &int_value);
- assert(!ret);
+ BT_ASSERT(!ret);
ok(int_value == 1001,
"bt_value_array_set() inserts an value object with the appropriate value");
BT_PUT(obj);
struct bt_value *bool2 = bt_value_bool_create_init(BT_TRUE);
struct bt_value *bool3 = bt_value_bool_create_init(BT_FALSE);
- assert(bool1 && bool2 && bool3);
+ BT_ASSERT(bool1 && bool2 && bool3);
ok(!bt_value_compare(bt_value_null, bool1),
"cannot compare null value object and bt_bool value object");
ok(!bt_value_compare(bool1, bool2),
struct bt_value *int2 = bt_value_integer_create_init(-23);
struct bt_value *int3 = bt_value_integer_create_init(10);
- assert(int1 && int2 && int3);
+ BT_ASSERT(int1 && int2 && int3);
ok(!bt_value_compare(bt_value_null, int1),
"cannot compare null value object and integer value object");
ok(!bt_value_compare(int1, int2),
struct bt_value *float2 = bt_value_float_create_init(-14.23);
struct bt_value *float3 = bt_value_float_create_init(17.38);
- assert(float1 && float2 && float3);
+ BT_ASSERT(float1 && float2 && float3);
ok(!bt_value_compare(bt_value_null, float1),
"cannot compare null value object and floating point number value object");
struct bt_value *string2 = bt_value_string_create_init("bt_value");
struct bt_value *string3 = bt_value_string_create_init("hello");
- assert(string1 && string2 && string3);
+ BT_ASSERT(string1 && string2 && string3);
ok(!bt_value_compare(bt_value_null, string1),
"cannot compare null value object and string value object");
struct bt_value *array2 = bt_value_array_create();
struct bt_value *array3 = bt_value_array_create();
- assert(array1 && array2 && array3);
+ BT_ASSERT(array1 && array2 && array3);
ok(bt_value_compare(array1, array2),
"empty array value objects are equivalent");
- assert(!bt_value_array_append_integer(array1, 23));
- assert(!bt_value_array_append_float(array1, 14.2));
- assert(!bt_value_array_append_bool(array1, BT_FALSE));
- assert(!bt_value_array_append_float(array2, 14.2));
- assert(!bt_value_array_append_integer(array2, 23));
- assert(!bt_value_array_append_bool(array2, BT_FALSE));
- assert(!bt_value_array_append_integer(array3, 23));
- assert(!bt_value_array_append_float(array3, 14.2));
- assert(!bt_value_array_append_bool(array3, BT_FALSE));
- assert(bt_value_array_size(array1) == 3);
- assert(bt_value_array_size(array2) == 3);
- assert(bt_value_array_size(array3) == 3);
+ BT_ASSERT(!bt_value_array_append_integer(array1, 23));
+ BT_ASSERT(!bt_value_array_append_float(array1, 14.2));
+ BT_ASSERT(!bt_value_array_append_bool(array1, BT_FALSE));
+ BT_ASSERT(!bt_value_array_append_float(array2, 14.2));
+ BT_ASSERT(!bt_value_array_append_integer(array2, 23));
+ BT_ASSERT(!bt_value_array_append_bool(array2, BT_FALSE));
+ BT_ASSERT(!bt_value_array_append_integer(array3, 23));
+ BT_ASSERT(!bt_value_array_append_float(array3, 14.2));
+ BT_ASSERT(!bt_value_array_append_bool(array3, BT_FALSE));
+ BT_ASSERT(bt_value_array_size(array1) == 3);
+ BT_ASSERT(bt_value_array_size(array2) == 3);
+ BT_ASSERT(bt_value_array_size(array3) == 3);
ok(!bt_value_compare(bt_value_null, array1),
"cannot compare null value object and array value object");
struct bt_value *map2 = bt_value_map_create();
struct bt_value *map3 = bt_value_map_create();
- assert(map1 && map2 && map3);
+ BT_ASSERT(map1 && map2 && map3);
ok(bt_value_compare(map1, map2),
"empty map value objects are equivalent");
- assert(!bt_value_map_insert_integer(map1, "one", 23));
- assert(!bt_value_map_insert_float(map1, "two", 14.2));
- assert(!bt_value_map_insert_bool(map1, "three", BT_FALSE));
- assert(!bt_value_map_insert_float(map2, "one", 14.2));
- assert(!bt_value_map_insert_integer(map2, "two", 23));
- assert(!bt_value_map_insert_bool(map2, "three", BT_FALSE));
- assert(!bt_value_map_insert_bool(map3, "three", BT_FALSE));
- assert(!bt_value_map_insert_integer(map3, "one", 23));
- assert(!bt_value_map_insert_float(map3, "two", 14.2));
- assert(bt_value_map_size(map1) == 3);
- assert(bt_value_map_size(map2) == 3);
- assert(bt_value_map_size(map3) == 3);
+ BT_ASSERT(!bt_value_map_insert_integer(map1, "one", 23));
+ BT_ASSERT(!bt_value_map_insert_float(map1, "two", 14.2));
+ BT_ASSERT(!bt_value_map_insert_bool(map1, "three", BT_FALSE));
+ BT_ASSERT(!bt_value_map_insert_float(map2, "one", 14.2));
+ BT_ASSERT(!bt_value_map_insert_integer(map2, "two", 23));
+ BT_ASSERT(!bt_value_map_insert_bool(map2, "three", BT_FALSE));
+ BT_ASSERT(!bt_value_map_insert_bool(map3, "three", BT_FALSE));
+ BT_ASSERT(!bt_value_map_insert_integer(map3, "one", 23));
+ BT_ASSERT(!bt_value_map_insert_float(map3, "two", 14.2));
+ BT_ASSERT(bt_value_map_size(map1) == 3);
+ BT_ASSERT(bt_value_map_size(map2) == 3);
+ BT_ASSERT(bt_value_map_size(map3) == 3);
ok(!bt_value_compare(bt_value_null, map1),
"cannot compare null value object and map value object");
array_obj = bt_value_array_create();
map_obj = bt_value_map_create();
- assert(bool_obj && integer_obj && float_obj && string_obj &&
+ BT_ASSERT(bool_obj && integer_obj && float_obj && string_obj &&
array_obj && map_obj);
- assert(!bt_value_array_append(array_obj, bool_obj));
- assert(!bt_value_array_append(array_obj, integer_obj));
- assert(!bt_value_array_append(array_obj, float_obj));
- assert(!bt_value_array_append(array_obj, bt_value_null));
- assert(!bt_value_map_insert(map_obj, "array", array_obj));
- assert(!bt_value_map_insert(map_obj, "string", string_obj));
+ BT_ASSERT(!bt_value_array_append(array_obj, bool_obj));
+ BT_ASSERT(!bt_value_array_append(array_obj, integer_obj));
+ BT_ASSERT(!bt_value_array_append(array_obj, float_obj));
+ BT_ASSERT(!bt_value_array_append(array_obj, bt_value_null));
+ BT_ASSERT(!bt_value_map_insert(map_obj, "array", array_obj));
+ BT_ASSERT(!bt_value_map_insert(map_obj, "string", string_obj));
map_copy_obj = bt_value_copy(map_obj);
ok(map_copy_obj,
struct bt_value *array = bt_value_array_create();
enum bt_value_status status;
- assert(base_map);
- assert(extension_map);
- assert(array);
+ BT_ASSERT(base_map);
+ BT_ASSERT(extension_map);
+ BT_ASSERT(array);
status = bt_value_map_insert_bool(base_map, "file", BT_TRUE);
- assert(status == BT_VALUE_STATUS_OK);
+ BT_ASSERT(status == BT_VALUE_STATUS_OK);
status = bt_value_map_insert_bool(base_map, "edit", BT_FALSE);
- assert(status == BT_VALUE_STATUS_OK);
+ BT_ASSERT(status == BT_VALUE_STATUS_OK);
status = bt_value_map_insert_integer(base_map, "selection", 17);
- assert(status == BT_VALUE_STATUS_OK);
+ BT_ASSERT(status == BT_VALUE_STATUS_OK);
status = bt_value_map_insert_integer(base_map, "find", -34);
- assert(status == BT_VALUE_STATUS_OK);
+ BT_ASSERT(status == BT_VALUE_STATUS_OK);
status = bt_value_map_insert_bool(extension_map, "edit", BT_TRUE);
- assert(status == BT_VALUE_STATUS_OK);
+ BT_ASSERT(status == BT_VALUE_STATUS_OK);
status = bt_value_map_insert_integer(extension_map, "find", 101);
- assert(status == BT_VALUE_STATUS_OK);
+ BT_ASSERT(status == BT_VALUE_STATUS_OK);
status = bt_value_map_insert_float(extension_map, "project", -404);
- assert(status == BT_VALUE_STATUS_OK);
+ BT_ASSERT(status == BT_VALUE_STATUS_OK);
extended_map = bt_value_map_extend(base_map, extension_map);
ok(extended_map, "bt_value_map_extend() succeeds");
ok(bt_value_map_size(extended_map) == 5,
#include <babeltrace/ref.h>
#include <babeltrace/graph/clock-class-priority-map.h>
#include <babeltrace/ctf-ir/clock-class.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include "tap/tap.h"
cc_prio_map = bt_clock_class_priority_map_create();
ok(cc_prio_map, "bt_clock_class_priority_map_create() succeeds");
cc1 = bt_clock_class_create("cc1", 1);
- assert(cc1);
+ BT_ASSERT(cc1);
cc2 = bt_clock_class_create("cc2", 2);
- assert(cc2);
+ BT_ASSERT(cc2);
cc3 = bt_clock_class_create("cc3", 3);
- assert(cc3);
+ BT_ASSERT(cc3);
ok(!bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map),
"bt_clock_class_priority_map_get_highest_priority_clock_class() returns NULL when there's no clock classes");
ret = bt_clock_class_priority_map_add_clock_class(cc_prio_map, cc2, 75);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
cc = bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map);
ok(cc == cc2,
"bt_clock_class_priority_map_get_highest_priority_clock_class() returns the expected clock class (1)");
BT_PUT(cc);
ret = bt_clock_class_priority_map_add_clock_class(cc_prio_map, cc1, 1001);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
cc = bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map);
ok(cc == cc2,
"bt_clock_class_priority_map_get_highest_priority_clock_class() returns the expected clock class (2)");
BT_PUT(cc);
ret = bt_clock_class_priority_map_add_clock_class(cc_prio_map, cc3, 11);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
cc = bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map);
ok(cc == cc3,
"bt_clock_class_priority_map_get_highest_priority_clock_class() returns the expected clock class (3)");
ok(prio == 1001,
"bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (1)");
ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map, cc2, &prio);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ok(prio == 75,
"bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (2)");
ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map, cc3, &prio);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ok(prio == 11,
"bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (3)");
cc_prio_map_copy = bt_clock_class_priority_map_copy(cc_prio_map);
ok(cc_prio_map_copy, "bt_clock_class_priority_map_copy() succeeds");
ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map_copy, cc1, &prio);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ok(prio == 1001,
"bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (1, copy)");
ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map_copy, cc2, &prio);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ok(prio == 75,
"bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (2, copy)");
ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map_copy, cc3, &prio);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ok(prio == 11,
"bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (3, copy)");
cc = bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map_copy);
ret = bt_clock_class_priority_map_add_clock_class(cc_prio_map_copy, cc3, 253);
ok(ret == 0, "bt_clock_class_priority_map_add_clock_class() succeeds for an existing clock class");
ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map_copy, cc3, &prio);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ok(prio == 253,
"bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (updated, copy)");
cc = bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map_copy);
#include <babeltrace/ctf-ir/trace.h>
#include <babeltrace/object-internal.h>
#include <babeltrace/compat/stdlib-internal.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include "common.h"
#define NR_TESTS 41
struct bt_event_class *event = NULL;
struct bt_field_type *payload = NULL;
- assert(name);
+ BT_ASSERT(name);
event = bt_event_class_create(name);
if (!event) {
diag("Failed to create simple event");
struct bt_event_class *event = NULL;
struct bt_field_type *inner = NULL, *outer = NULL;
- assert(name);
+ BT_ASSERT(name);
event = bt_event_class_create(name);
if (!event) {
diag("Failed to create complex event");
int ret;
packet_context_type = bt_field_type_structure_create();
- assert(packet_context_type);
+ BT_ASSERT(packet_context_type);
ft = bt_field_type_integer_create(32);
- assert(ft);
+ BT_ASSERT(ft);
ret = bt_field_type_structure_add_field(packet_context_type,
ft, "packet_size");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(ft);
ft = bt_field_type_integer_create(32);
- assert(ft);
+ BT_ASSERT(ft);
ret = bt_field_type_structure_add_field(packet_context_type,
ft, "content_size");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(ft);
event_header_type = bt_field_type_structure_create();
- assert(event_header_type);
+ BT_ASSERT(event_header_type);
ft = bt_field_type_integer_create(32);
- assert(ft);
+ BT_ASSERT(ft);
ret = bt_field_type_structure_add_field(event_header_type,
ft, "id");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(ft);
ret = bt_stream_class_set_packet_context_field_type(stream_class,
packet_context_type);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_set_event_header_field_type(stream_class,
event_header_type);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(packet_context_type);
bt_put(event_header_type);
int ret;
packet_header_type = bt_field_type_structure_create();
- assert(packet_header_type);
+ BT_ASSERT(packet_header_type);
ft = bt_field_type_integer_create(32);
- assert(ft);
+ BT_ASSERT(ft);
ret = bt_field_type_structure_add_field(packet_header_type,
ft, "stream_id");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(ft);
ret = bt_trace_set_packet_header_field_type(trace,
packet_header_type);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(packet_header_type);
}
}
user->writer = bt_ctf_writer_create(trace_path);
- assert(user->writer);
+ BT_ASSERT(user->writer);
ret = bt_ctf_writer_set_byte_order(user->writer,
BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
user->tc = bt_ctf_writer_get_trace(user->writer);
- assert(user->tc);
+ BT_ASSERT(user->tc);
user->sc = bt_ctf_stream_class_create("sc");
- assert(user->sc);
+ BT_ASSERT(user->sc);
clock = bt_ctf_clock_create("the_clock");
- assert(clock);
+ BT_ASSERT(clock);
ret = bt_ctf_writer_add_clock(user->writer, clock);
- assert(!ret);
+ BT_ASSERT(!ret);
ret = bt_ctf_stream_class_set_clock(user->sc, clock);
- assert(!ret);
+ BT_ASSERT(!ret);
BT_PUT(clock);
user->stream = bt_ctf_writer_create_stream(user->writer, user->sc);
- assert(user->stream);
+ BT_ASSERT(user->stream);
user->ec = bt_ctf_event_class_create("ec");
- assert(user->ec);
+ BT_ASSERT(user->ec);
ft = create_writer_integer_struct();
- assert(ft);
+ BT_ASSERT(ft);
ret = bt_ctf_event_class_set_payload_field_type(user->ec, ft);
BT_PUT(ft);
- assert(!ret);
+ BT_ASSERT(!ret);
ret = bt_ctf_stream_class_add_event_class(user->sc, user->ec);
- assert(!ret);
+ BT_ASSERT(!ret);
user->event = bt_ctf_event_create(user->ec);
- assert(user->event);
+ BT_ASSERT(user->event);
field = bt_ctf_event_get_payload(user->event, "payload_8");
- assert(field);
+ BT_ASSERT(field);
ret = bt_ctf_field_integer_unsigned_set_value(field, 10);
- assert(!ret);
+ BT_ASSERT(!ret);
BT_PUT(field);
field = bt_ctf_event_get_payload(user->event, "payload_16");
- assert(field);
+ BT_ASSERT(field);
ret = bt_ctf_field_integer_unsigned_set_value(field, 20);
- assert(!ret);
+ BT_ASSERT(!ret);
BT_PUT(field);
field = bt_ctf_event_get_payload(user->event, "payload_32");
- assert(field);
+ BT_ASSERT(field);
ret = bt_ctf_field_integer_unsigned_set_value(field, 30);
- assert(!ret);
+ BT_ASSERT(!ret);
BT_PUT(field);
ret = bt_ctf_stream_append_event(user->stream, user->event);
- assert(!ret);
+ BT_ASSERT(!ret);
recursive_rmdir(trace_path);
g_free(trace_path);
}
#include <babeltrace/compat/limits-internal.h>
#include <babeltrace/compat/stdio-internal.h>
#include <string.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include <fcntl.h>
#include "tap/tap.h"
#include <math.h>
bt_ctf_event_class_add_field(simple_event_class, float_type,
"float_field");
- assert(!bt_ctf_event_class_set_id(simple_event_class, 13));
+ BT_ASSERT(!bt_ctf_event_class_set_id(simple_event_class, 13));
/* Set an event context type which will contain a single integer. */
ok(!bt_ctf_field_type_structure_add_field(event_context_type, uint_12_type,
BT_PUT(event_payload_type);
event_payload_type = bt_ctf_event_class_get_payload_field_type(
simple_event_class);
- assert(event_payload_type);
+ BT_ASSERT(event_payload_type);
event_context_type = bt_ctf_event_class_get_context_field_type(
simple_event_class);
- assert(event_context_type);
+ BT_ASSERT(event_context_type);
ep_integer_field_type =
bt_ctf_field_type_structure_get_field_type_by_name(
event_payload_type, "integer_field");
- assert(ep_integer_field_type);
+ BT_ASSERT(ep_integer_field_type);
ep_enum_field_type =
bt_ctf_field_type_structure_get_field_type_by_name(
event_payload_type, "enum_field");
- assert(ep_enum_field_type);
+ BT_ASSERT(ep_enum_field_type);
ep_enum_field_unsigned_type =
bt_ctf_field_type_structure_get_field_type_by_name(
event_payload_type, "enum_field_unsigned");
- assert(ep_enum_field_unsigned_type);
+ BT_ASSERT(ep_enum_field_unsigned_type);
ok(bt_ctf_stream_class_get_event_class_count(stream_class) == 1,
"bt_ctf_stream_class_get_event_class_count returns a correct number of event classes");
"bt_ctf_field_floating_point_get_value returns a correct value");
enum_field = bt_ctf_field_create(ep_enum_field_type);
- assert(enum_field);
+ BT_ASSERT(enum_field);
enum_container_field = bt_ctf_field_enumeration_get_container(enum_field);
ok(bt_ctf_field_integer_signed_set_value(
enum_container_field, -42) == 0,
"Set signed enumeration container value");
ret = bt_ctf_event_set_payload(simple_event, "enum_field", enum_field);
- assert(!ret);
+ BT_ASSERT(!ret);
BT_PUT(iter);
enum_field_unsigned = bt_ctf_field_create(ep_enum_field_unsigned_type);
- assert(enum_field_unsigned);
+ BT_ASSERT(enum_field_unsigned);
enum_container_field_unsigned = bt_ctf_field_enumeration_get_container(
enum_field_unsigned);
ok(bt_ctf_field_integer_unsigned_set_value(
"Set unsigned enumeration container value");
ret = bt_ctf_event_set_payload(simple_event, "enum_field_unsigned",
enum_field_unsigned);
- assert(!ret);
+ BT_ASSERT(!ret);
ok(bt_ctf_clock_set_time(clock, current_time) == 0, "Set clock time");
/* Populate stream event context */
stream_event_context =
bt_ctf_event_get_stream_event_context(simple_event);
- assert(stream_event_context);
+ BT_ASSERT(stream_event_context);
stream_event_context_field = bt_ctf_field_structure_get_field_by_name(
stream_event_context, "common_event_context");
bt_ctf_field_integer_unsigned_set_value(stream_event_context_field, 42);
}
stream_event_ctx_field = bt_ctf_event_get_stream_event_context(event);
- assert(stream_event_ctx_field);
+ BT_ASSERT(stream_event_ctx_field);
stream_event_ctx_int_field = bt_ctf_field_structure_get_field_by_name(
stream_event_ctx_field, "common_event_context");
BT_PUT(stream_event_ctx_field);
"bt_ctf_field_type_integer_get_encoding returns a correct value");
int_16_type = bt_ctf_field_type_integer_create(16);
- assert(int_16_type);
+ BT_ASSERT(int_16_type);
ok(!bt_ctf_field_type_integer_set_signed(int_16_type, 1),
"Set signedness of 16 bit integer to true");
ok(bt_ctf_field_type_integer_get_signed(int_16_type) == 1,
* appropriate fields.
*/
ep_type = bt_ctf_event_class_get_payload_field_type(event_class);
- assert(ep_type);
+ BT_ASSERT(ep_type);
ep_field_1_type = bt_ctf_field_type_structure_get_field_type_by_name(
ep_type, "field_1");
- assert(ep_field_1_type);
+ BT_ASSERT(ep_field_1_type);
ep_a_string_type = bt_ctf_field_type_structure_get_field_type_by_name(
ep_type, "a_string");
- assert(ep_a_string_type);
+ BT_ASSERT(ep_a_string_type);
event = bt_ctf_event_create(event_class);
ret_field = bt_ctf_event_get_payload(event, 0);
}
ret = bt_ctf_stream_class_set_packet_context_type(stream_class, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_ctf_stream_class_set_event_header_type(stream_class, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ok(bt_ctf_stream_class_get_trace(stream_class) == NULL,
"bt_ctf_stream_class_get_trace returns NULL when stream class is orphaned");
struct bt_ctf_event_class *event_class;
event_class = bt_ctf_event_class_create("Simple Event");
- assert(event_class);
+ BT_ASSERT(event_class);
ok(bt_ctf_stream_class_add_event_class(stream_class, event_class) == 0,
"two event classes with the same name may cohabit within the same stream class");
bt_put(event_class);
event_class = bt_ctf_event_class_create("different name, ok");
- assert(event_class);
- assert(!bt_ctf_event_class_set_id(event_class, 13));
+ BT_ASSERT(event_class);
+ BT_ASSERT(!bt_ctf_event_class_set_id(event_class, 13));
ok(bt_ctf_stream_class_add_event_class(stream_class, event_class),
"two event classes with the same ID cannot cohabit within the same stream class");
bt_put(event_class);
struct bt_ctf_clock *clock = NULL;
clock = bt_ctf_clock_create("water");
- assert(clock);
+ BT_ASSERT(clock);
ret = bt_ctf_clock_set_offset_s(clock, 1234);
- assert(!ret);
+ BT_ASSERT(!ret);
ret = bt_ctf_clock_set_offset(clock, 1000);
- assert(!ret);
+ BT_ASSERT(!ret);
ret = bt_ctf_clock_set_frequency(clock, 1000000000);
- assert(!ret);
+ BT_ASSERT(!ret);
ret = bt_ctf_clock_set_frequency(clock, 1534);
- assert(!ret);
+ BT_ASSERT(!ret);
BT_PUT(clock);
}
/* Test bt_ctf_trace_set_environment_field with an integer object */
obj = bt_value_integer_create_init(23);
- assert(obj);
+ BT_ASSERT(obj);
ok(bt_ctf_trace_set_environment_field(NULL, "test_env_int_obj", obj),
"bt_ctf_trace_set_environment_field handles a NULL trace correctly");
ok(bt_ctf_trace_set_environment_field(trace, NULL, obj),
/* Test bt_ctf_trace_set_environment_field with a string object */
obj = bt_value_string_create_init("the value");
- assert(obj);
+ BT_ASSERT(obj);
ok(!bt_ctf_trace_set_environment_field(trace, "test_env_str_obj", obj),
"bt_ctf_trace_set_environment_field succeeds in adding a string object");
BT_PUT(obj);
/* Instantiate a stream and append events */
ret = bt_ctf_writer_add_clock(writer, clock);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ok(bt_ctf_trace_get_stream_count(trace) == 0,
"bt_ctf_trace_get_stream_count() succeeds and returns the correct value (0)");
BT_PUT(packet_context_type);
BT_PUT(stream_event_context_type);
packet_header_type = bt_ctf_trace_get_packet_header_field_type(trace);
- assert(packet_header_type);
+ BT_ASSERT(packet_header_type);
packet_context_type =
bt_ctf_stream_class_get_packet_context_type(stream_class);
- assert(packet_context_type);
+ BT_ASSERT(packet_context_type);
stream_event_context_type =
bt_ctf_stream_class_get_event_context_type(stream_class);
- assert(stream_event_context_type);
+ BT_ASSERT(stream_event_context_type);
/*
* Try to modify the packet context type after a stream has been
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include <glib.h>
#include "tap/tap.h"
case TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED:
ret = bt_private_component_source_add_output_private_port(
private_component, "hello", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
break;
default:
break;
switch (current_test) {
case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT:
ret = bt_private_port_remove_from_component(private_port);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
default:
break;
}
ret = bt_private_component_source_add_output_private_port(
priv_comp, "out", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
return BT_COMPONENT_STATUS_OK;
}
case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT:
def_port = bt_private_component_sink_get_input_private_port_by_name(
priv_component, "in");
- assert(def_port);
+ BT_ASSERT(def_port);
ret = bt_private_port_remove_from_component(def_port);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(def_port);
break;
default:
ret = bt_private_component_sink_add_input_private_port(priv_comp,
"in", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
return BT_COMPONENT_STATUS_OK;
}
{
struct bt_component *comp = bt_port_get_component(port);
- assert(comp);
+ BT_ASSERT(comp);
bt_put(comp);
struct event event = {
bt_port_get_component(downstream_port);
struct bt_connection *conn = bt_port_get_connection(upstream_port);
- assert(upstream_comp);
- assert(downstream_comp);
- assert(conn);
+ BT_ASSERT(upstream_comp);
+ BT_ASSERT(downstream_comp);
+ BT_ASSERT(conn);
bt_put(upstream_comp);
bt_put(downstream_comp);
bt_put(conn);
int ret;
src_comp_class = bt_component_class_source_create("src", src_iter_next);
- assert(src_comp_class);
+ BT_ASSERT(src_comp_class);
ret = bt_component_class_set_init_method(src_comp_class, src_init);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_set_accept_port_connection_method(
src_comp_class, accept_port_connection);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_set_port_connected_method(src_comp_class,
src_port_connected);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_set_port_disconnected_method(
src_comp_class, src_port_disconnected);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
sink_comp_class = bt_component_class_sink_create("sink", sink_consume);
- assert(sink_comp_class);
+ BT_ASSERT(sink_comp_class);
ret = bt_component_class_set_init_method(sink_comp_class, sink_init);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_set_accept_port_connection_method(
sink_comp_class, accept_port_connection);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_set_port_connected_method(sink_comp_class,
sink_port_connected);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_set_port_disconnected_method(sink_comp_class,
sink_port_disconnected);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_component_class_freeze(src_comp_class);
bt_component_class_freeze(sink_comp_class);
events = g_array_new(FALSE, TRUE, sizeof(struct event));
- assert(events);
+ BT_ASSERT(events);
}
static
ret = bt_graph_add_component(graph, src_comp_class, "src-comp", NULL,
&comp);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
return comp;
}
ret = bt_graph_add_component(graph, sink_comp_class, "sink-comp",
NULL, &comp);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
return comp;
}
struct bt_graph *graph = bt_graph_create();
int ret;
- assert(graph);
+ BT_ASSERT(graph);
ret = bt_graph_add_port_added_listener(graph, graph_port_added, NULL,
NULL);
- assert(ret >= 0);
+ BT_ASSERT(ret >= 0);
ret = bt_graph_add_port_removed_listener(graph, graph_port_removed,
NULL, NULL);
- assert(ret >= 0);
+ BT_ASSERT(ret >= 0);
ret = bt_graph_add_ports_connected_listener(graph,
graph_ports_connected, NULL, NULL);
- assert(ret >= 0);
+ BT_ASSERT(ret >= 0);
ret = bt_graph_add_ports_disconnected_listener(graph,
graph_ports_disconnected, NULL, NULL);
- assert(ret >= 0);
+ BT_ASSERT(ret >= 0);
return graph;
}
prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT,
"sink removes port in consume, then source removes disconnected port");
graph = create_graph();
- assert(graph);
+ BT_ASSERT(graph);
src = create_src(graph);
sink = create_sink(graph);
src_def_port = bt_component_source_get_output_port_by_name(src, "out");
- assert(src_def_port);
+ BT_ASSERT(src_def_port);
sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in");
- assert(sink_def_port);
+ BT_ASSERT(sink_def_port);
status = bt_graph_connect_ports(graph, src_def_port, sink_def_port,
&conn);
- assert(status == 0);
- assert(conn);
+ BT_ASSERT(status == 0);
+ BT_ASSERT(conn);
/* We're supposed to have 7 events so far */
ok(events->len == 7, "we have the expected number of events (before consume)");
/* Consume sink once */
clear_events();
ret = bt_graph_consume(graph);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
/* We're supposed to have 5 new events */
ok(events->len == 5, "we have the expected number of events (after consume)");
prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME,
"sink removes port in consume");
graph = create_graph();
- assert(graph);
+ BT_ASSERT(graph);
src = create_src(graph);
sink = create_sink(graph);
src_def_port = bt_component_source_get_output_port_by_name(src, "out");
- assert(src_def_port);
+ BT_ASSERT(src_def_port);
sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in");
- assert(sink_def_port);
+ BT_ASSERT(sink_def_port);
status = bt_graph_connect_ports(graph, src_def_port, sink_def_port,
&conn);
- assert(status == 0);
+ BT_ASSERT(status == 0);
/* We're supposed to have 7 events so far */
ok(events->len == 7, "we have the expected number of events (before consume)");
/* Consume sink once */
clear_events();
ret = bt_graph_consume(graph);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
/* We're supposed to have 4 new events */
ok(events->len == 4, "we have the expected number of events (after consume)");
prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED,
"source adds port in port connected");
graph = create_graph();
- assert(graph);
+ BT_ASSERT(graph);
src = create_src(graph);
sink = create_sink(graph);
src_def_port = bt_component_source_get_output_port_by_name(src, "out");
- assert(src_def_port);
+ BT_ASSERT(src_def_port);
sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in");
- assert(sink_def_port);
+ BT_ASSERT(sink_def_port);
status = bt_graph_connect_ports(graph, src_def_port, sink_def_port,
&conn);
- assert(status == 0);
+ BT_ASSERT(status == 0);
src_hello_port = bt_component_source_get_output_port_by_name(src,
"hello");
- assert(src_hello_port);
+ BT_ASSERT(src_hello_port);
/* We're supposed to have 8 events */
ok(events->len == 8, "we have the expected number of events");
prepare_test(TEST_SIMPLE, "simple");
graph = create_graph();
- assert(graph);
+ BT_ASSERT(graph);
src = create_src(graph);
sink = create_sink(graph);
src_def_port = bt_component_source_get_output_port_by_name(src, "out");
- assert(src_def_port);
+ BT_ASSERT(src_def_port);
sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in");
- assert(sink_def_port);
+ BT_ASSERT(sink_def_port);
status = bt_graph_connect_ports(graph, src_def_port, sink_def_port,
&conn);
- assert(status == 0);
+ BT_ASSERT(status == 0);
/* We're supposed to have 7 events */
ok(events->len == 7, "we have the expected number of events");
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#define NR_TESTS 13
int ret;
packet_context_type = bt_field_type_structure_create();
- assert(packet_context_type);
+ BT_ASSERT(packet_context_type);
ft = bt_field_type_integer_create(32);
- assert(ft);
+ BT_ASSERT(ft);
ret = bt_field_type_structure_add_field(packet_context_type,
ft, "packet_size");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(ft);
ft = bt_field_type_integer_create(32);
- assert(ft);
+ BT_ASSERT(ft);
ret = bt_field_type_structure_add_field(packet_context_type,
ft, "content_size");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(ft);
event_header_type = bt_field_type_structure_create();
- assert(event_header_type);
+ BT_ASSERT(event_header_type);
ft = bt_field_type_integer_create(32);
- assert(ft);
+ BT_ASSERT(ft);
ret = bt_field_type_structure_add_field(event_header_type,
ft, "id");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(ft);
ret = bt_stream_class_set_packet_context_field_type(stream_class,
packet_context_type);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_set_event_header_field_type(stream_class,
event_header_type);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(packet_context_type);
bt_put(event_header_type);
int ret;
packet_header_type = bt_field_type_structure_create();
- assert(packet_header_type);
+ BT_ASSERT(packet_header_type);
ft = bt_field_type_integer_create(32);
- assert(ft);
+ BT_ASSERT(ft);
ret = bt_field_type_structure_add_field(packet_header_type,
ft, "stream_id");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(ft);
ret = bt_trace_set_packet_header_field_type(trace,
packet_header_type);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(packet_header_type);
}
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include <glib.h>
#include "tap/tap.h"
#include "common.h"
struct bt_plugin *plugin;
char *minimal_path = get_test_plugin_path(plugin_dir, "minimal");
- assert(minimal_path);
+ BT_ASSERT(minimal_path);
diag("minimal plugin test below");
reset_test_plugin_env_vars();
struct bt_query_executor *query_exec = bt_query_executor_create();
int ret;
- assert(query_exec);
- assert(sfs_path);
+ BT_ASSERT(query_exec);
+ BT_ASSERT(sfs_path);
diag("sfs plugin test below");
plugin_set = bt_plugin_create_all_from_file(sfs_path);
- assert(plugin_set && bt_plugin_set_get_plugin_count(plugin_set) == 1);
+ BT_ASSERT(plugin_set && bt_plugin_set_get_plugin_count(plugin_set) == 1);
plugin = bt_plugin_set_get_plugin(plugin_set, 0);
ok(bt_plugin_get_version(plugin, &major, &minor, &patch, &extra) ==
BT_PLUGIN_STATUS_OK,
BT_COMPONENT_CLASS_TYPE_SOURCE),
"bt_plugin_get_component_class_by_name_and_type() does not find a component class given the wrong type");
params = bt_value_integer_create_init(23);
- assert(params);
+ BT_ASSERT(params);
ret = bt_query_executor_query(NULL, filter_comp_class, "object",
params, &results);
ok (ret, "bt_query_executor_query() handles NULL (query executor)");
ret = bt_query_executor_query(query_exec, filter_comp_class,
"get-something", params, &results);
ok(ret == 0 && results, "bt_query_executor_query() succeeds");
- assert(bt_value_is_array(results) && bt_value_array_size(results) == 2);
+ BT_ASSERT(bt_value_is_array(results) && bt_value_array_size(results) == 2);
object = bt_value_array_get(results, 0);
- assert(object && bt_value_is_string(object));
+ BT_ASSERT(object && bt_value_is_string(object));
value_ret = bt_value_string_get(object, &object_str);
- assert(value_ret == BT_VALUE_STATUS_OK);
+ BT_ASSERT(value_ret == BT_VALUE_STATUS_OK);
ok(strcmp(object_str, "get-something") == 0,
"bt_component_class_query() receives the expected object name");
res_params = bt_value_array_get(results, 1);
diag("> putting the plugin object here");
BT_PUT(plugin);
graph = bt_graph_create();
- assert(graph);
+ BT_ASSERT(graph);
graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink",
NULL, &sink_component);
ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component,
BT_PUT(source_comp_class);
bt_put(graph);
graph = bt_graph_create();
- assert(graph);
+ BT_ASSERT(graph);
graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink",
NULL, &sink_component);
ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component,
BT_PUT(filter_comp_class);
bt_put(graph);
graph = bt_graph_create();
- assert(graph);
+ BT_ASSERT(graph);
graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink",
NULL, &sink_component);
ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component,
"8db46494-a398-466a-9649-c765ae077629"
G_SEARCHPATH_SEPARATOR_S,
NON_EXISTING_PATH, plugin_dir);
- assert(ret > 0 && plugin_path);
+ BT_ASSERT(ret > 0 && plugin_path);
g_setenv("BABELTRACE_PLUGIN_PATH", plugin_path, 1);
plugin = bt_plugin_find("test_minimal");
ok(plugin,
#include <stdbool.h>
#include <inttypes.h>
#include <string.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include <babeltrace/babeltrace.h>
#include <glib.h>
const struct test_event *expected_event = expected_events;
size_t i = 0;
- assert(expected_events);
+ BT_ASSERT(expected_events);
while (true) {
const struct test_event *event;
/* Test events */
test_events = g_array_new(FALSE, TRUE, sizeof(struct test_event));
- assert(test_events);
+ BT_ASSERT(test_events);
/* Metadata */
empty_struct_ft = bt_field_type_structure_create();
- assert(empty_struct_ft);
+ BT_ASSERT(empty_struct_ft);
src_clock_class = bt_clock_class_create("my-clock", 1000000000);
- assert(src_clock_class);
+ BT_ASSERT(src_clock_class);
trace = bt_trace_create();
- assert(trace);
+ BT_ASSERT(trace);
ret = bt_trace_set_native_byte_order(trace,
BT_BYTE_ORDER_LITTLE_ENDIAN);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_trace_set_packet_header_field_type(trace, empty_struct_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_clock_class_set_is_absolute(src_clock_class, 1);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_trace_add_clock_class(trace, src_clock_class);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
src_empty_cc_prio_map = bt_clock_class_priority_map_create();
- assert(src_empty_cc_prio_map);
+ BT_ASSERT(src_empty_cc_prio_map);
src_cc_prio_map = bt_clock_class_priority_map_create();
- assert(src_cc_prio_map);
+ BT_ASSERT(src_cc_prio_map);
ret = bt_clock_class_priority_map_add_clock_class(src_cc_prio_map,
src_clock_class, 0);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
src_stream_class = bt_stream_class_create("my-stream-class");
- assert(src_stream_class);
+ BT_ASSERT(src_stream_class);
ret = bt_stream_class_set_packet_context_field_type(src_stream_class,
empty_struct_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
eh_ft = bt_field_type_structure_create();
- assert(eh_ft);
+ BT_ASSERT(eh_ft);
eh_ts_ft = bt_field_type_integer_create(64);
- assert(eh_ts_ft);
+ BT_ASSERT(eh_ts_ft);
ret = bt_field_type_structure_add_field(eh_ft, eh_ts_ft, "ts");
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_field_type_integer_set_mapped_clock_class(eh_ts_ft,
src_clock_class);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_set_event_header_field_type(src_stream_class,
eh_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_set_event_context_field_type(src_stream_class,
empty_struct_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
src_event_class = bt_event_class_create("my-event-class");
ret = bt_event_class_set_context_field_type(src_event_class,
empty_struct_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_event_class_set_context_field_type(src_event_class,
empty_struct_ft);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_stream_class_add_event_class(src_stream_class,
src_event_class);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_trace_add_stream_class(trace, src_stream_class);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
stream = bt_stream_create(src_stream_class, "stream0", 0);
- assert(stream);
+ BT_ASSERT(stream);
src_packet0 = bt_packet_create(stream);
- assert(src_packet0);
+ BT_ASSERT(src_packet0);
bt_put(stream);
stream = bt_stream_create(src_stream_class, "stream1", 1);
- assert(stream);
+ BT_ASSERT(stream);
src_packet1 = bt_packet_create(stream);
- assert(src_packet0);
+ BT_ASSERT(src_packet0);
bt_put(stream);
stream = bt_stream_create(src_stream_class, "stream2", 2);
- assert(stream);
+ BT_ASSERT(stream);
src_packet2 = bt_packet_create(stream);
- assert(src_packet0);
+ BT_ASSERT(src_packet0);
bt_put(stream);
stream = bt_stream_create(src_stream_class, "stream3", 3);
- assert(stream);
+ BT_ASSERT(stream);
src_packet3 = bt_packet_create(stream);
- assert(src_packet0);
+ BT_ASSERT(src_packet0);
bt_put(stream);
bt_put(trace);
const char *port_name;
int ret;
- assert(user_data);
- assert(port);
+ BT_ASSERT(user_data);
+ BT_ASSERT(port);
ret = bt_private_connection_private_notification_iterator_set_user_data(priv_notif_iter,
user_data);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
port_name = bt_port_get_name(port);
- assert(port_name);
+ BT_ASSERT(port_name);
user_data->iter_index = port_name[3] - '0';
switch (user_data->iter_index) {
notif = bt_notification_event_create(graph, src_event_class,
packet, cc_prio_map);
- assert(notif);
+ BT_ASSERT(notif);
event = bt_notification_event_borrow_event(notif);
- assert(event);
+ BT_ASSERT(event);
field = bt_event_borrow_header(event);
- assert(field);
+ BT_ASSERT(field);
field = bt_field_structure_borrow_field_by_name(field, "ts");
- assert(field);
+ BT_ASSERT(field);
ret = bt_field_integer_unsigned_set_value(field, (uint64_t) ts_ns);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
clock_value = bt_event_borrow_clock_value(event, src_clock_class);
- assert(clock_value);
+ BT_ASSERT(clock_value);
ret = bt_clock_value_set_value(clock_value, (uint64_t) ts_ns);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
return notif;
}
int64_t cur_ts_ns;
struct bt_stream *stream;
- assert(user_data->seq);
+ BT_ASSERT(user_data->seq);
cur_ts_ns = user_data->seq[user_data->at];
switch (cur_ts_ns) {
next_return.notification =
bt_notification_packet_begin_create(graph,
user_data->packet);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_PACKET_END:
next_return.notification =
bt_notification_packet_end_create(graph,
user_data->packet);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
case SEQ_STREAM_BEGIN:
stream = bt_packet_get_stream(user_data->packet);
next_return.notification =
bt_notification_stream_begin_create(graph, stream);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
bt_put(stream);
break;
case SEQ_STREAM_END:
stream = bt_packet_get_stream(user_data->packet);
next_return.notification =
bt_notification_stream_end_create(graph, stream);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
bt_put(stream);
break;
default:
{
next_return.notification = src_create_event_notif(
user_data->packet, src_cc_prio_map, cur_ts_ns);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
break;
}
}
struct bt_stream *stream;
int ret;
- assert(user_data);
- assert(private_component);
+ BT_ASSERT(user_data);
+ BT_ASSERT(private_component);
switch (current_test) {
case TEST_NO_TS:
bt_notification_stream_begin_create(
graph, stream);
bt_put(stream);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
} else if (user_data->at == 1) {
next_return.notification =
bt_notification_packet_begin_create(
graph, user_data->packet);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
} else if (user_data->at < 7) {
next_return.notification =
src_create_event_notif(
user_data->packet,
src_empty_cc_prio_map, 0);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
} else if (user_data->at == 7) {
next_return.notification =
bt_notification_packet_end_create(
graph, user_data->packet);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
} else if (user_data->at == 8) {
stream = bt_packet_get_stream(user_data->packet);
next_return.notification =
bt_notification_stream_end_create(
graph, stream);
bt_put(stream);
- assert(next_return.notification);
+ BT_ASSERT(next_return.notification);
} else {
next_return.status =
BT_NOTIFICATION_ITERATOR_STATUS_END;
if (user_data->iter_index == 0) {
ret = bt_private_component_source_add_output_private_port(
private_component, "out1", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_private_component_source_add_output_private_port(
private_component, "out2", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
next_return.status = BT_NOTIFICATION_ITERATOR_STATUS_END;
} else {
next_return = src_iter_next_seq(user_data);
} else {
ret = bt_private_component_source_add_output_private_port(
private_component, "out1", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_private_component_source_add_output_private_port(
private_component, "out2", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
next_return.status = BT_NOTIFICATION_ITERATOR_STATUS_END;
}
} else {
if (nb_ports >= 1) {
ret = bt_private_component_source_add_output_private_port(
private_component, "out0", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
}
if (nb_ports >= 2) {
ret = bt_private_component_source_add_output_private_port(
private_component, "out1", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
}
if (nb_ports >= 3) {
ret = bt_private_component_source_add_output_private_port(
private_component, "out2", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
}
if (nb_ports >= 4) {
ret = bt_private_component_source_add_output_private_port(
private_component, "out3", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
}
return BT_COMPONENT_STATUS_OK;
struct test_event test_event;
bool do_append_test_event = true;
- assert(user_data && user_data->notif_iter);
+ BT_ASSERT(user_data && user_data->notif_iter);
it_ret = bt_notification_iterator_next(user_data->notif_iter);
if (it_ret < 0) {
notification = bt_notification_iterator_get_notification(
user_data->notif_iter);
- assert(notification);
+ BT_ASSERT(notification);
switch (bt_notification_get_type(notification)) {
case BT_NOTIFICATION_TYPE_EVENT:
cc_prio_map =
bt_notification_event_borrow_clock_class_priority_map(
notification);
- assert(cc_prio_map);
+ BT_ASSERT(cc_prio_map);
event = bt_notification_event_borrow_event(notification);
- assert(event);
+ BT_ASSERT(event);
if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map) > 0) {
struct bt_clock_value *clock_value;
bt_clock_class_priority_map_borrow_highest_priority_clock_class(
cc_prio_map);
- assert(clock_class);
+ BT_ASSERT(clock_class);
clock_value = bt_event_borrow_clock_value(event,
clock_class);
- assert(clock_value);
+ BT_ASSERT(clock_value);
ret = bt_clock_value_get_value_ns_from_epoch(
clock_value, &test_event.ts_ns);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
} else {
test_event.ts_ns = -1;
}
test_event.type = TEST_EV_TYPE_NOTIF_INACTIVITY;
cc_prio_map = bt_notification_inactivity_borrow_clock_class_priority_map(
notification);
- assert(cc_prio_map);
+ BT_ASSERT(cc_prio_map);
if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map) > 0) {
struct bt_clock_value *clock_value;
bt_clock_class_priority_map_borrow_highest_priority_clock_class(
cc_prio_map);
- assert(clock_class);
+ BT_ASSERT(clock_class);
clock_value =
bt_notification_inactivity_borrow_clock_value(
notification, clock_class);
- assert(clock_value);
+ BT_ASSERT(clock_value);
ret = bt_clock_value_get_value_ns_from_epoch(
clock_value, &test_event.ts_ns);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
} else {
test_event.ts_ns = -1;
}
private_component);
enum bt_connection_status conn_status;
- assert(user_data);
- assert(priv_conn);
+ BT_ASSERT(user_data);
+ BT_ASSERT(priv_conn);
conn_status = bt_private_connection_create_notification_iterator(
priv_conn, &user_data->notif_iter);
- assert(conn_status == 0);
+ BT_ASSERT(conn_status == 0);
bt_put(priv_conn);
}
struct sink_user_data *user_data = g_new0(struct sink_user_data, 1);
int ret;
- assert(user_data);
+ BT_ASSERT(user_data);
ret = bt_private_component_set_user_data(private_component,
user_data);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_private_component_sink_add_input_private_port(
private_component, "in", NULL, NULL);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
return BT_COMPONENT_STATUS_OK;
}
/* Create source component */
src_comp_class = bt_component_class_source_create("src", src_iter_next);
- assert(src_comp_class);
+ BT_ASSERT(src_comp_class);
ret = bt_component_class_set_init_method(src_comp_class, src_init);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_set_finalize_method(src_comp_class,
src_finalize);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_source_set_notification_iterator_init_method(
src_comp_class, src_iter_init);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_source_set_notification_iterator_finalize_method(
src_comp_class, src_iter_finalize);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_graph_add_component(graph, src_comp_class, "source", NULL, source);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
/* Create muxer component */
muxer_comp_class = bt_plugin_find_component_class("utils", "muxer",
BT_COMPONENT_CLASS_TYPE_FILTER);
- assert(muxer_comp_class);
+ BT_ASSERT(muxer_comp_class);
ret = bt_graph_add_component(graph, muxer_comp_class, "muxer", NULL, muxer);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
/* Create sink component */
sink_comp_class = bt_component_class_sink_create("sink", sink_consume);
- assert(sink_comp_class);
+ BT_ASSERT(sink_comp_class);
ret = bt_component_class_set_init_method(sink_comp_class, sink_init);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_component_class_set_finalize_method(sink_comp_class,
sink_finalize);
ret = bt_component_class_set_port_connected_method(sink_comp_class,
sink_port_connected);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
ret = bt_graph_add_component(graph, sink_comp_class, "sink", NULL, sink);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(src_comp_class);
bt_put(muxer_comp_class);
clear_test_events();
current_test = test;
diag("test: %s", name);
- assert(!graph);
+ BT_ASSERT(!graph);
graph = bt_graph_create();
- assert(graph);
+ BT_ASSERT(graph);
create_source_muxer_sink(graph, &src_comp, &muxer_comp, &sink_comp);
/* Connect source output ports to muxer input ports */
if (with_upstream) {
count = bt_component_source_get_output_port_count(src_comp);
- assert(count >= 0);
+ BT_ASSERT(count >= 0);
for (i = 0; i < count; i++) {
upstream_port = bt_component_source_get_output_port_by_index(
src_comp, i);
- assert(upstream_port);
+ BT_ASSERT(upstream_port);
downstream_port = bt_component_filter_get_input_port_by_index(
muxer_comp, i);
- assert(downstream_port);
+ BT_ASSERT(downstream_port);
graph_status = bt_graph_connect_ports(graph,
upstream_port, downstream_port, NULL);
- assert(graph_status == 0);
+ BT_ASSERT(graph_status == 0);
bt_put(upstream_port);
bt_put(downstream_port);
}
/* Connect muxer output port to sink input port */
upstream_port = bt_component_filter_get_output_port_by_name(muxer_comp,
"out");
- assert(upstream_port);
+ BT_ASSERT(upstream_port);
downstream_port = bt_component_sink_get_input_port_by_name(sink_comp, "in");
- assert(downstream_port);
+ BT_ASSERT(downstream_port);
graph_status = bt_graph_connect_ports(graph, upstream_port,
downstream_port, NULL);
- assert(graph_status == 0);
+ BT_ASSERT(graph_status == 0);
bt_put(upstream_port);
bt_put(downstream_port);
enum bt_graph_status graph_status;
count = bt_component_filter_get_input_port_count(muxer_comp);
- assert(count >= 0);
+ BT_ASSERT(count >= 0);
for (i = 0; i < count; i++) {
struct bt_port *muxer_port =
bt_component_filter_get_input_port_by_index(
muxer_comp, i);
- assert(muxer_port);
+ BT_ASSERT(muxer_port);
if (!bt_port_is_connected(muxer_port)) {
BT_MOVE(avail_muxer_port, muxer_port);
graph_status = bt_graph_connect_ports(graph, source_port,
avail_muxer_port, NULL);
- assert(graph_status == 0);
+ BT_ASSERT(graph_status == 0);
bt_put(avail_muxer_port);
}
struct bt_component *comp;
comp = bt_port_get_component(port);
- assert(comp);
+ BT_ASSERT(comp);
if (comp != graph_listener_data->source) {
goto end;
clear_test_events();
current_test = TEST_SINGLE_END_THEN_MULTIPLE_FULL;
diag("test: single end then multiple full");
- assert(!graph);
+ BT_ASSERT(!graph);
graph = bt_graph_create();
- assert(graph);
+ BT_ASSERT(graph);
create_source_muxer_sink(graph, &src_comp, &muxer_comp, &sink_comp);
graph_listener_data.graph = graph;
graph_listener_data.source = src_comp;
ret = bt_graph_add_port_added_listener(graph,
graph_port_added_listener_connect_to_avail_muxer_port, NULL,
&graph_listener_data);
- assert(ret >= 0);
+ BT_ASSERT(ret >= 0);
/* Connect source output ports to muxer input ports */
count = bt_component_source_get_output_port_count(src_comp);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
for (i = 0; i < count; i++) {
upstream_port = bt_component_source_get_output_port_by_index(
src_comp, i);
- assert(upstream_port);
+ BT_ASSERT(upstream_port);
connect_port_to_first_avail_muxer_port(graph,
upstream_port, muxer_comp);
bt_put(upstream_port);
/* Connect muxer output port to sink input port */
upstream_port = bt_component_filter_get_output_port_by_name(muxer_comp,
"out");
- assert(upstream_port);
+ BT_ASSERT(upstream_port);
downstream_port = bt_component_sink_get_input_port_by_name(sink_comp, "in");
- assert(downstream_port);
+ BT_ASSERT(downstream_port);
graph_status = bt_graph_connect_ports(graph, upstream_port,
downstream_port, NULL);
- assert(graph_status == 0);
+ BT_ASSERT(graph_status == 0);
bt_put(upstream_port);
bt_put(downstream_port);
clear_test_events();
current_test = TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL;
diag("test: single again then end then multiple full");
- assert(!graph);
+ BT_ASSERT(!graph);
graph = bt_graph_create();
- assert(graph);
+ BT_ASSERT(graph);
create_source_muxer_sink(graph, &src_comp, &muxer_comp, &sink_comp);
graph_listener_data.graph = graph;
graph_listener_data.source = src_comp;
ret = bt_graph_add_port_added_listener(graph,
graph_port_added_listener_connect_to_avail_muxer_port, NULL,
&graph_listener_data);
- assert(ret >= 0);
+ BT_ASSERT(ret >= 0);
/* Connect source output ports to muxer input ports */
count = bt_component_source_get_output_port_count(src_comp);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
for (i = 0; i < count; i++) {
upstream_port = bt_component_source_get_output_port_by_index(
src_comp, i);
- assert(upstream_port);
+ BT_ASSERT(upstream_port);
connect_port_to_first_avail_muxer_port(graph,
upstream_port, muxer_comp);
bt_put(upstream_port);
/* Connect muxer output port to sink input port */
upstream_port = bt_component_filter_get_output_port_by_name(muxer_comp,
"out");
- assert(upstream_port);
+ BT_ASSERT(upstream_port);
downstream_port = bt_component_sink_get_input_port_by_name(sink_comp, "in");
- assert(downstream_port);
+ BT_ASSERT(downstream_port);
graph_status = bt_graph_connect_ports(graph, upstream_port,
downstream_port, NULL);
- assert(graph_status == 0);
+ BT_ASSERT(graph_status == 0);
bt_put(upstream_port);
bt_put(downstream_port);
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include <string.h>
#include <limits.h>
{
size_t len, i, line_start_idx = 0;
- assert(val);
+ BT_ASSERT(val);
len = strlen(val);
for (i = 0; i < len; i++) {
continue;
}
- assert((i - line_start_idx + 1) <= INT_MAX);
+ BT_ASSERT((i - line_start_idx + 1) <= INT_MAX);
line_length = i - line_start_idx + 1;
fprintf(stderr, "# %.*s", line_length, &val[line_start_idx]);
line_start_idx = i + 1;
projects / babeltrace.git / commitdiff
