#define DEFAULT_CLOCK_TIME 0
#define DEFAULT_CLOCK_VALUE 0
-#define NR_TESTS 552
+#define NR_TESTS 476
struct bt_utsname {
char sysname[BABELTRACE_HOST_NAME_MAX];
returned_type = bt_field_type_enumeration_get_container_type(enum_type);
ok(returned_type == int_64_type, "bt_field_type_enumeration_get_container_type returns the right type");
- ok(!bt_field_type_enumeration_get_container_type(NULL), "bt_field_type_enumeration_get_container_type handles NULL correctly");
ok(!bt_field_type_enumeration_create(enum_type),
"bt_field_enumeration_type_create rejects non-integer container field types");
bt_put(returned_type);
bt_field_type_set_alignment(float_type, 32);
- ok(bt_field_type_get_alignment(NULL) < 0,
- "bt_field_type_get_alignment handles NULL correctly");
ok(bt_field_type_get_alignment(float_type) == 32,
"bt_field_type_get_alignment returns a correct value");
ok(bt_field_type_floating_point_set_mantissa_digits(float_type, 53) == 0,
"Set a floating point type's mantissa digit count");
- ok(bt_field_type_floating_point_get_exponent_digits(NULL) < 0,
- "bt_field_type_floating_point_get_exponent_digits handles NULL properly");
- ok(bt_field_type_floating_point_get_mantissa_digits(NULL) < 0,
- "bt_field_type_floating_point_get_mantissa_digits handles NULL properly");
ok(bt_field_type_floating_point_get_exponent_digits(float_type) == 11,
"bt_field_type_floating_point_get_exponent_digits returns the correct value");
ok(bt_field_type_floating_point_get_mantissa_digits(float_type) == 53,
-54, -55), "bt_field_type_enumeration_add_mapping rejects mapping where end < start");
bt_ctf_field_type_enumeration_add_mapping(enum_type, "another entry", -42000, -13000);
- iter = bt_field_type_enumeration_find_mappings_by_signed_value(NULL, -42);
- ok(iter == NULL, "bt_field_type_enumeration_find_mappings_by_signed_value handles a NULL field type correctly");
-
iter = bt_field_type_enumeration_find_mappings_by_signed_value(enum_type, -4200000);
ret = bt_field_type_enumeration_mapping_iterator_next(iter);
ok(iter && ret, "bt_field_type_enumeration_find_mappings_by_signed_value rejects non-mapped values");
ok(bt_event_class_add_field(simple_event_class, enum_type,
"enum_field") == 0, "Add signed enumeration field to event");
- ok(bt_field_type_enumeration_get_mapping_signed(NULL, 0, &ret_char,
- &ret_range_start_int64_t, &ret_range_end_int64_t) < 0,
- "bt_field_type_enumeration_get_mapping_signed handles a NULL enumeration correctly");
ok(bt_field_type_enumeration_get_mapping_signed(enum_type, 0, NULL,
&ret_range_start_int64_t, &ret_range_end_int64_t) == 0,
"bt_field_type_enumeration_get_mapping_signed handles a NULL string correctly");
ok(bt_event_class_add_field(simple_event_class, enum_type_unsigned,
"enum_field_unsigned") == 0, "Add unsigned enumeration field to event");
- ok(bt_field_type_enumeration_get_mapping_count(NULL) < 0,
- "bt_field_type_enumeration_get_mapping_count handles NULL correctly");
ok(bt_field_type_enumeration_get_mapping_count(enum_type_unsigned) == 6,
"bt_field_type_enumeration_get_mapping_count returns the correct value");
- ok(bt_field_type_enumeration_get_mapping_unsigned(NULL, 0, &ret_char,
- &ret_range_start_uint64_t, &ret_range_end_uint64_t) < 0,
- "bt_field_type_enumeration_get_mapping_unsigned handles a NULL enumeration correctly");
ok(bt_field_type_enumeration_get_mapping_unsigned(enum_type_unsigned, 0, NULL,
&ret_range_start_uint64_t, &ret_range_end_uint64_t) == 0,
"bt_field_type_enumeration_get_mapping_unsigned handles a NULL string correctly");
ok(!bt_field_type_structure_add_field(event_context_type, uint_12_type,
"event_specific_context"),
"Add event specific context field");
- ok(bt_event_class_get_context_type(NULL) == NULL,
- "bt_event_class_get_context_type handles NULL correctly");
ok(bt_event_class_set_context_type(NULL, event_context_type) < 0,
"bt_event_class_set_context_type handles a NULL event class correctly");
event_payload_type, "enum_field_unsigned");
assert(ep_enum_field_unsigned_type);
- ok(bt_stream_class_get_event_class_count(NULL) < 0,
- "bt_stream_class_get_event_class_count handles NULL correctly");
ok(bt_stream_class_get_event_class_count(stream_class) == 1,
"bt_stream_class_get_event_class_count returns a correct number of event classes");
- ok(bt_stream_class_get_event_class_by_index(NULL, 0) == NULL,
- "bt_stream_class_get_event_class handles NULL correctly");
- ok(bt_stream_class_get_event_class_by_index(stream_class, 8724) == NULL,
- "bt_stream_class_get_event_class handles invalid indexes correctly");
ret_event_class = bt_stream_class_get_event_class_by_index(stream_class, 0);
ok(ret_event_class == simple_event_class,
"bt_stream_class_get_event_class returns the correct event class");
bt_put(ret_event_class);
- ok(!bt_stream_class_get_event_class_by_id(NULL, 0),
- "bt_stream_class_get_event_class_by_id handles NULL correctly");
ok(!bt_stream_class_get_event_class_by_id(stream_class, 2),
"bt_stream_class_get_event_class_by_id returns NULL when the requested ID doesn't exist");
ret_event_class =
sequence_type = bt_field_type_sequence_create(int_16_type,
"seq_len");
- ok(bt_field_type_array_get_element_type(NULL) == NULL,
- "bt_field_type_array_get_element_type handles NULL correctly");
ret_field_type = bt_field_type_array_get_element_type(
array_type);
ok(ret_field_type == int_16_type,
"bt_field_type_array_get_element_type returns the correct type");
bt_put(ret_field_type);
- ok(bt_field_type_array_get_length(NULL) < 0,
- "bt_field_type_array_get_length handles NULL correctly");
ok(bt_field_type_array_get_length(array_type) == ARRAY_TEST_LENGTH,
"bt_field_type_array_get_length returns the correct length");
bt_ctf_field_type_enumeration_add_mapping(enum_variant_type,
"UINT35_TYPE", 2, 7);
- iter = bt_field_type_enumeration_find_mappings_by_name(NULL, "INT16_TYPE");
- ok(iter == NULL, "bt_field_type_enumeration_find_mappings_by_name handles a NULL field type correctly");
-
iter = bt_field_type_enumeration_find_mappings_by_name(enum_variant_type, "INT16_TYPE");
ok(iter != NULL, "bt_field_type_enumeration_find_mappings_by_name returns a non-NULL iterator");
ret = bt_field_type_enumeration_mapping_iterator_next(iter);
"bt_field_type_enumeration_mapping_iterator_get_unsigned handles mapped values correctly");
BT_PUT(iter);
- iter = bt_field_type_enumeration_find_mappings_by_name(enum_variant_type, NULL);
- ret = bt_field_type_enumeration_mapping_iterator_next(iter);
- ok(iter && ret, "bt_field_type_enumeration_find_mappings_by_name handles a NULL name correctly");
- BT_PUT(iter);
-
- iter = bt_field_type_enumeration_find_mappings_by_unsigned_value(NULL, 1);
- ok(iter == NULL, "bt_field_type_enumeration_find_mappings_by_unsigned_value handles a NULL field type correctly");
-
iter = bt_field_type_enumeration_find_mappings_by_unsigned_value(enum_variant_type, -42);
ret = bt_field_type_enumeration_mapping_iterator_next(iter);
ok(iter && ret, "bt_field_type_enumeration_find_mappings_by_unsigned_value handles invalid values correctly");
- ok(bt_field_type_enumeration_mapping_iterator_get_unsigned(iter, NULL, NULL, NULL) != 0,
- "bt_field_type_enumeration_mapping_iterator_get_unsigned handles invalid values correctly");
BT_PUT(iter);
iter = bt_field_type_enumeration_find_mappings_by_unsigned_value(enum_variant_type, 5);
ret = bt_field_type_enumeration_mapping_iterator_next(iter);
ok(iter != NULL && !ret, "bt_field_type_enumeration_find_mappings_by_unsigned_value handles valid values correctly");
- ok(bt_field_type_enumeration_mapping_iterator_get_unsigned(iter, NULL, NULL, NULL) == 0,
- "bt_field_type_enumeration_mapping_iterator_get_unsigned handles valid values correctly");
BT_PUT(iter);
ok(bt_field_type_variant_add_field(variant_type, uint_3_type,
ok(!bt_field_type_variant_add_field(variant_type, uint_35_type,
"UINT35_TYPE"), "Add UINT35_TYPE field to variant");
- ok(bt_field_type_variant_get_tag_type(NULL) == NULL,
- "bt_field_type_variant_get_tag_type handles NULL correctly");
ret_field_type = bt_field_type_variant_get_tag_type(variant_type);
ok(ret_field_type == enum_variant_type,
"bt_field_type_variant_get_tag_type returns a correct tag type");
bt_put(ret_field_type);
- ok(bt_field_type_variant_get_tag_name(NULL) == NULL,
- "bt_field_type_variant_get_tag_name handles NULL correctly");
ret_string = bt_field_type_variant_get_tag_name(variant_type);
ok(ret_string ? !strcmp(ret_string, "variant_selector") : 0,
"bt_field_type_variant_get_tag_name returns the correct variant tag name");
- ok(bt_field_type_variant_get_field_type_by_name(NULL,
- "INT16_TYPE") == NULL,
- "bt_field_type_variant_get_field_type_by_name handles a NULL variant_type correctly");
- ok(bt_field_type_variant_get_field_type_by_name(variant_type,
- NULL) == NULL,
- "bt_field_type_variant_get_field_type_by_name handles a NULL field name correctly");
ret_field_type = bt_field_type_variant_get_field_type_by_name(
variant_type, "INT16_TYPE");
ok(ret_field_type == int_16_type,
"bt_field_type_variant_get_field_type_by_name returns a correct field type");
bt_put(ret_field_type);
- ok(bt_field_type_variant_get_field_count(NULL) < 0,
- "bt_field_type_variant_get_field_count handles NULL correctly");
ok(bt_field_type_variant_get_field_count(variant_type) == 3,
"bt_field_type_variant_get_field_count returns the correct count");
- ok(bt_field_type_variant_get_field_by_index(NULL, &ret_string, &ret_field_type, 0) < 0,
- "bt_field_type_variant_get_field handles a NULL type correctly");
ok(bt_field_type_variant_get_field_by_index(variant_type, NULL, &ret_field_type, 0) == 0,
"bt_field_type_variant_get_field handles a NULL field name correctly");
bt_put(ret_field_type);
ok(bt_field_type_variant_get_field_by_index(variant_type, &ret_string, NULL, 0) == 0,
"bt_field_type_variant_get_field handles a NULL field type correctly");
- ok(bt_field_type_variant_get_field_by_index(variant_type, &ret_string, &ret_field_type, 200) < 0,
- "bt_field_type_variant_get_field handles an invalid index correctly");
ok(bt_field_type_variant_get_field_by_index(variant_type, &ret_string, &ret_field_type, 1) == 0,
"bt_field_type_variant_get_field returns a field");
ok(!strcmp("INT16_TYPE", ret_string),
"complex_structure") == 0,
"Add composite structure to an event");
- ok(bt_event_class_get_name(NULL) == NULL,
- "bt_event_class_get_name handles NULL correctly");
ret_string = bt_event_class_get_name(event_class);
ok(!strcmp(ret_string, complex_test_event_string),
"bt_event_class_get_name returns a correct name");
ok(bt_event_class_get_id(event_class) < 0,
"bt_event_class_get_id returns a negative value when not set");
- ok(bt_event_class_get_id(NULL) < 0,
- "bt_event_class_get_id handles NULL correctly");
ok(bt_event_class_set_id(NULL, 42) < 0,
"bt_event_class_set_id handles NULL correctly");
ok(bt_event_class_set_id(event_class, 42) == 0,
"bt_event_class_set_log_level handles an unknown log level correctly");
ok(!bt_event_class_set_log_level(event_class, BT_EVENT_CLASS_LOG_LEVEL_INFO),
"bt_event_class_set_log_level succeeds with a valid log level");
- ok(bt_event_class_get_log_level(NULL) == BT_EVENT_CLASS_LOG_LEVEL_UNKNOWN,
- "bt_event_class_get_log_level handles a NULL event class correctly");
ok(bt_event_class_get_log_level(event_class) == BT_EVENT_CLASS_LOG_LEVEL_INFO,
"bt_event_class_get_log_level returns the expected log level");
ok(bt_event_class_set_emf_uri(NULL, "http://diamon.org/babeltrace/"),
"bt_event_class_set_emf_uri handles a NULL event class correctly");
ok(!bt_event_class_set_emf_uri(event_class, "http://diamon.org/babeltrace/"),
"bt_event_class_set_emf_uri succeeds with a valid EMF URI");
- ok(!bt_event_class_get_emf_uri(NULL),
- "bt_event_class_get_emf_uri handles a NULL event class correctly");
ok(strcmp(bt_event_class_get_emf_uri(event_class), "http://diamon.org/babeltrace/") == 0,
"bt_event_class_get_emf_uri returns the expected EMF URI");
ok(!bt_event_class_set_emf_uri(event_class, NULL),
ok(bt_stream_class_add_event_class(stream_class,
event_class) == 0, "Add an event class to stream class");
- ok(bt_event_class_get_stream_class(NULL) == NULL,
- "bt_event_class_get_stream_class handles NULL correctly");
ret_stream_class = bt_event_class_get_stream_class(event_class);
ok(ret_stream_class == stream_class,
"bt_event_class_get_stream_class returns the correct stream class");
bt_put(ret_stream_class);
- ok(bt_event_class_get_payload_type_field_count(NULL) < 0,
- "bt_event_class_get_field_count handles NULL correctly");
ok(bt_event_class_get_payload_type_field_count(event_class) == 3,
"bt_event_class_get_field_count returns a correct value");
- ok(bt_event_class_get_payload_type_field_by_index(NULL, &ret_string,
- &ret_field_type, 0) < 0,
- "bt_event_class_get_field handles a NULL event class correctly");
- ok(bt_event_class_get_payload_type_field_by_index(event_class, NULL,
- &ret_field_type, 0) == 0,
- "bt_event_class_get_field handles a NULL field name correctly");
- bt_put(ret_field_type);
ok(bt_event_class_get_payload_type_field_by_index(event_class, &ret_string,
NULL, 0) == 0,
"bt_event_class_get_field handles a NULL field type correctly");
- ok(bt_event_class_get_payload_type_field_by_index(event_class, &ret_string,
- &ret_field_type, 42) < 0,
- "bt_event_class_get_field handles an invalid index correctly");
ok(bt_event_class_get_payload_type_field_by_index(event_class, &ret_string,
&ret_field_type, 0) == 0,
"bt_event_class_get_field returns a field");
bt_put(ret_field_type);
ok(!strcmp(ret_string, "uint_35"),
"bt_event_class_get_field returns a correct field name");
- ok(bt_ctf_event_class_get_field_by_name(NULL, "") == NULL,
- "bt_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_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_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,
"Set integer type signedness to signed");
ok(bt_ctf_field_type_integer_set_signed(uint_12_type, 0) == 0,
"Set integer type signedness to unsigned");
- ok(bt_field_type_integer_get_size(NULL) < 0,
- "bt_field_type_integer_get_size handles NULL correctly");
ok(bt_field_type_integer_get_size(uint_12_type) == 12,
"bt_field_type_integer_get_size returns a correct value");
- ok(bt_ctf_field_type_integer_get_signed(NULL) < 0,
- "bt_field_type_integer_get_signed handles NULL correctly");
ok(bt_ctf_field_type_integer_get_signed(uint_12_type) == 0,
"bt_field_type_integer_get_signed returns a correct value for unsigned types");
ok(bt_field_type_get_byte_order(uint_12_type) ==
BT_BYTE_ORDER_BIG_ENDIAN,
"bt_field_type_get_byte_order returns a correct value");
- ok(bt_field_type_get_byte_order(NULL) ==
- BT_BYTE_ORDER_UNKNOWN,
- "bt_field_type_get_byte_order handles NULL correctly");
- ok(bt_field_type_get_type_id(NULL) ==
- BT_FIELD_TYPE_ID_UNKNOWN,
- "bt_field_type_get_type_id handles NULL correctly");
ok(bt_field_type_get_type_id(uint_12_type) ==
BT_FIELD_TYPE_ID_INTEGER,
"bt_field_type_get_type_id returns a correct value with an integer type");
- ok(bt_field_type_integer_get_base(NULL) ==
- BT_INTEGER_BASE_UNKNOWN,
- "bt_field_type_integer_get_base handles NULL correctly");
ok(bt_field_type_integer_get_base(uint_12_type) ==
BT_INTEGER_BASE_HEXADECIMAL,
"bt_field_type_integer_get_base returns a correct value");
ok(bt_field_type_integer_set_encoding(uint_12_type,
BT_STRING_ENCODING_UTF8) == 0,
"Set integer type encoding to UTF8");
- ok(bt_field_type_integer_get_encoding(NULL) ==
- BT_STRING_ENCODING_UNKNOWN,
- "bt_field_type_integer_get_encoding handles NULL correctly");
ok(bt_field_type_integer_get_encoding(uint_12_type) ==
BT_STRING_ENCODING_UTF8,
"bt_field_type_integer_get_encoding returns a correct value");
BT_FIELD_TYPE_ID_SEQUENCE,
"bt_field_type_get_type_id returns a correct value with a sequence type");
- ok(bt_field_type_sequence_get_length_field_name(NULL) == NULL,
- "bt_field_type_sequence_get_length_field_name handles NULL correctly");
ret_string = bt_field_type_sequence_get_length_field_name(
sequence_type);
ok(!strcmp(ret_string, "seq_len"),
"bt_field_type_sequence_get_length_field_name returns the correct value");
- ok(bt_field_type_sequence_get_element_type(NULL) == NULL,
- "bt_field_type_sequence_get_element_type handles NULL correctly");
returned_type = bt_field_type_sequence_get_element_type(
sequence_type);
ok(returned_type == int_16_type,
BT_STRING_ENCODING_ASCII) == 0,
"Set string encoding to ASCII");
- ok(bt_field_type_string_get_encoding(NULL) ==
- BT_STRING_ENCODING_UNKNOWN,
- "bt_field_type_string_get_encoding handles NULL correctly");
ok(bt_field_type_string_get_encoding(string_type) ==
BT_STRING_ENCODING_ASCII,
"bt_field_type_string_get_encoding returns the correct value");
sequence_type, "a_sequence") == 0,
"Add a sequence type to a structure");
- ok(bt_field_type_structure_get_field_count(NULL) < 0,
- "bt_field_type_structure_get_field_count handles NULL correctly");
ok(bt_field_type_structure_get_field_count(structure_seq_type) == 2,
"bt_field_type_structure_get_field_count returns a correct value");
- ok(bt_ctf_field_type_structure_get_field(NULL,
- &ret_string, &returned_type, 1) < 0,
- "bt_field_type_structure_get_field handles a NULL type correctly");
ok(bt_ctf_field_type_structure_get_field(structure_seq_type,
NULL, &returned_type, 1) == 0,
"bt_field_type_structure_get_field handles a NULL name correctly");
ok(bt_ctf_field_type_structure_get_field(structure_seq_type,
&ret_string, NULL, 1) == 0,
"bt_field_type_structure_get_field handles a NULL return type correctly");
- ok(bt_ctf_field_type_structure_get_field(structure_seq_type,
- &ret_string, &returned_type, 10) < 0,
- "bt_field_type_structure_get_field handles an invalid index correctly");
ok(bt_ctf_field_type_structure_get_field(structure_seq_type,
&ret_string, &returned_type, 1) == 0,
"bt_field_type_structure_get_field returns a field");
"bt_field_type_structure_get_field returns a correct field type");
bt_put(returned_type);
- ok(bt_field_type_structure_get_field_type_by_name(NULL, "a_sequence") == NULL,
- "bt_field_type_structure_get_field_type_by_name handles a NULL structure correctly");
- ok(bt_field_type_structure_get_field_type_by_name(structure_seq_type, NULL) == NULL,
- "bt_field_type_structure_get_field_type_by_name handles a NULL field name correctly");
returned_type = bt_field_type_structure_get_field_type_by_name(
structure_seq_type, "a_sequence");
ok(returned_type == sequence_type,
structure_seq_type, "inner_structure") == 0,
"Add a structure type to a structure");
- ok(bt_field_type_structure_get_field_type_by_name(
- NULL, "a_sequence") == NULL,
- "bt_field_type_structure_get_field_type_by_name handles a NULL field correctly");
- ok(bt_field_type_structure_get_field_type_by_name(
- structure_seq_type, NULL) == NULL,
- "bt_field_type_structure_get_field_type_by_name handles a NULL field name correctly");
returned_type = bt_field_type_structure_get_field_type_by_name(
structure_seq_type, "a_sequence");
ok(returned_type == sequence_type,
ret = bt_stream_class_set_event_header_type(stream_class, NULL);
assert(ret == 0);
- ok(bt_stream_class_get_trace(NULL) == NULL,
- "bt_stream_class_get_trace handles NULL correctly");
ok(bt_stream_class_get_trace(stream_class) == NULL,
"bt_stream_class_get_trace returns NULL when stream class is orphaned");
trace = bt_trace_create();
assert(trace);
- ok(!bt_trace_get_uuid(NULL),
- "bt_trace_get_uuid() handles NULL");
ok(!bt_trace_get_uuid(trace),
"bt_trace_get_uuid() returns NULL initially");
ok(bt_trace_set_uuid(NULL, uuid),
"bt_trace_set_environment_field_string succeeds");
/* Test bt_trace_get_environment_field_count */
- ok(bt_trace_get_environment_field_count(NULL) < 0,
- "bt_trace_get_environment_field_count handles a NULL trace correctly");
ok(bt_trace_get_environment_field_count(trace) == 5,
"bt_trace_get_environment_field_count returns a correct number of environment fields");
/* Test bt_trace_get_environment_field_name */
- ok(bt_trace_get_environment_field_name_by_index(NULL, 0) == NULL,
- "bt_trace_get_environment_field_name handles a NULL trace correctly");
- ok(bt_trace_get_environment_field_name_by_index(trace, 5) == NULL,
- "bt_trace_get_environment_field_name handles an invalid index correctly (too large)");
ret_string = bt_trace_get_environment_field_name_by_index(trace, 0);
ok(ret_string && !strcmp(ret_string, "host"),
"bt_trace_get_environment_field_name returns a correct field name");
"bt_trace_get_environment_field_name returns a correct field name");
/* Test bt_trace_get_environment_field_value */
- ok(bt_trace_get_environment_field_value_by_index(NULL, 0) == NULL,
- "bt_trace_get_environment_field_value handles a NULL trace correctly");
- ok(bt_trace_get_environment_field_value_by_index(trace, 5) == NULL,
- "bt_trace_get_environment_field_value handles an invalid index correctly (too large)");
obj = bt_trace_get_environment_field_value_by_index(trace, 1);
ret = bt_value_integer_get(obj, &ret_int64_t);
ok(!ret && ret_int64_t == 23,
BT_PUT(obj);
/* Test bt_trace_get_environment_field_value_by_name */
- ok(!bt_trace_get_environment_field_value_by_name(NULL,
- "test_env_str"),
- "bt_trace_get_environment_field_value_by_name handles a NULL trace correctly");
- ok(!bt_trace_get_environment_field_value_by_name(trace, NULL),
- "bt_trace_get_environment_field_value_by_name handles a NULL name correctly");
ok(!bt_trace_get_environment_field_value_by_name(trace, "oh oh"),
"bt_trace_get_environment_field_value_by_name returns NULL or an unknown field name");
obj = bt_trace_get_environment_field_value_by_name(trace,
/* Define a stream class */
stream_class = bt_stream_class_create("test_stream");
- ok(bt_stream_class_get_name(NULL) == NULL,
- "bt_stream_class_get_name handles NULL correctly");
ret_string = bt_stream_class_get_name(stream_class);
ok(ret_string && !strcmp(ret_string, "test_stream"),
"bt_stream_class_get_name returns a correct stream class name");
ok(bt_stream_class_get_id(stream_class) < 0,
"bt_stream_class_get_id returns an error when no id is set");
- ok(bt_stream_class_get_id(NULL) < 0,
- "bt_stream_class_get_id handles NULL correctly");
ok(bt_stream_class_set_id(NULL, 123) < 0,
"bt_stream_class_set_id handles NULL correctly");
ok(bt_stream_class_set_id(stream_class, 123) == 0,
"bt_stream_class_get_id returns the correct value");
/* Validate default event header fields */
- ok(bt_stream_class_get_event_header_type(NULL) == NULL,
- "bt_stream_class_get_event_header_type handles NULL correctly");
ret_field_type = bt_stream_class_get_event_header_type(
stream_class);
ok(ret_field_type,
bt_put(ret_field_type);
/* Add a custom trace packet header field */
- ok(bt_trace_get_packet_header_type(NULL) == NULL,
- "bt_trace_get_packet_header_type handles NULL correctly");
packet_header_type = bt_trace_get_packet_header_type(trace);
ok(packet_header_type,
"bt_trace_get_packet_header_type returns a packet header");
ok(!bt_trace_set_packet_header_type(trace, packet_header_type),
"Set a trace packet_header_type successfully");
- ok(bt_stream_class_get_packet_context_type(NULL) == NULL,
- "bt_stream_class_get_packet_context_type handles NULL correctly");
-
/* Add a custom field to the stream class' packet context */
packet_context_type = bt_stream_class_get_packet_context_type(stream_class);
ok(packet_context_type,
ok(ret == 0, "Packet context field added successfully");
/* Define a stream event context containing a my_integer field. */
- ok(bt_stream_class_get_event_context_type(NULL) == NULL,
- "bt_stream_class_get_event_context_type handles NULL correctly");
stream_event_context_type = bt_field_type_structure_create();
bt_field_type_structure_add_field(stream_event_context_type,
integer_type, "common_event_context");
* class to the writer's trace, thus registering the stream
* class's clock to the trace.
*/
- ok(bt_trace_get_clock_class_count(NULL) < 0,
- "bt_trace_get_clock_class_count correctly handles NULL");
ok(bt_trace_get_clock_class_count(trace) == 1,
"bt_trace_get_clock_class_count returns the correct number of clocks");
- ok(!bt_trace_get_clock_class_by_index(NULL, 0),
- "bt_trace_get_clock_class correctly handles NULL");
- ok(!bt_trace_get_clock_class_by_index(trace, 1),
- "bt_trace_get_clock_class correctly handles out of bound accesses");
ret_clock_class = bt_trace_get_clock_class_by_index(trace, 0);
ok(strcmp(bt_clock_class_get_name(ret_clock_class),
bt_ctf_clock_get_name(clock)) == 0,
"bt_trace_get_clock_class returns the right clock instance");
bt_put(ret_clock_class);
- ok(!bt_trace_get_clock_class_by_name(trace, NULL),
- "bt_trace_get_clock_class_by_name correctly handles NULL (trace)");
- ok(!bt_trace_get_clock_class_by_name(NULL, clock_name),
- "bt_trace_get_clock_by_name correctly handles NULL (clock name)");
- ok(!bt_trace_get_clock_class_by_name(NULL, NULL),
- "bt_trace_get_clock_by_name correctly handles NULL (both)");
ret_clock_class = bt_trace_get_clock_class_by_name(trace, clock_name);
ok(strcmp(bt_clock_class_get_name(ret_clock_class),
bt_ctf_clock_get_name(clock)) == 0,
ok(!bt_trace_get_clock_class_by_name(trace, "random"),
"bt_trace_get_clock_by_name fails when the requested clock doesn't exist");
- ok(bt_stream_get_class(NULL) == NULL,
- "bt_stream_get_class correctly handles NULL");
ret_stream_class = bt_stream_get_class(stream1);
ok(ret_stream_class,
"bt_stream_get_class returns a stream class");
projects / babeltrace.git / blobdiff