#define DEFAULT_CLOCK_IS_ABSOLUTE 0
#define DEFAULT_CLOCK_TIME 0
-#define NR_TESTS 597
+#define NR_TESTS 594
static int64_t current_time = 42;
bt_ctf_field_type_enumeration_create(uint_12_type);
struct bt_ctf_field_type *event_context_type =
bt_ctf_field_type_structure_create();
+ struct bt_ctf_field_type *event_payload_type = NULL;
struct bt_ctf_field_type *returned_type;
struct bt_ctf_event *simple_event;
struct bt_ctf_field *integer_field;
struct bt_ctf_field *stream_event_context_field;
struct bt_ctf_field *event_context;
struct bt_ctf_field *event_context_field;
+ struct bt_ctf_field_type *ep_integer_field_type = NULL;
+ struct bt_ctf_field_type *ep_enum_field_type = NULL;
+ struct bt_ctf_field_type *ep_enum_field_unsigned_type = NULL;
int ret;
ok(uint_12_type, "Create an unsigned integer type");
bt_ctf_stream_class_add_event_class(stream_class, simple_event_class);
+ /*
+ * bt_ctf_stream_class_add_event_class() copies the field types
+ * of simple_event_class, so we retrieve the new ones to create
+ * the appropriate fields.
+ */
+ BT_PUT(event_context_type);
+ BT_PUT(event_payload_type);
+ event_payload_type = bt_ctf_event_class_get_payload_type(
+ simple_event_class);
+ assert(event_payload_type);
+ event_context_type = bt_ctf_event_class_get_context_type(
+ simple_event_class);
+ 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);
+ ep_enum_field_type =
+ bt_ctf_field_type_structure_get_field_type_by_name(
+ event_payload_type, "enum_field");
+ 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);
+
ok(bt_ctf_stream_class_get_event_class_count(NULL) < 0,
"bt_ctf_stream_class_get_event_class_count handles NULL correctly");
ok(bt_ctf_stream_class_get_event_class_count(stream_class) == 1,
"bt_ctf_event_get_clock returns a correct clock");
bt_put(clock);
- integer_field = bt_ctf_field_create(uint_12_type);
+ integer_field = bt_ctf_field_create(ep_integer_field_type);
bt_ctf_field_unsigned_integer_set_value(integer_field, 42);
ok(bt_ctf_event_set_payload(simple_event, "integer_field",
integer_field) == 0, "Use bt_ctf_event_set_payload to set a manually allocated field");
ok(fabs(ret_double - double_test_value) <= DBL_EPSILON,
"bt_ctf_field_floating_point_get_value returns a correct value");
- enum_field = bt_ctf_field_create(enum_type);
+ enum_field = bt_ctf_field_create(ep_enum_field_type);
+ assert(enum_field);
ret_char = bt_ctf_field_enumeration_get_mapping_name(NULL);
ok(!ret_char, "bt_ctf_field_enumeration_get_mapping_name handles NULL correctly");
ret_char = bt_ctf_field_enumeration_get_mapping_name(enum_field);
ret = bt_ctf_event_set_payload(simple_event, "enum_field", enum_field);
assert(!ret);
- enum_field_unsigned = bt_ctf_field_create(enum_type_unsigned);
+ enum_field_unsigned = bt_ctf_field_create(ep_enum_field_unsigned_type);
+ assert(enum_field_unsigned);
enum_container_field_unsigned = bt_ctf_field_enumeration_get_container(
enum_field_unsigned);
ok(bt_ctf_field_unsigned_integer_set_value(
bt_put(stream_event_context_field);
bt_put(event_context);
bt_put(event_context_field);
+ bt_put(event_payload_type);
+ bt_put(ep_integer_field_type);
+ bt_put(ep_enum_field_type);
+ bt_put(ep_enum_field_unsigned_type);
}
void append_complex_event(struct bt_ctf_stream_class *stream_class,
ok(bt_ctf_event_class_get_field(event_class, &ret_string,
&ret_field_type, 0) == 0,
"bt_ctf_event_class_get_field returns a field");
- ok(ret_field_type == uint_35_type,
+ ok(bt_ctf_field_type_compare(ret_field_type, uint_35_type) == 0,
"bt_ctf_event_class_get_field returns a correct field type");
bt_put(ret_field_type);
ok(!strcmp(ret_string, "uint_35"),
"bt_ctf_event_class_get_field_by_name handles an invalid field name correctly");
ret_field_type = bt_ctf_event_class_get_field_by_name(event_class,
"complex_structure");
- ok(ret_field_type == complex_structure_type,
+ ok(bt_ctf_field_type_compare(ret_field_type, complex_structure_type) == 0,
"bt_ctf_event_class_get_field_by_name returns a correct field type");
bt_put(ret_field_type);
complex_structure_field, 3);
ret_field_type = bt_ctf_field_get_type(inner_structure_field);
bt_put(inner_structure_field);
- ok(ret_field_type == inner_structure_type,
+ ok(bt_ctf_field_type_compare(ret_field_type, inner_structure_type) == 0,
"bt_ctf_field_structure_get_field_by_index returns a correct field");
bt_put(ret_field_type);
struct bt_ctf_field_type *uint_12_type =
bt_ctf_field_type_integer_create(12);
struct bt_ctf_field_type *enumeration_type;
- struct bt_ctf_field_type *enumeration_sequence_type;
- struct bt_ctf_field_type *enumeration_array_type;
struct bt_ctf_field_type *returned_type;
const char *ret_string;
enumeration_type = bt_ctf_field_type_enumeration_create(uint_12_type);
ok(enumeration_type,
"Create an enumeration type with an unsigned 12-bit integer as container");
- enumeration_sequence_type = bt_ctf_field_type_sequence_create(
- enumeration_type, "count");
- ok(!enumeration_sequence_type,
- "Check enumeration types are validated when creating a sequence");
- enumeration_array_type = bt_ctf_field_type_array_create(
- enumeration_type, 10);
- ok(!enumeration_array_type,
- "Check enumeration types are validated when creating an array");
- ok(bt_ctf_field_type_structure_add_field(composite_structure_type,
- enumeration_type, "enumeration"),
- "Check enumeration types are validated when adding them as structure members");
enumeration = bt_ctf_field_create(enumeration_type);
ok(!enumeration,
"Check enumeration types are validated before instantiation");
bt_put(int_16_type);
bt_put(uint_12_type);
bt_put(enumeration_type);
- bt_put(enumeration_sequence_type);
- bt_put(enumeration_array_type);
bt_put(returned_type);
}
int events_appended = 0;
struct bt_ctf_field *packet_context = NULL,
*packet_context_field = NULL, *event_context = NULL;
+ struct bt_ctf_field_type *ep_field_1_type = NULL;
+ struct bt_ctf_field_type *ep_a_string_type = NULL;
+ struct bt_ctf_field_type *ep_type = NULL;
ret |= bt_ctf_event_class_add_field(event_class, integer_type,
"field_1");
goto end;
}
+ /*
+ * bt_ctf_stream_class_add_event_class() copies the field types
+ * of event_class, so we retrieve the new ones to create the
+ * appropriate fields.
+ */
+ ep_type = bt_ctf_event_class_get_payload_type(event_class);
+ 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);
+ ep_a_string_type = bt_ctf_field_type_structure_get_field_type_by_name(
+ ep_type, "a_string");
+ assert(ep_a_string_type);
+
event = bt_ctf_event_create(event_class);
ret_field = bt_ctf_event_get_payload_by_index(event, 0);
ret_field_type = bt_ctf_field_get_type(ret_field);
- ok(ret_field_type == integer_type,
+ ok(bt_ctf_field_type_compare(ret_field_type, integer_type) == 0,
"bt_ctf_event_get_payload_by_index returns a correct field");
bt_put(ret_field_type);
bt_put(ret_field);
"bt_ctf_stream_set_event_context handles a NULL stream event context correctly");
ok(!bt_ctf_stream_set_event_context(stream, event_context),
"bt_ctf_stream_set_event_context correctly set a stream event context");
- ret_field = bt_ctf_field_create(integer_type);
+ ret_field = bt_ctf_field_create(ep_field_1_type);
ok(bt_ctf_stream_set_event_context(stream, ret_field) < 0,
"bt_ctf_stream_set_event_context rejects an event context of incorrect type");
bt_put(ret_field);
for (i = 0; i < PACKET_RESIZE_TEST_LENGTH; i++) {
event = bt_ctf_event_create(event_class);
struct bt_ctf_field *integer =
- bt_ctf_field_create(integer_type);
+ bt_ctf_field_create(ep_field_1_type);
struct bt_ctf_field *string =
- bt_ctf_field_create(string_type);
+ bt_ctf_field_create(ep_a_string_type);
ret |= bt_ctf_clock_set_time(clock, ++current_time);
ret |= bt_ctf_field_unsigned_integer_set_value(integer, i);
bt_put(packet_context_field);
bt_put(event_context);
bt_put(event_class);
+ bt_put(ep_field_1_type);
+ bt_put(ep_a_string_type);
+ bt_put(ep_type);
}
void test_empty_stream(struct bt_ctf_writer *writer)
ok(ret_stream_class == stream_class,
"Returned stream class is of the correct type");
+ /*
+ * Packet header, packet context, event header, and stream
+ * event context types were copied for the resolving
+ * process
+ */
+ BT_PUT(packet_header_type);
+ BT_PUT(packet_context_type);
+ BT_PUT(stream_event_context_type);
+ packet_header_type = bt_ctf_trace_get_packet_header_type(trace);
+ assert(packet_header_type);
+ packet_context_type =
+ bt_ctf_stream_class_get_packet_context_type(stream_class);
+ assert(packet_context_type);
+ stream_event_context_type =
+ bt_ctf_stream_class_get_event_context_type(stream_class);
+ assert(stream_event_context_type);
+
/*
* Try to modify the packet context type after a stream has been
* created.
ok(packet_header_field,
"Packet header structure contains a custom field with the appropriate name");
ret_field_type = bt_ctf_field_get_type(packet_header_field);
- ok(ret_field_type == packet_header_field_type,
+ ok(bt_ctf_field_type_compare(ret_field_type, packet_header_field_type) == 0,
"Custom packet header field is of the expected type");
ok(!bt_ctf_field_unsigned_integer_set_value(packet_header_field,
54321), "Set custom packet header value successfully");
projects / babeltrace.git / blobdiff