#include "logging.h"
#include <babeltrace/babeltrace.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include "ctfcopytrace.h"
#include "clock-fields.h"
const char *name, *description;
struct bt_clock_class *writer_clock_class = NULL;
- assert(err && clock_class);
+ BT_ASSERT(err && clock_class);
name = bt_clock_class_get_name(clock_class);
- assert(name);
+ BT_ASSERT(name);
writer_clock_class = bt_clock_class_create(name,
bt_clock_class_get_frequency(clock_class));
if (description) {
int_ret = bt_clock_class_set_description(writer_clock_class,
description);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
}
u64_ret = bt_clock_class_get_precision(clock_class);
- assert(u64_ret != -1ULL);
+ BT_ASSERT(u64_ret != -1ULL);
int_ret = bt_clock_class_set_precision(writer_clock_class,
u64_ret);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
int_ret = bt_clock_class_get_offset_s(clock_class, &offset_s);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
int_ret = bt_clock_class_set_offset_s(writer_clock_class, offset_s);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
int_ret = bt_clock_class_get_offset_cycles(clock_class, &offset);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
int_ret = bt_clock_class_set_offset_cycles(writer_clock_class, offset);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
int_ret = bt_clock_class_is_absolute(clock_class);
- assert(int_ret >= 0);
+ BT_ASSERT(int_ret >= 0);
int_ret = bt_clock_class_set_is_absolute(writer_clock_class, int_ret);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
end:
return writer_clock_class;
struct bt_clock_class *clock_class =
bt_trace_get_clock_class_by_index(trace, i);
- assert(clock_class);
+ BT_ASSERT(clock_class);
writer_clock_class = ctf_copy_clock_class(err, clock_class);
bt_put(clock_class);
{
int ret;
- assert(trace_copy);
- assert(field_type);
+ BT_ASSERT(trace_copy);
+ BT_ASSERT(field_type);
switch (bt_field_type_get_type_id(field_type)) {
case BT_FIELD_TYPE_ID_INTEGER:
}
name = bt_clock_class_get_name(mapped_clock_class);
- assert(name);
+ BT_ASSERT(name);
clock_class_copy = bt_trace_get_clock_class_by_name(
trace_copy, name);
- assert(clock_class_copy);
+ BT_ASSERT(clock_class_copy);
ret = bt_field_type_integer_set_mapped_clock_class(
field_type, clock_class_copy);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
bt_put(mapped_clock_class);
bt_put(clock_class_copy);
break;
abort();
}
- assert(subtype);
+ BT_ASSERT(subtype);
replace_clock_classes(trace_copy, subtype);
bt_put(subtype);
break;
ret = bt_field_type_structure_get_field_by_index(
field_type, &name, &member_type, i);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
replace_clock_classes(trace_copy, member_type);
bt_put(member_type);
}
ret = bt_field_type_variant_get_field_by_index(
field_type, &name, &member_type, i);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
replace_clock_classes(trace_copy, member_type);
bt_put(member_type);
}
name = bt_event_class_get_name(event_class);
writer_event_class = bt_event_class_create(name);
- assert(writer_event_class);
+ BT_ASSERT(writer_event_class);
id = bt_event_class_get_id(event_class);
- assert(id >= 0);
+ BT_ASSERT(id >= 0);
ret = bt_event_class_set_id(writer_event_class, id);
if (ret) {
struct bt_trace *writer_trace =
bt_stream_class_get_trace(writer_stream_class);
- assert(writer_trace);
+ BT_ASSERT(writer_trace);
count = bt_stream_class_get_event_class_count(stream_class);
- assert(count >= 0);
+ BT_ASSERT(count >= 0);
for (i = 0; i < count; i++) {
int int_ret;
event_class = bt_stream_class_get_event_class_by_index(
stream_class, i);
- assert(event_class);
+ BT_ASSERT(event_class);
if (i < bt_stream_class_get_event_class_count(writer_stream_class)) {
writer_event_class = bt_stream_class_get_event_class_by_index(
const char *name = bt_stream_class_get_name(stream_class);
writer_stream_class = bt_stream_class_create_empty(name);
- assert(writer_stream_class);
+ BT_ASSERT(writer_stream_class);
type = bt_stream_class_get_packet_context_type(stream_class);
if (type) {
}
ret_int = bt_trace_get_clock_class_count(writer_trace);
- assert(ret_int >= 0);
+ BT_ASSERT(ret_int >= 0);
if (override_ts64 && ret_int > 0) {
struct bt_field_type *new_event_header_type;
clock_value = bt_event_get_clock_value(event, clock_class);
BT_PUT(clock_class);
- assert(clock_value);
+ BT_ASSERT(clock_value);
ret = bt_clock_value_get_value(clock_value, &value);
BT_PUT(clock_value);
struct bt_stream_class *stream_class = NULL;
stream_class = bt_event_class_get_stream_class(event_class);
- assert(stream_class);
+ BT_ASSERT(stream_class);
trace = bt_stream_class_get_trace(stream_class);
- assert(trace);
+ BT_ASSERT(trace);
bt_put(stream_class);
return trace;
* is.
*/
ret = bt_trace_get_clock_class_count(writer_trace);
- assert(ret >= 0);
+ BT_ASSERT(ret >= 0);
if (override_ts64 && ret > 0) {
copy_field = bt_event_get_header(writer_event);
- assert(copy_field);
+ BT_ASSERT(copy_field);
ret = copy_override_field(err, event, writer_event, field,
copy_field);
name = bt_trace_get_environment_field_name_by_index(
trace, i);
- assert(name);
+ BT_ASSERT(name);
value = bt_trace_get_environment_field_value_by_index(
trace, i);
- assert(value);
+ BT_ASSERT(value);
ret_int = bt_trace_set_environment_field(writer_trace,
name, value);
}
order = bt_trace_get_native_byte_order(trace);
- assert(order != BT_BYTE_ORDER_UNKNOWN);
+ BT_ASSERT(order != BT_BYTE_ORDER_UNKNOWN);
/*
* Only explicitly set the writer trace's native byte order if