#include <stdlib.h>
#include <stdio.h>
#include <sys/utsname.h>
-#include <limits.h>
+#include <babeltrace/compat/limits.h>
#include <string.h>
#include <assert.h>
-#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <dirent.h>
static uint64_t current_time = 42;
+/* Return 1 if uuids match, zero if different. */
+int uuid_match(const unsigned char *uuid_a, const unsigned char *uuid_b)
+{
+ int ret = 0;
+ int i;
+
+ if (!uuid_a || !uuid_b) {
+ goto end;
+ }
+
+ for (i = 0; i < 16; i++) {
+ if (uuid_a[i] != uuid_b[i]) {
+ goto end;
+ }
+ }
+
+ ret = 1;
+end:
+ return ret;
+}
+
void validate_metadata(char *parser_path, char *metadata_path)
{
int ret = 0;
const char *mapping_name_negative_test = "negative_value";
const char *ret_char;
double ret_double;
- 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;
-54, -55), "bt_ctf_field_type_enumeration_add_mapping rejects mapping where end < start");
bt_ctf_field_type_enumeration_add_mapping(enum_type, "another entry", -42000, -13000);
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(NULL, -42, &ret_size_t) < 0,
+ ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(NULL, -42) < 0,
"bt_ctf_field_type_enumeration_get_mapping_index_by_value handles a NULL field type correctly");
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(enum_type, -42, NULL) < 0,
- "bt_ctf_field_type_enumeration_get_mapping_index_by_value handles a NULL index correctly");
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(enum_type, 1000000, &ret_size_t) < 0,
- "bt_ctf_field_type_enumeration_get_mapping_index_by_value handles invalid values correctly");
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(enum_type, -55, &ret_size_t) == 0,
+ ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(enum_type, 1000000) < 0,
"bt_ctf_field_type_enumeration_get_mapping_index_by_value handles invalid values correctly");
- ok(ret_size_t == 1,
+ ok(bt_ctf_field_type_enumeration_get_mapping_index_by_value(enum_type, -55) == 1,
"bt_ctf_field_type_enumeration_get_mapping_index_by_value returns the correct index");
ok(bt_ctf_event_class_add_field(simple_event_class, enum_type,
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;
struct bt_ctf_field *packet_context, *packet_context_field;
bt_ctf_field_type_enumeration_add_mapping(enum_variant_type,
"UINT35_TYPE", 2, 7);
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(NULL, "INT16_TYPE",
- &ret_size_t) < 0,
+ ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(NULL,
+ "INT16_TYPE") < 0,
"bt_ctf_field_type_enumeration_get_mapping_index_by_name handles a NULL field type correctly");
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(enum_variant_type, NULL,
- &ret_size_t) < 0,
+ ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(
+ enum_variant_type, NULL) < 0,
"bt_ctf_field_type_enumeration_get_mapping_index_by_name handles a NULL name correctly");
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(enum_variant_type, "INT16_TYPE",
- NULL) < 0,
- "bt_ctf_field_type_enumeration_get_mapping_index_by_name handles a NULL index correctly");
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(enum_variant_type, "INT16_TYPE",
- &ret_size_t) == 0,
- "bt_ctf_field_type_enumeration_get_mapping_index_by_name returns a value");
- ok(ret_size_t == 1,
+ ok(bt_ctf_field_type_enumeration_get_mapping_index_by_name(
+ enum_variant_type, "INT16_TYPE") == 1,
"bt_ctf_field_type_enumeration_get_mapping_index_by_name returns the correct index");
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(NULL, 1, &ret_size_t) < 0,
+ ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(NULL, 1) < 0,
"bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value handles a NULL field type correctly");
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(enum_variant_type, 1, NULL) < 0,
- "bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value handles a NULL index correctly");
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(enum_variant_type, -42, &ret_size_t) < 0,
+ ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(enum_variant_type, -42) < 0,
"bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value handles invalid values correctly");
- ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(enum_variant_type, 5, &ret_size_t) == 0,
- "bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value handles invalid values correctly");
- ok(ret_size_t == 2,
+ ok(bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(enum_variant_type, 5) == 2,
"bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value returns the correct index");
ok(bt_ctf_field_type_variant_add_field(variant_type, uint_3_type,
ok(uint_35_field, "Use bt_ctf_event_get_payload to get a field instance ");
bt_ctf_field_unsigned_integer_set_value(uint_35_field, 0x0DDF00D);
- ok(bt_ctf_field_unsigned_integer_get_value(NULL, &ret_unsigned_int) == -1,
+ ok(bt_ctf_field_unsigned_integer_get_value(NULL, &ret_unsigned_int) < 0,
"bt_ctf_field_unsigned_integer_get_value properly properly handles a NULL field.");
- ok(bt_ctf_field_unsigned_integer_get_value(uint_35_field, NULL) == -1,
+ ok(bt_ctf_field_unsigned_integer_get_value(uint_35_field, NULL) < 0,
"bt_ctf_field_unsigned_integer_get_value properly handles a NULL return value");
ok(bt_ctf_field_unsigned_integer_get_value(uint_35_field,
&ret_unsigned_int) == 0,
ok(ret_unsigned_int == 0x0DDF00D,
"bt_ctf_field_unsigned_integer_get_value returns the correct value");
ok(bt_ctf_field_signed_integer_get_value(uint_35_field,
- &ret_signed_int) == -1,
+ &ret_signed_int) < 0,
"bt_ctf_field_signed_integer_get_value fails on an unsigned field");
bt_ctf_field_put(uint_35_field);
int_16_field = bt_ctf_event_get_payload(event, "int_16");
bt_ctf_field_signed_integer_set_value(int_16_field, -12345);
- ok(bt_ctf_field_signed_integer_get_value(NULL, &ret_signed_int) == -1,
+ ok(bt_ctf_field_signed_integer_get_value(NULL, &ret_signed_int) < 0,
"bt_ctf_field_signed_integer_get_value properly handles a NULL field");
- ok(bt_ctf_field_signed_integer_get_value(int_16_field, NULL) == -1,
+ ok(bt_ctf_field_signed_integer_get_value(int_16_field, NULL) < 0,
"bt_ctf_field_signed_integer_get_value properly handles a NULL return value");
ok(bt_ctf_field_signed_integer_get_value(int_16_field,
&ret_signed_int) == 0,
ok(ret_signed_int == -12345,
"bt_ctf_field_signed_integer_get_value returns the correct value");
ok(bt_ctf_field_unsigned_integer_get_value(int_16_field,
- &ret_unsigned_int) == -1,
+ &ret_unsigned_int) < 0,
"bt_ctf_field_unsigned_integer_get_value fails on a signed field");
bt_ctf_field_put(int_16_field);
"bt_ctf_field_string_get_value correctly handles NULL");
ret_string = bt_ctf_field_string_get_value(a_string_field);
ok(ret_string, "bt_ctf_field_string_get_value returns a string");
- ok(!strcmp(ret_string, test_string),
+ ok(ret_string ? !strcmp(ret_string, test_string) : 0,
"bt_ctf_field_string_get_value returns a correct value");
bt_ctf_field_unsigned_integer_set_value(uint_35_field,
SEQUENCE_TEST_LENGTH);
}
events_appended = 1;
- ok(bt_ctf_stream_get_discarded_events_count(NULL, &ret_uint64) == -1,
+ ok(bt_ctf_stream_get_discarded_events_count(NULL, &ret_uint64) < 0,
"bt_ctf_stream_get_discarded_events_count handles a NULL stream correctly");
- ok(bt_ctf_stream_get_discarded_events_count(stream, NULL) == -1,
+ ok(bt_ctf_stream_get_discarded_events_count(stream, NULL) < 0,
"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,
char *metadata_string;
struct bt_ctf_writer *writer;
struct utsname name;
- char hostname[HOST_NAME_MAX];
+ char hostname[BABELTRACE_HOST_NAME_MAX];
struct bt_ctf_clock *clock, *ret_clock;
struct bt_ctf_stream_class *stream_class;
struct bt_ctf_stream *stream1;
const char *ret_string;
- struct bt_ctf_field_type *packet_context_type, *packet_context_field_type;
+ const unsigned char *ret_uuid;
+ unsigned char tmp_uuid[16] = { 0 };
+ struct bt_ctf_field_type *packet_context_type,
+ *packet_context_field_type,
+ *integer_type;
+ struct bt_ctf_trace *trace;
int ret;
if (argc < 3) {
printf("Usage: tests-ctf-writer path_to_ctf_parser_test path_to_babeltrace\n");
- exit(-1);
+ return -1;
}
plan_no_plan();
ok(writer, "bt_ctf_create succeeds in creating trace with path");
/* Add environment context to the trace */
- gethostname(hostname, HOST_NAME_MAX);
+ ret = gethostname(hostname, sizeof(hostname));
+ if (ret < 0) {
+ return ret;
+ }
ok(bt_ctf_writer_add_environment_field(writer, "host", hostname) == 0,
"Add host (%s) environment field to writer instance",
hostname);
ok(clock, "Clock created sucessfully");
returned_clock_name = bt_ctf_clock_get_name(clock);
ok(returned_clock_name, "bt_ctf_clock_get_name returns a clock name");
- ok(strcmp(returned_clock_name, clock_name) == 0,
+ ok(returned_clock_name ? !strcmp(returned_clock_name, clock_name) : 0,
"Returned clock name is valid");
returned_clock_description = bt_ctf_clock_get_description(clock);
returned_clock_description = bt_ctf_clock_get_description(clock);
ok(returned_clock_description,
"bt_ctf_clock_get_description returns a description.");
- ok(strcmp(returned_clock_description, clock_description) == 0,
+ ok(returned_clock_description ?
+ !strcmp(returned_clock_description, clock_description) : 0,
"Returned clock description is valid");
ok(bt_ctf_clock_get_frequency(clock) == DEFAULT_CLOCK_FREQ,
ok(bt_ctf_writer_add_clock(writer, clock),
"Verify a clock can't be added twice to a writer instance");
+ ok(!bt_ctf_writer_get_trace(NULL),
+ "bt_ctf_writer_get_trace correctly handles NULL");
+ trace = bt_ctf_writer_get_trace(writer);
+ ok(trace,
+ "bt_ctf_writer_get_trace returns a bt_ctf_trace object");
+ ok(bt_ctf_trace_get_clock_count(NULL) < 0,
+ "bt_ctf_trace_get_clock_count correctly handles NULL");
+ ok(bt_ctf_trace_get_clock_count(trace) == 1,
+ "bt_ctf_trace_get_clock_count returns the correct number of clocks");
+ ok(!bt_ctf_trace_get_clock(NULL, 0),
+ "bt_ctf_trace_get_clock correctly handles NULL");
+ ok(!bt_ctf_trace_get_clock(trace, -1),
+ "bt_ctf_trace_get_clock correctly handles negative indexes");
+ ok(!bt_ctf_trace_get_clock(trace, 1),
+ "bt_ctf_trace_get_clock correctly handles out of bound accesses");
+ ret_clock = bt_ctf_trace_get_clock(trace, 0);
+ ok(ret_clock == clock,
+ "bt_ctf_trace_get_clock returns the right clock instance");
+ bt_ctf_clock_put(ret_clock);
+
ok(!bt_ctf_clock_get_name(NULL),
"bt_ctf_clock_get_name correctly handles NULL");
ok(!bt_ctf_clock_get_description(NULL),
"bt_ctf_clock_get_offset_s correctly handles NULL");
ok(bt_ctf_clock_get_offset(NULL) == -1ULL,
"bt_ctf_clock_get_offset correctly handles NULL");
- ok(bt_ctf_clock_get_is_absolute(NULL) == -1,
+ ok(bt_ctf_clock_get_is_absolute(NULL) < 0,
"bt_ctf_clock_get_is_absolute correctly handles NULL");
ok(bt_ctf_clock_get_time(NULL) == -1ULL,
"bt_ctf_clock_get_time correctly handles NULL");
- ok(bt_ctf_clock_set_description(NULL, NULL) == -1,
+ ok(bt_ctf_clock_set_description(NULL, NULL) < 0,
"bt_ctf_clock_set_description correctly handles NULL clock");
- ok(bt_ctf_clock_set_frequency(NULL, frequency) == -1,
+ ok(bt_ctf_clock_set_frequency(NULL, frequency) < 0,
"bt_ctf_clock_set_frequency correctly handles NULL clock");
- ok(bt_ctf_clock_set_precision(NULL, precision) == -1,
+ ok(bt_ctf_clock_set_precision(NULL, precision) < 0,
"bt_ctf_clock_get_precision correctly handles NULL clock");
- ok(bt_ctf_clock_set_offset_s(NULL, offset_s) == -1,
+ ok(bt_ctf_clock_set_offset_s(NULL, offset_s) < 0,
"bt_ctf_clock_set_offset_s correctly handles NULL clock");
- ok(bt_ctf_clock_set_offset(NULL, offset) == -1,
+ ok(bt_ctf_clock_set_offset(NULL, offset) < 0,
"bt_ctf_clock_set_offset correctly handles NULL clock");
- ok(bt_ctf_clock_set_is_absolute(NULL, is_absolute) == -1,
+ ok(bt_ctf_clock_set_is_absolute(NULL, is_absolute) < 0,
"bt_ctf_clock_set_is_absolute correctly handles NULL clock");
- ok(bt_ctf_clock_set_time(NULL, current_time) == -1,
+ ok(bt_ctf_clock_set_time(NULL, current_time) < 0,
"bt_ctf_clock_set_time correctly handles NULL clock");
+ ok(bt_ctf_clock_get_uuid(NULL) == NULL,
+ "bt_ctf_clock_get_uuid correctly handles NULL clock");
+ ret_uuid = bt_ctf_clock_get_uuid(clock);
+ ok(ret_uuid,
+ "bt_ctf_clock_get_uuid returns a UUID");
+ if (ret_uuid) {
+ memcpy(tmp_uuid, ret_uuid, sizeof(tmp_uuid));
+ /* Slightly modify UUID */
+ tmp_uuid[sizeof(tmp_uuid) - 1]++;
+ }
+
+ ok(bt_ctf_clock_set_uuid(NULL, tmp_uuid) < 0,
+ "bt_ctf_clock_set_uuid correctly handles a NULL clock");
+ ok(bt_ctf_clock_set_uuid(clock, NULL) < 0,
+ "bt_ctf_clock_set_uuid correctly handles a NULL UUID");
+ ok(bt_ctf_clock_set_uuid(clock, tmp_uuid) == 0,
+ "bt_ctf_clock_set_uuid sets a new uuid succesfully");
+ ret_uuid = bt_ctf_clock_get_uuid(clock);
+ ok(ret_uuid,
+ "bt_ctf_clock_get_uuid returns a UUID after setting a new one");
+ ok(uuid_match(ret_uuid, tmp_uuid),
+ "bt_ctf_clock_get_uuid returns the correct UUID after setting a new one");
/* Define a stream class */
stream_class = bt_ctf_stream_class_create("test_stream");
"bt_ctf_stream_class_set_packet_context_type handles a NULL stream class correctly");
ok(bt_ctf_stream_class_set_packet_context_type(stream_class, NULL),
"bt_ctf_stream_class_set_packet_context_type handles a NULL packet context type correctly");
+
+ integer_type = bt_ctf_field_type_integer_create(32);
+ ok(bt_ctf_stream_class_set_packet_context_type(stream_class,
+ integer_type) < 0,
+ "bt_ctf_stream_class_set_packet_context_type rejects a packet context that is not a structure");
ret = bt_ctf_field_type_structure_add_field(packet_context_type,
packet_context_field_type, "custom_field");
ok(ret == 0, "Packet context field added successfully");
bt_ctf_stream_put(stream1);
bt_ctf_field_type_put(packet_context_type);
bt_ctf_field_type_put(packet_context_field_type);
+ bt_ctf_field_type_put(integer_type);
+ bt_ctf_trace_put(trace);
free(metadata_string);
/* Remove all trace files and delete temporary trace directory */