#include <babeltrace/ref.h>
#include <babeltrace/ctf/events.h>
#include <babeltrace/values.h>
+#include <glib.h>
#include <unistd.h>
#include <babeltrace/compat/stdlib-internal.h>
#include <stdio.h>
-#include <babeltrace/compat/utsname-internal.h>
#include <babeltrace/compat/limits-internal.h>
#include <babeltrace/compat/stdio-internal.h>
#include <string.h>
#include <assert.h>
-#include <sys/wait.h>
#include <fcntl.h>
#include "tap/tap.h"
#include <math.h>
#define DEFAULT_CLOCK_TIME 0
#define DEFAULT_CLOCK_VALUE 0
-#define NR_TESTS 622
+#define NR_TESTS 623
+
+struct bt_utsname {
+ char sysname[BABELTRACE_HOST_NAME_MAX];
+ char nodename[BABELTRACE_HOST_NAME_MAX];
+ char release[BABELTRACE_HOST_NAME_MAX];
+ char version[BABELTRACE_HOST_NAME_MAX];
+ char machine[BABELTRACE_HOST_NAME_MAX];
+};
static int64_t current_time = 42;
static unsigned int packet_resize_test_length = PACKET_RESIZE_TEST_DEF_LENGTH;
void validate_trace(char *parser_path, char *trace_path)
{
int ret = 0;
- char babeltrace_output_path[] = "/tmp/babeltrace_output_XXXXXX";
- int babeltrace_output_fd = -1;
+ gchar *standard_error = NULL;
+ gint exit_status;
+ char *argv[] = {parser_path, trace_path, NULL};
- if (!trace_path) {
+ if (!parser_path || !trace_path) {
ret = -1;
goto result;
}
- babeltrace_output_fd = mkstemp(babeltrace_output_path);
- unlink(babeltrace_output_path);
-
- if (babeltrace_output_fd == -1) {
- diag("Failed to create a temporary file for trace parsing.");
+ if (!g_spawn_sync(NULL,
+ argv,
+ NULL,
+ G_SPAWN_STDOUT_TO_DEV_NULL,
+ NULL,
+ NULL,
+ NULL,
+ &standard_error,
+ &exit_status,
+ NULL)) {
+ diag("Failed to spawn babeltrace.");
ret = -1;
goto result;
}
- pid_t pid = fork();
- if (pid) {
- int status = 0;
- waitpid(pid, &status, 0);
- ret = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
- } else {
- ret = dup2(babeltrace_output_fd, STDOUT_FILENO);
- if (ret < 0) {
- perror("# dup2 babeltrace_output_fd to STDOUT");
- goto result;
- }
-
- ret = dup2(babeltrace_output_fd, STDERR_FILENO);
- if (ret < 0) {
- perror("# dup2 babeltrace_output_fd to STDERR");
- goto result;
- }
+ /* Replace by g_spawn_check_exit_status when we require glib >= 2.34 */
+#ifdef G_OS_UNIX
+ ret = WIFEXITED(exit_status) ? WEXITSTATUS(exit_status) : -1;
+#else
+ ret = exit_status;
+#endif
- execl(parser_path, parser_path, trace_path, NULL);
- perror("# Could not launch the babeltrace process");
- exit(-1);
+ if (ret != 0) {
+ diag("Babeltrace returned an error.");
+ diag_multiline(standard_error);
+ goto result;
}
+
result:
ok(ret == 0, "Babeltrace could read the resulting trace");
-
- if (ret && babeltrace_output_fd >= 0) {
- char *line;
- size_t len = METADATA_LINE_SIZE;
- FILE *babeltrace_output_fp = NULL;
-
- babeltrace_output_fp = fdopen(babeltrace_output_fd, "r");
- if (!babeltrace_output_fp) {
- perror("fdopen on babeltrace_output_fd");
- goto close_fp;
- }
- babeltrace_output_fd = -1;
-
- line = malloc(len);
- if (!line) {
- diag("malloc error");
- }
- rewind(babeltrace_output_fp);
- while (bt_getline(&line, &len, babeltrace_output_fp) > 0) {
- diag("%s", line);
- }
-
- free(line);
-close_fp:
- if (babeltrace_output_fp) {
- if (fclose(babeltrace_output_fp)) {
- diag("fclose error");
- }
- }
- }
-
- if (babeltrace_output_fd >= 0) {
- if (close(babeltrace_output_fd)) {
- diag("close error");
- }
- }
+ g_free(standard_error);
}
static
ok(iter == NULL, "bt_ctf_field_type_enumeration_find_mappings_by_signed_value handles a NULL field type correctly");
iter = bt_ctf_field_type_enumeration_find_mappings_by_signed_value(enum_type, -4200000);
- ok(iter == NULL, "bt_ctf_field_type_enumeration_find_mappings_by_signed_value rejects non-mapped values");
+ ret = bt_ctf_field_type_enumeration_mapping_iterator_next(iter);
+ ok(iter && ret, "bt_ctf_field_type_enumeration_find_mappings_by_signed_value rejects non-mapped values");
+ BT_PUT(iter);
iter = bt_ctf_field_type_enumeration_find_mappings_by_signed_value(enum_type, 3);
ok(iter != NULL, "bt_ctf_field_type_enumeration_find_mappings_by_signed_value succeeds with mapped value");
- ok(bt_ctf_field_type_enumeration_mapping_iterator_get_signed(iter, NULL, NULL, NULL) == 0,
+ ret = bt_ctf_field_type_enumeration_mapping_iterator_next(iter);
+ ok(!ret && bt_ctf_field_type_enumeration_mapping_iterator_get_signed(iter, NULL, NULL, NULL) == 0,
"bt_ctf_field_type_enumeration_mapping_iterator_get_signed handles mapped values correctly");
BT_PUT(iter);
"Set signed enumeration container value");
iter = bt_ctf_field_enumeration_get_mappings(enum_field);
ok(iter, "bt_ctf_field_enumeration_get_mappings returns an iterator to matching mappings");
+ ret = bt_ctf_field_type_enumeration_mapping_iterator_next(iter);
+ ok(!ret, "bt_ctf_field_enumeration_get_mappings returned a non-empty match");
ret = bt_ctf_field_type_enumeration_mapping_iterator_get_signed(iter, &ret_char, NULL, NULL);
ok(!ret && ret_char, "bt_ctf_field_type_enumeration_mapping_iterator_get_signed return a mapping name");
assert(ret_char);
assert(!ret);
iter = bt_ctf_field_enumeration_get_mappings(enum_field_unsigned);
assert(iter);
+ ret = bt_ctf_field_type_enumeration_mapping_iterator_next(iter);
+ assert(!ret);
(void) bt_ctf_field_type_enumeration_mapping_iterator_get_unsigned(iter, &ret_char, NULL, NULL);
ok(ret_char && !strcmp(ret_char, mapping_name_test),
"bt_ctf_field_type_enumeration_mapping_iterator_get_unsigned returns the correct mapping name with an unsigned container");
void append_complex_event(struct bt_ctf_stream_class *stream_class,
struct bt_ctf_stream *stream, struct bt_ctf_clock *clock)
{
- int i;
+ int i, ret;
struct event_class_attrs_counts ;
const char *complex_test_event_string = "Complex Test Event";
const char *test_string_1 = "Test ";
ok(iter == NULL, "bt_ctf_field_type_enumeration_find_mappings_by_name handles a NULL field type correctly");
iter = bt_ctf_field_type_enumeration_find_mappings_by_name(enum_variant_type, "INT16_TYPE");
- ok(iter != NULL, "bt_ctf_field_type_enumeration_find_mappings_by_name handles an existing mapping correctly");
+ ok(iter != NULL, "bt_ctf_field_type_enumeration_find_mappings_by_name returns a non-NULL iterator");
+ ret = bt_ctf_field_type_enumeration_mapping_iterator_next(iter);
+ ok(!ret, "bt_ctf_field_type_enumeration_find_mappings_by_name handles an existing mapping correctly");
ok(bt_ctf_field_type_enumeration_mapping_iterator_get_unsigned(iter, NULL, NULL, NULL) == 0,
"bt_ctf_field_type_enumeration_mapping_iterator_get_unsigned handles mapped values correctly");
BT_PUT(iter);
iter = bt_ctf_field_type_enumeration_find_mappings_by_name(enum_variant_type, NULL);
- ok(iter == NULL, "bt_ctf_field_type_enumeration_find_mappings_by_name handles a NULL name correctly");
+ ret = bt_ctf_field_type_enumeration_mapping_iterator_next(iter);
+ ok(iter && ret, "bt_ctf_field_type_enumeration_find_mappings_by_name handles a NULL name correctly");
+ BT_PUT(iter);
iter = bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value(NULL, 1);
ok(iter == NULL, "bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value handles a NULL field type correctly");
iter = bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value(enum_variant_type, -42);
- ok(iter == NULL, "bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value handles invalid values correctly");
+ ret = bt_ctf_field_type_enumeration_mapping_iterator_next(iter);
+ ok(iter && ret, "bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value handles invalid values correctly");
ok(bt_ctf_field_type_enumeration_mapping_iterator_get_unsigned(iter, NULL, NULL, NULL) != 0,
"bt_ctf_field_type_enumeration_mapping_iterator_get_unsigned handles invalid values correctly");
BT_PUT(iter);
iter = bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value(enum_variant_type, 5);
- ok(iter != NULL, "bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value handles valid values correctly");
+ ret = bt_ctf_field_type_enumeration_mapping_iterator_next(iter);
+ ok(iter != NULL && !ret, "bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value handles valid values correctly");
ok(bt_ctf_field_type_enumeration_mapping_iterator_get_unsigned(iter, NULL, NULL, NULL) == 0,
"bt_ctf_field_type_enumeration_mapping_iterator_get_unsigned handles valid values correctly");
BT_PUT(iter);
/* validate e copy */
e_iter = bt_ctf_field_enumeration_get_mappings(e_copy);
+ (void) bt_ctf_field_type_enumeration_mapping_iterator_next(e_iter);
(void) bt_ctf_field_type_enumeration_mapping_iterator_get_signed(e_iter,
&str_val, NULL, NULL);
ok(str_val && !strcmp(str_val, "LABEL2"),
void test_create_writer_vs_non_writer_mode(void)
{
int ret;
- char trace_path[] = "/tmp/ctfwriter_XXXXXX";
+ gchar *trace_path;
const char *writer_stream_name = "writer stream instance";
struct bt_ctf_writer *writer = NULL;
struct bt_ctf_trace *writer_trace = NULL;
struct bt_ctf_packet *packet = NULL;
struct bt_ctf_packet *packet2 = NULL;
+ trace_path = g_build_filename(g_get_tmp_dir(), "ctfwriter_XXXXXX", NULL);
if (!bt_mkdtemp(trace_path)) {
perror("# perror");
}
bt_put(packet);
bt_put(packet2);
recursive_rmdir(trace_path);
+ g_free(trace_path);
}
static
static
void trace_is_static_listener(struct bt_ctf_trace *trace, void *data)
{
- *((int *) data) = 1;
+ *((int *) data) |= 1;
+}
+
+static
+void trace_listener_removed(struct bt_ctf_trace *trace, void *data)
+{
+ *((int *) data) |= 2;
}
static
trace = bt_ctf_trace_create();
assert(trace);
ret = bt_ctf_trace_add_is_static_listener(NULL,
- trace_is_static_listener, &called1);
+ trace_is_static_listener, trace_listener_removed, &called1);
ok(ret < 0, "bt_ctf_trace_add_is_static_listener() handles NULL (trace)");
- ret = bt_ctf_trace_add_is_static_listener(trace, NULL, &called1);
+ ret = bt_ctf_trace_add_is_static_listener(trace, NULL,
+ trace_listener_removed, &called1);
ok(ret < 0, "bt_ctf_trace_add_is_static_listener() handles NULL (listener)");
listener1_id = bt_ctf_trace_add_is_static_listener(trace,
- trace_is_static_listener, &called1);
+ trace_is_static_listener, trace_listener_removed, &called1);
ok(listener1_id >= 0, "bt_ctf_trace_add_is_static_listener() succeeds (1)");
listener2_id = bt_ctf_trace_add_is_static_listener(trace,
- trace_is_static_listener, &called2);
+ trace_is_static_listener, trace_listener_removed, &called2);
ok(listener2_id >= 0, "bt_ctf_trace_add_is_static_listener() succeeds (2)");
listener3_id = bt_ctf_trace_add_is_static_listener(trace,
- trace_is_static_listener, &called3);
+ trace_is_static_listener, trace_listener_removed, &called3);
ok(listener3_id >= 0, "bt_ctf_trace_add_is_static_listener() succeeds (3)");
ret = bt_ctf_trace_remove_is_static_listener(NULL, 0);
ok(ret < 0, "bt_ctf_trace_remove_is_static_listener() handles NULL (trace)");
ok(ret < 0, "bt_ctf_trace_remove_is_static_listener() handles invalid ID (non existing)");
ret = bt_ctf_trace_remove_is_static_listener(trace, listener2_id);
ok(ret == 0, "bt_ctf_trace_remove_is_static_listener() succeeds");
+ ok(called2 == 2, "bt_ctf_trace_remove_is_static_listener() calls the remove listener");
listener4_id = bt_ctf_trace_add_is_static_listener(trace,
- trace_is_static_listener, &called4);
+ trace_is_static_listener, NULL, &called4);
ok(listener4_id >= 0, "bt_ctf_trace_add_is_static_listener() succeeds (4)");
ok(called1 == 0, "\"trace is static\" listener not called before the trace is made static (1)");
- ok(called2 == 0, "\"trace is static\" listener not called before the trace is made static (2)");
+ ok(called2 == 2, "\"trace is static\" listener not called before the trace is made static (2)");
ok(called3 == 0, "\"trace is static\" listener not called before the trace is made static (3)");
ok(called4 == 0, "\"trace is static\" listener not called before the trace is made static (4)");
ret = bt_ctf_trace_set_is_static(trace);
assert(ret == 0);
ret = bt_ctf_trace_add_is_static_listener(trace,
- trace_is_static_listener, &called1);
+ trace_is_static_listener, trace_listener_removed, &called1);
ok(ret < 0,
"bt_ctf_trace_add_is_static_listener() fails when the trace is static");
ok(called1 == 1, "\"trace is static\" listener called when the trace is made static (1)");
- ok(called2 == 0, "\"trace is static\" listener not called when the trace is made static (2)");
+ ok(called2 == 2, "\"trace is static\" listener not called when the trace is made static (2)");
ok(called3 == 1, "\"trace is static\" listener called when the trace is made static (3)");
ok(called4 == 1, "\"trace is static\" listener called when the trace is made static (4)");
called1 = 0;
called3 = 0;
called4 = 0;
bt_put(trace);
- ok(called1 == 0, "\"trace is static\" listener not called after the trace is put (1)");
+ ok(called1 == 2, "\"trace is static\" listener not called after the trace is put (1)");
ok(called2 == 0, "\"trace is static\" listener not called after the trace is put (2)");
- ok(called3 == 0, "\"trace is static\" listener not called after the trace is put (3)");
+ ok(called3 == 2, "\"trace is static\" listener not called after the trace is put (3)");
ok(called4 == 0, "\"trace is static\" listener not called after the trace is put (4)");
}
int main(int argc, char **argv)
{
const char *env_resize_length;
- char trace_path[] = "/tmp/ctfwriter_XXXXXX";
- char metadata_path[sizeof(trace_path) + 9];
+ gchar *trace_path;
+ gchar *metadata_path;
const char *clock_name = "test_clock";
const char *clock_description = "This is a test clock";
const char *returned_clock_name;
const int is_absolute = 0xFF;
char *metadata_string;
struct bt_ctf_writer *writer;
- struct utsname name;
- char hostname[BABELTRACE_HOST_NAME_MAX];
+ struct bt_utsname name = {"GNU/Linux", "testhost", "4.4.0-87-generic",
+ "#110-Ubuntu SMP Tue Jul 18 12:55:35 UTC 2017", "x86_64"};
struct bt_ctf_clock *clock, *ret_clock;
struct bt_ctf_clock_class *ret_clock_class;
struct bt_ctf_stream_class *stream_class, *ret_stream_class;
plan_tests(NR_TESTS);
+ trace_path = g_build_filename(g_get_tmp_dir(), "ctfwriter_XXXXXX", NULL);
if (!bt_mkdtemp(trace_path)) {
perror("# perror");
}
- strcpy(metadata_path, trace_path);
- strcat(metadata_path + sizeof(trace_path) - 1, "/metadata");
+ metadata_path = g_build_filename(trace_path, "metadata", NULL);
writer = bt_ctf_writer_create(trace_path);
ok(writer, "bt_ctf_create succeeds in creating trace with path");
"bt_ctf_trace_get_native_byte_order returns a correct endianness");
/* Add environment context to the trace */
- ret = gethostname(hostname, sizeof(hostname));
- if (ret < 0) {
- return ret;
- }
- ok(bt_ctf_writer_add_environment_field(writer, "host", hostname) == 0,
+ ok(bt_ctf_writer_add_environment_field(writer, "host", name.nodename) == 0,
"Add host (%s) environment field to writer instance",
- hostname);
+ name.nodename);
ok(bt_ctf_writer_add_environment_field(NULL, "test_field",
"test_value"),
"bt_ctf_writer_add_environment_field error with NULL writer");
"bt_ctf_trace_get_environment_field_value successfully replaces an existing field");
BT_PUT(obj);
- /* On Solaris, uname() can return any positive value on success */
- if (uname(&name) < 0) {
- perror("uname");
- return -1;
- }
-
ok(bt_ctf_writer_add_environment_field(writer, "sysname", name.sysname)
== 0, "Add sysname (%s) environment field to writer instance",
name.sysname);
validate_trace(argv[1], trace_path);
- //recursive_rmdir(trace_path);
+ recursive_rmdir(trace_path);
+ g_free(trace_path);
+ g_free(metadata_path);
+
return 0;
}
projects / babeltrace.git / blobdiff