#define METADATA_LINE_SIZE 512
#define SEQUENCE_TEST_LENGTH 10
+#define ARRAY_TEST_LENGTH 5
#define PACKET_RESIZE_TEST_LENGTH 100000
#define DEFAULT_CLOCK_FREQ 1000000000
size_t ret_size_t;
int64_t ret_range_start_int64_t, ret_range_end_int64_t;
uint64_t ret_range_start_uint64_t, ret_range_end_uint64_t;
+ struct bt_ctf_clock *ret_clock;
+ struct bt_ctf_event_class *ret_event_class;
ok(uint_12_type, "Create an unsigned integer type");
bt_ctf_stream_class_add_event_class(stream_class,
simple_event_class);
- simple_event = bt_ctf_event_create(simple_event_class);
+ 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_stream_class_get_event_class_count returns a correct number of event classes");
+ ok(bt_ctf_stream_class_get_event_class(NULL, 0) == NULL,
+ "bt_ctf_stream_class_get_event_class handles NULL correctly");
+ ok(bt_ctf_stream_class_get_event_class(stream_class, 8724) == NULL,
+ "bt_ctf_stream_class_get_event_class handles invalid indexes correctly");
+ ret_event_class = bt_ctf_stream_class_get_event_class(stream_class, 0);
+ ok(ret_event_class == simple_event_class,
+ "bt_ctf_stream_class_get_event_class returns the correct event class");
+ bt_ctf_event_class_put(ret_event_class);
+
+ ok(bt_ctf_stream_class_get_event_class_by_name(NULL, "some event name") == NULL,
+ "bt_ctf_stream_class_get_event_class_by_name handles a NULL stream class correctly");
+ ok(bt_ctf_stream_class_get_event_class_by_name(stream_class, NULL) == NULL,
+ "bt_ctf_stream_class_get_event_class_by_name handles a NULL event class name correctly");
+ ok(bt_ctf_stream_class_get_event_class_by_name(stream_class, "some event name") == NULL,
+ "bt_ctf_stream_class_get_event_class_by_name handles non-existing event class names correctly");
+ ret_event_class = bt_ctf_stream_class_get_event_class_by_name(stream_class, "Simple Event");
+ ok(ret_event_class == simple_event_class,
+ "bt_ctf_stream_class_get_event_class_by_name returns a correct event class");
+ bt_ctf_event_class_put(ret_event_class);
+ simple_event = bt_ctf_event_create(simple_event_class);
ok(simple_event,
"Instantiate an event containing a single integer field");
+ ok(bt_ctf_event_get_clock(NULL) == NULL,
+ "bt_ctf_event_get_clock handles NULL correctly");
+ ret_clock = bt_ctf_event_get_clock(simple_event);
+ ok(ret_clock == clock,
+ "bt_ctf_event_get_clock returns a correct clock");
+ bt_ctf_clock_put(clock);
+
integer_field = bt_ctf_field_create(uint_12_type);
bt_ctf_field_unsigned_integer_set_value(integer_field, 42);
ok(bt_ctf_event_set_payload(simple_event, "integer_field",
struct bt_ctf_stream *stream, struct bt_ctf_clock *clock)
{
int i;
+ const char *complex_test_event_string = "Complex Test Event";
const char *test_string = "Test string";
struct bt_ctf_field_type *uint_35_type =
bt_ctf_field_type_integer_create(35);
struct bt_ctf_field_type *string_type =
bt_ctf_field_type_string_create();
struct bt_ctf_field_type *sequence_type;
+ struct bt_ctf_field_type *array_type;
struct bt_ctf_field_type *inner_structure_type =
bt_ctf_field_type_structure_create();
struct bt_ctf_field_type *complex_structure_type =
struct bt_ctf_field *uint_35_field, *int_16_field, *a_string_field,
*inner_structure_field, *complex_structure_field,
*a_sequence_field, *enum_variant_field, *enum_container_field,
- *variant_field, *ret_field;
- int64_t ret_signed_int;
+ *variant_field, *an_array_field, *ret_field;
uint64_t ret_unsigned_int;
+ int64_t ret_signed_int;
const char *ret_string;
size_t ret_size_t;
+ struct bt_ctf_stream_class *ret_stream_class;
+ struct bt_ctf_event_class *ret_event_class;
bt_ctf_field_type_set_alignment(int_16_type, 32);
bt_ctf_field_type_integer_set_signed(int_16_type, 1);
bt_ctf_field_type_integer_set_base(uint_35_type,
BT_CTF_INTEGER_BASE_HEXADECIMAL);
+ array_type = bt_ctf_field_type_array_create(int_16_type, ARRAY_TEST_LENGTH);
sequence_type = bt_ctf_field_type_sequence_create(int_16_type,
"seq_len");
uint_35_type, "seq_len");
bt_ctf_field_type_structure_add_field(inner_structure_type,
sequence_type, "a_sequence");
+ bt_ctf_field_type_structure_add_field(inner_structure_type,
+ array_type, "an_array");
bt_ctf_field_type_enumeration_add_mapping(enum_variant_type,
"UINT3_TYPE", 0, 0);
ok(bt_ctf_event_class_create("clock") == NULL,
"Reject creation of an event class with an illegal name");
- event_class = bt_ctf_event_class_create("Complex Test Event");
+ event_class = bt_ctf_event_class_create(complex_test_event_string);
ok(event_class, "Create an event class");
ok(bt_ctf_event_class_add_field(event_class, uint_35_type, ""),
"Reject addition of a field with an empty name to an event");
"complex_structure") == 0,
"Add composite structure to an event");
+ ok(bt_ctf_event_class_get_name(NULL) == NULL,
+ "bt_ctf_event_class_get_name handles NULL correctly");
+ ret_string = bt_ctf_event_class_get_name(event_class);
+ ok(!strcmp(ret_string, complex_test_event_string),
+ "bt_ctf_event_class_get_name returns a correct name");
+ ok(bt_ctf_event_class_get_id(event_class) < 0,
+ "bt_ctf_event_class_get_id returns a negative value when not set");
+ ok(bt_ctf_event_class_get_id(NULL) < 0,
+ "bt_ctf_event_class_get_id handles NULL correctly");
+ ok(bt_ctf_event_class_set_id(NULL, 42) < 0,
+ "bt_ctf_event_class_set_id handles NULL correctly");
+ ok(bt_ctf_event_class_set_id(event_class, 42) == 0,
+ "Set an event class' id");
+ ok(bt_ctf_event_class_get_id(event_class) == 42,
+ "bt_ctf_event_class_get_id returns the correct value");
+
/* Add event class to the stream class */
ok(bt_ctf_stream_class_add_event_class(stream_class, NULL),
"Reject addition of NULL event class to a stream class");
ok(bt_ctf_stream_class_add_event_class(stream_class,
event_class) == 0, "Add an event class to stream class");
+ ok(bt_ctf_event_class_get_stream_class(NULL) == NULL,
+ "bt_ctf_event_class_get_stream_class handles NULL correctly");
+ ret_stream_class = bt_ctf_event_class_get_stream_class(event_class);
+ ok(ret_stream_class == stream_class,
+ "bt_ctf_event_class_get_stream_class returns the correct stream class");
+ bt_ctf_stream_class_put(ret_stream_class);
+
+ ok(bt_ctf_event_class_get_field_count(NULL) < 0,
+ "bt_ctf_event_class_get_field_count handles NULL correctly");
+ ok(bt_ctf_event_class_get_field_count(event_class) == 3,
+ "bt_ctf_event_class_get_field_count returns a correct value");
+
+ ok(bt_ctf_event_class_get_field(NULL, &ret_string,
+ &ret_field_type, 0) < 0,
+ "bt_ctf_event_class_get_field handles a NULL event class correctly");
+ ok(bt_ctf_event_class_get_field(event_class, NULL,
+ &ret_field_type, 0) < 0,
+ "bt_ctf_event_class_get_field handles a NULL field name correctly");
+ ok(bt_ctf_event_class_get_field(event_class, &ret_string,
+ NULL, 0) < 0,
+ "bt_ctf_event_class_get_field handles a NULL field type correctly");
+ ok(bt_ctf_event_class_get_field(event_class, &ret_string,
+ &ret_field_type, 42) < 0,
+ "bt_ctf_event_class_get_field handles an invalid index correctly");
+ 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,
+ "bt_ctf_event_class_get_field returns a correct field type");
+ bt_ctf_field_type_put(ret_field_type);
+ ok(!strcmp(ret_string, "uint_35"),
+ "bt_ctf_event_class_get_field returns a correct field name");
+ ok(bt_ctf_event_class_get_field_by_name(NULL, "") == NULL,
+ "bt_ctf_event_class_get_field_by_name handles a NULL event class correctly");
+ ok(bt_ctf_event_class_get_field_by_name(event_class, NULL) == NULL,
+ "bt_ctf_event_class_get_field_by_name handles a NULL field name correctly");
+ ok(bt_ctf_event_class_get_field_by_name(event_class, "truie") == NULL,
+ "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,
+ "bt_ctf_event_class_get_field_by_name returns a correct field type");
+ bt_ctf_field_type_put(ret_field_type);
+
event = bt_ctf_event_create(event_class);
ok(event, "Instanciate a complex event");
+ ok(bt_ctf_event_get_class(NULL) == NULL,
+ "bt_ctf_event_get_class handles NULL correctly");
+ ret_event_class = bt_ctf_event_get_class(event);
+ ok(ret_event_class == event_class,
+ "bt_ctf_event_get_class returns the correct event class");
+ bt_ctf_event_class_put(ret_event_class);
+
uint_35_field = bt_ctf_event_get_payload(event, "uint_35");
if (!uint_35_field) {
printf("uint_35_field is NULL\n");
inner_structure_field, "seq_len");
a_sequence_field = bt_ctf_field_structure_get_field(
inner_structure_field, "a_sequence");
+ an_array_field = bt_ctf_field_structure_get_field(
+ inner_structure_field, "an_array");
enum_container_field = bt_ctf_field_enumeration_get_container(
enum_variant_field);
bt_ctf_field_put(int_16_field);
}
+ for (i = 0; i < ARRAY_TEST_LENGTH; i++) {
+ int_16_field = bt_ctf_field_array_get_field(
+ an_array_field, i);
+ bt_ctf_field_signed_integer_set_value(int_16_field, i);
+ bt_ctf_field_put(int_16_field);
+ }
+
bt_ctf_clock_set_time(clock, ++current_time);
ok(bt_ctf_stream_append_event(stream, event) == 0,
"Append a complex event to a stream");
bt_ctf_field_put(inner_structure_field);
bt_ctf_field_put(complex_structure_field);
bt_ctf_field_put(a_sequence_field);
+ bt_ctf_field_put(an_array_field);
bt_ctf_field_put(enum_variant_field);
bt_ctf_field_put(enum_container_field);
bt_ctf_field_put(variant_field);
bt_ctf_field_type_put(int_16_type);
bt_ctf_field_type_put(string_type);
bt_ctf_field_type_put(sequence_type);
+ bt_ctf_field_type_put(array_type);
bt_ctf_field_type_put(inner_structure_type);
bt_ctf_field_type_put(complex_structure_type);
bt_ctf_field_type_put(uint_3_type);
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") == 0,
+ enumeration_type, "enumeration"),
"Check enumeration types are validated when adding them as structure members");
enumeration = bt_ctf_field_create(enumeration_type);
ok(!enumeration,
bt_ctf_field_type_integer_create(17);
struct bt_ctf_field_type *string_type =
bt_ctf_field_type_string_create();
+ struct bt_ctf_event *event;
+ struct bt_ctf_field *ret_field;
+ struct bt_ctf_field_type *ret_field_type;
+ uint64_t ret_uint64;
ret |= bt_ctf_event_class_add_field(event_class, integer_type,
"field_1");
goto end;
}
+ 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,
+ "bt_ctf_event_get_payload_by_index returns a correct field");
+ bt_ctf_field_type_put(ret_field_type);
+ bt_ctf_field_put(ret_field);
+
+ ok(bt_ctf_event_get_payload_by_index(NULL, 0) == NULL,
+ "bt_ctf_event_get_payload_by_index handles NULL correctly");
+ ok(bt_ctf_event_get_payload_by_index(event, 4) == NULL,
+ "bt_ctf_event_get_payload_by_index handles an invalid index correctly");
+ bt_ctf_event_put(event);
+
for (i = 0; i < PACKET_RESIZE_TEST_LENGTH; i++) {
- struct bt_ctf_event *event = bt_ctf_event_create(event_class);
+ event = bt_ctf_event_create(event_class);
struct bt_ctf_field *integer =
bt_ctf_field_create(integer_type);
struct bt_ctf_field *string =
break;
}
}
+
+ ok(bt_ctf_stream_get_discarded_events_count(NULL, &ret_uint64) == -1,
+ "bt_ctf_stream_get_discarded_events_count handles a NULL stream correctly");
+ ok(bt_ctf_stream_get_discarded_events_count(stream, NULL) == -1,
+ "bt_ctf_stream_get_discarded_events_count handles a NULL return pointer correctly");
+ ret = bt_ctf_stream_get_discarded_events_count(stream, &ret_uint64);
+ ok(ret == 0 && ret_uint64 == 0,
+ "bt_ctf_stream_get_discarded_events_count returns a correct number of discarded events when none were discarded");
+ bt_ctf_stream_append_discarded_events(stream, 1000);
+ ret = bt_ctf_stream_get_discarded_events_count(stream, &ret_uint64);
+ ok(ret == 0 && ret_uint64 == 1000,
+ "bt_ctf_stream_get_discarded_events_count returns a correct number of discarded events when some were discarded");
+
end:
ok(ret == 0, "Append 100 000 events to a stream");
ok(bt_ctf_stream_flush(stream) == 0,
"Flush a stream that forces a packet resize");
+ ret = bt_ctf_stream_get_discarded_events_count(stream, &ret_uint64);
+ ok(ret == 0 && ret_uint64 == 1000,
+ "bt_ctf_stream_get_discarded_events_count returns a correct number of discarded events after a flush");
bt_ctf_field_type_put(integer_type);
bt_ctf_field_type_put(string_type);
bt_ctf_event_class_put(event_class);
struct bt_ctf_writer *writer;
struct utsname name;
char hostname[HOST_NAME_MAX];
- struct bt_ctf_clock *clock;
+ struct bt_ctf_clock *clock, *ret_clock;
struct bt_ctf_stream_class *stream_class;
struct bt_ctf_stream *stream1;
+ const char *ret_string;
if (argc < 3) {
printf("Usage: tests-ctf-writer path_to_ctf_parser_test path_to_babeltrace\n");
/* Define a stream class */
stream_class = bt_ctf_stream_class_create("test_stream");
+
+ ok(bt_ctf_stream_class_get_name(NULL) == NULL,
+ "bt_ctf_stream_class_get_name handles NULL correctly");
+ ret_string = bt_ctf_stream_class_get_name(stream_class);
+ ok(!strcmp(ret_string, "test_stream"),
+ "bt_ctf_stream_class_get_name returns a correct stream class name");
+
+ ok(bt_ctf_stream_class_get_clock(stream_class) == NULL,
+ "bt_ctf_stream_class_get_clock returns NULL when a clock was not set");
+ ok(bt_ctf_stream_class_get_clock(NULL) == NULL,
+ "bt_ctf_stream_class_get_clock handles NULL correctly");
+
ok(stream_class, "Create stream class");
ok(bt_ctf_stream_class_set_clock(stream_class, clock) == 0,
"Set a stream class' clock");
+ ret_clock = bt_ctf_stream_class_get_clock(stream_class);
+ ok(ret_clock == clock,
+ "bt_ctf_stream_class_get_clock returns a correct clock");
+ bt_ctf_clock_put(ret_clock);
/* Test the event fields and event types APIs */
type_field_tests();
+ ok(bt_ctf_stream_class_get_id(stream_class) < 0,
+ "bt_ctf_stream_class_get_id returns an error when no id is set");
+ ok(bt_ctf_stream_class_get_id(NULL) < 0,
+ "bt_ctf_stream_class_get_id handles NULL correctly");
+ ok(bt_ctf_stream_class_set_id(NULL, 123) < 0,
+ "bt_ctf_stream_class_set_id handles NULL correctly");
+ ok(bt_ctf_stream_class_set_id(stream_class, 123) == 0,
+ "Set an stream class' id");
+ ok(bt_ctf_stream_class_get_id(stream_class) == 123,
+ "bt_ctf_stream_class_get_id returns the correct value");
+
/* Instantiate a stream and append events */
stream1 = bt_ctf_writer_create_stream(writer, stream_class);
ok(stream1, "Instanciate a stream class from writer");
projects / babeltrace.git / blobdiff