#include "tap/tap.h"
#include <math.h>
#include <float.h>
-#include <sys/stat.h>
+#include "common.h"
#define METADATA_LINE_SIZE 512
#define SEQUENCE_TEST_LENGTH 10
#define DEFAULT_CLOCK_TIME 0
#define DEFAULT_CLOCK_VALUE 0
-#define NR_TESTS 605
+#define NR_TESTS 604
static int64_t current_time = 42;
-static
-void delete_trace(const char *trace_path)
-{
- /* Remove all trace files and delete temporary trace directory */
- struct dirent *entry;
- DIR *trace_dir = opendir(trace_path);
-
- if (!trace_dir) {
- perror("# opendir");
- return;
- }
-
- while ((entry = readdir(trace_dir))) {
- struct stat st;
- char filename[PATH_MAX];
-
- if (snprintf(filename, sizeof(filename), "%s/%s",
- trace_path, entry->d_name) <= 0) {
- continue;
- }
-
- if (stat(filename, &st)) {
- continue;
- }
-
- if (S_ISREG(st.st_mode)) {
- unlinkat(bt_dirfd(trace_dir), entry->d_name, 0);
- }
- }
-
- rmdir(trace_path);
- closedir(trace_dir);
-}
-
/* Return 1 if uuids match, zero if different. */
static
int uuid_match(const unsigned char *uuid_a, const unsigned char *uuid_b)
double ret_double;
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;
struct bt_ctf_field *packet_context;
struct bt_ctf_field *packet_context_field;
ok(uint_12_type, "Create an unsigned integer type");
- bt_ctf_field_type_integer_set_signed(int_64_type, 1);
+ ok(!bt_ctf_field_type_integer_set_signed(int_64_type, 1),
+ "Set signed 64 bit integer signedness to true");
ok(int_64_type, "Create a signed integer type");
enum_type = bt_ctf_field_type_enumeration_create(int_64_type);
"bt_ctf_event_class_get_context_type returns the appropriate type");
bt_put(returned_type);
- bt_ctf_stream_class_add_event_class(stream_class, simple_event_class);
+ ok(!bt_ctf_stream_class_add_event_class(stream_class, simple_event_class),
+ "Adding simple event class to stream class");
/*
* bt_ctf_stream_class_add_event_class() copies the field types
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_put(clock);
-
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",
"bt_ctf_field_type_set_alignment handles wrong alignment correctly (24)");
ok(!bt_ctf_field_type_set_alignment(int_16_type, 4),
"bt_ctf_field_type_set_alignment handles correct alignment correctly (4)");
- 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);
+ ok(!bt_ctf_field_type_set_alignment(int_16_type, 32),
+ "Set alignment of signed 16 bit integer to 32");
+ ok(!bt_ctf_field_type_integer_set_signed(int_16_type, 1),
+ "Set integer signedness to true");
+ ok(!bt_ctf_field_type_integer_set_base(uint_35_type,
+ BT_CTF_INTEGER_BASE_HEXADECIMAL),
+ "Set signed 16 bit integer base to 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,
ok(bt_ctf_field_type_array_get_length(array_type) == ARRAY_TEST_LENGTH,
"bt_ctf_field_type_array_get_length returns the correct length");
- bt_ctf_field_type_structure_add_field(inner_structure_type,
- 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");
+ ok(!bt_ctf_field_type_structure_add_field(inner_structure_type,
+ uint_35_type, "seq_len"), "Add seq_len field to inner structure");
+ ok(!bt_ctf_field_type_structure_add_field(inner_structure_type,
+ sequence_type, "a_sequence"), "Add a_sequence field to inner structure");
+ ok(!bt_ctf_field_type_structure_add_field(inner_structure_type,
+ array_type, "an_array"), "Add an_array field to inner structure");
bt_ctf_field_type_enumeration_add_mapping(enum_variant_type,
"UINT3_TYPE", 0, 0);
"An unknown entry"), "Reject a variant field based on an unknown tag value");
ok(bt_ctf_field_type_variant_add_field(variant_type, uint_3_type,
"UINT3_TYPE") == 0, "Add a field to a variant");
- bt_ctf_field_type_variant_add_field(variant_type, int_16_type,
- "INT16_TYPE");
- bt_ctf_field_type_variant_add_field(variant_type, uint_35_type,
- "UINT35_TYPE");
+ ok(!bt_ctf_field_type_variant_add_field(variant_type, int_16_type,
+ "INT16_TYPE"), "Add INT16_TYPE field to variant");
+ ok(!bt_ctf_field_type_variant_add_field(variant_type, uint_35_type,
+ "UINT35_TYPE"), "Add UINT35_TYPE field to variant");
ok(bt_ctf_field_type_variant_get_tag_type(NULL) == NULL,
"bt_ctf_field_type_variant_get_tag_type handles NULL correctly");
"bt_ctf_field_type_variant_get_field returns a correct field type");
bt_put(ret_field_type);
- bt_ctf_field_type_structure_add_field(complex_structure_type,
- enum_variant_type, "variant_selector");
- bt_ctf_field_type_structure_add_field(complex_structure_type,
- string_type, "a_string");
- bt_ctf_field_type_structure_add_field(complex_structure_type,
- variant_type, "variant_value");
- bt_ctf_field_type_structure_add_field(complex_structure_type,
- inner_structure_type, "inner_structure");
+ ok(!bt_ctf_field_type_structure_add_field(complex_structure_type,
+ enum_variant_type, "variant_selector"),
+ "Add variant_selector field to complex structure");
+ ok(!bt_ctf_field_type_structure_add_field(complex_structure_type,
+ string_type, "a_string"), "Add a_string field to complex structure");
+ ok(!bt_ctf_field_type_structure_add_field(complex_structure_type,
+ variant_type, "variant_value"),
+ "Add variant_value field to complex structure");
+ ok(!bt_ctf_field_type_structure_add_field(complex_structure_type,
+ inner_structure_type, "inner_structure"),
+ "Add inner_structure field to complex structure");
ok(bt_ctf_event_class_create("clock") == NULL,
"Reject creation of an event class with an illegal name");
"bt_ctf_field_type_integer_get_encoding returns a correct value");
int_16_type = bt_ctf_field_type_integer_create(16);
- bt_ctf_field_type_integer_set_signed(int_16_type, 1);
+ assert(int_16_type);
+ ok(!bt_ctf_field_type_integer_set_signed(int_16_type, 1),
+ "Set signedness of 16 bit integer to true");
ok(bt_ctf_field_type_integer_get_signed(int_16_type) == 1,
"bt_ctf_field_type_integer_get_signed returns a correct value for signed types");
uint_8_type = bt_ctf_field_type_integer_create(8);
ok(!bt_ctf_stream_append_event(writer_stream, event),
"bt_ctf_stream_append_event() succeeds with a writer stream");
- /*
- * Verify that it's possible to get and set the value of a
- * writer mode clock.
- */
- ok (!bt_ctf_clock_set_value(writer_clock, 1000),
- "bt_ctf_clock_set_value() succeeds with a writer mode clock");
- ok (bt_ctf_clock_get_value(writer_clock) == 1000,
- "bt_ctf_clock_get_value() succeeds with a writer mode clock");
-
- /*
- * Verify that it's impossible to get and set the value of a
- * non-writer mode clock.
- */
- ok (bt_ctf_clock_set_value(non_writer_clock, 1000),
- "bt_ctf_clock_set_value() fails with a non-writer mode clock");
- ok (bt_ctf_clock_get_value(non_writer_clock) == -1ULL,
- "bt_ctf_clock_get_value() fails with a non-writer mode clock");
-
/*
* It should be possible to create a packet from a non-writer
* stream, but not from a writer stream.
bt_put(non_writer_clock);
bt_put(packet);
bt_put(packet2);
- delete_trace(trace_path);
+ recursive_rmdir(trace_path);
}
static
assert(!ret);
ret = bt_ctf_clock_set_frequency(clock, 1000000000);
assert(!ret);
- ok(bt_ctf_clock_ns_from_value(clock, 4321) == 1234000005321ULL,
- "bt_ctf_clock_ns_from_value() returns the correct value with a 1 GHz frequency");
ret = bt_ctf_clock_set_frequency(clock, 1534);
assert(!ret);
- ok(bt_ctf_clock_ns_from_value(clock, 4321) ==
- (uint64_t) 1237468709256.845,
- "bt_ctf_clock_ns_from_value() returns the correct value with a non-1 GHz frequency");
BT_PUT(clock);
}
const int64_t offset_s = 1351530929945824323;
const int64_t offset = 1234567;
int64_t get_offset_s,
- get_offset,
- get_time;
+ get_offset;
const uint64_t precision = 10;
const int is_absolute = 0xFF;
char *metadata_string;
/* Define a clock and add it to the trace */
ok(bt_ctf_clock_create("signed") == NULL,
"Illegal clock name rejected");
- ok(bt_ctf_clock_create(NULL) == NULL, "NULL clock name rejected");
clock = bt_ctf_clock_create(clock_name);
ok(clock, "Clock created sucessfully");
returned_clock_name = bt_ctf_clock_get_name(clock);
ok(bt_ctf_clock_get_is_absolute(clock) == !!is_absolute,
"bt_ctf_clock_get_precision returns the correct is_absolute attribute once it is set");
- ok(bt_ctf_clock_get_time(clock, &get_time) == 0,
- "bt_ctf_clock_get_time succeeds");
- ok(get_time == DEFAULT_CLOCK_TIME,
- "bt_ctf_clock_get_time returns the correct default time");
- ok(bt_ctf_clock_get_value(clock) == DEFAULT_CLOCK_VALUE,
- "bt_ctf_clock_get_value returns the correct default value");
- ok(bt_ctf_clock_set_value(clock, current_time) == 0,
- "Set clock value");
- ok(bt_ctf_clock_get_value(clock) == current_time,
- "bt_ctf_clock_get_value returns the correct value once it is set");
ok(bt_ctf_clock_set_time(clock, current_time) == 0,
"Set clock time");
- ok(bt_ctf_clock_get_time(clock, &get_time) == 0,
- "bt_ctf_clock_get_time succeeds");
- ok(get_time >= current_time - 1 && get_time <= current_time + 1,
- "bt_ctf_clock_get_time returns the correct time once it is set");
ok(!bt_ctf_clock_get_name(NULL),
"bt_ctf_clock_get_name correctly handles NULL");
"bt_ctf_clock_get_offset correctly handles NULL output");
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, &get_time) < 0,
- "bt_ctf_clock_get_time correctly handles NULL clock");
- ok(bt_ctf_clock_get_time(clock, NULL) < 0,
- "bt_ctf_clock_get_time correctly handles NULL output");
ok(bt_ctf_clock_set_description(NULL, NULL) < 0,
"bt_ctf_clock_set_description correctly handles 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");
+ "bt_ctf_clock_set_uuid sets a new uuid successfully");
ret_uuid = bt_ctf_clock_get_uuid(clock);
ok(ret_uuid,
"bt_ctf_clock_get_uuid returns a UUID after setting a new one");
free(metadata_string);
bt_put(stream_class);
- delete_trace(trace_path);
+ recursive_rmdir(trace_path);
return 0;
}
projects / babeltrace.git / blobdiff