#include <babeltrace/ctf/events.h>
#include <babeltrace/values.h>
#include <unistd.h>
-#include <babeltrace/compat/stdlib.h>
+#include <babeltrace/compat/stdlib-internal.h>
#include <stdio.h>
#include <sys/utsname.h>
-#include <babeltrace/compat/limits.h>
-#include <babeltrace/compat/stdio.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 <babeltrace/compat/dirent.h>
+#include <babeltrace/compat/dirent-internal.h>
#include "tap/tap.h"
#include <math.h>
#include <float.h>
#define DEFAULT_CLOCK_TIME 0
#define DEFAULT_CLOCK_VALUE 0
-#define NR_TESTS 602
+#define NR_TESTS 601
static int64_t current_time = 42;
return ret;
}
-static
-void validate_metadata(char *parser_path, char *metadata_path)
-{
- int ret = 0;
- char parser_output_path[] = "/tmp/parser_output_XXXXXX";
- int parser_output_fd = -1, metadata_fd = -1;
-
- if (!metadata_path) {
- ret = -1;
- goto result;
- }
-
- parser_output_fd = mkstemp(parser_output_path);
- metadata_fd = open(metadata_path, O_RDONLY);
-
- unlink(parser_output_path);
-
- if (parser_output_fd == -1 || metadata_fd == -1) {
- diag("Failed create temporary files for metadata parsing.");
- ret = -1;
- goto result;
- }
-
- pid_t pid = fork();
- if (pid) {
- int status = 0;
- waitpid(pid, &status, 0);
- ret = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
- } else {
- /* ctf-parser-test expects a metadata string on stdin. */
- ret = dup2(metadata_fd, STDIN_FILENO);
- if (ret < 0) {
- perror("# dup2 metadata_fd to STDIN");
- goto result;
- }
-
- ret = dup2(parser_output_fd, STDOUT_FILENO);
- if (ret < 0) {
- perror("# dup2 parser_output_fd to STDOUT");
- goto result;
- }
-
- ret = dup2(parser_output_fd, STDERR_FILENO);
- if (ret < 0) {
- perror("# dup2 parser_output_fd to STDERR");
- goto result;
- }
-
- execl(parser_path, "ctf-parser-test", NULL);
- perror("# Could not launch the ctf metadata parser process");
- exit(-1);
- }
-result:
- ok(ret == 0, "Metadata string is valid");
-
- if (ret && metadata_fd >= 0 && parser_output_fd >= 0) {
- char *line;
- size_t len = METADATA_LINE_SIZE;
- FILE *metadata_fp = NULL, *parser_output_fp = NULL;
-
- metadata_fp = fdopen(metadata_fd, "r");
- if (!metadata_fp) {
- perror("fdopen on metadata_fd");
- goto close_fp;
- }
- metadata_fd = -1;
-
- parser_output_fp = fdopen(parser_output_fd, "r");
- if (!parser_output_fp) {
- perror("fdopen on parser_output_fd");
- goto close_fp;
- }
- parser_output_fd = -1;
-
- line = malloc(len);
- if (!line) {
- diag("malloc failure");
- }
-
- rewind(metadata_fp);
-
- /* Output the metadata and parser output as diagnostic */
- while (bt_getline(&line, &len, metadata_fp) > 0) {
- fprintf(stderr, "# %s", line);
- }
-
- rewind(parser_output_fp);
- while (bt_getline(&line, &len, parser_output_fp) > 0) {
- fprintf(stderr, "# %s", line);
- }
-
- free(line);
-close_fp:
- if (metadata_fp) {
- if (fclose(metadata_fp)) {
- diag("fclose failure");
- }
- }
- if (parser_output_fp) {
- if (fclose(parser_output_fp)) {
- diag("fclose failure");
- }
- }
- }
-
- if (parser_output_fd >= 0) {
- if (close(parser_output_fd)) {
- diag("close error");
- }
- }
- if (metadata_fd >= 0) {
- if (close(metadata_fd)) {
- diag("close error");
- }
- }
-}
-
static
void validate_trace(char *parser_path, char *trace_path)
{
"bt_ctf_field_type_get_byte_order handles NULL correctly");
ok(bt_ctf_field_type_get_type_id(NULL) ==
- BT_CTF_TYPE_ID_UNKNOWN,
+ BT_CTF_FIELD_TYPE_ID_UNKNOWN,
"bt_ctf_field_type_get_type_id handles NULL correctly");
ok(bt_ctf_field_type_get_type_id(uint_12_type) ==
- BT_CTF_TYPE_ID_INTEGER,
+ BT_CTF_FIELD_TYPE_ID_INTEGER,
"bt_ctf_field_type_get_type_id returns a correct value with an integer type");
ok(bt_ctf_field_type_integer_get_base(NULL) ==
bt_ctf_field_type_sequence_create(int_16_type, "seq_len");
ok(sequence_type, "Create a sequence of int16_t type");
ok(bt_ctf_field_type_get_type_id(sequence_type) ==
- BT_CTF_TYPE_ID_SEQUENCE,
+ BT_CTF_FIELD_TYPE_ID_SEQUENCE,
"bt_ctf_field_type_get_type_id returns a correct value with a sequence type");
ok(bt_ctf_field_type_sequence_get_length_field_name(NULL) == NULL,
structure_seq_type = bt_ctf_field_type_structure_create();
ok(bt_ctf_field_type_get_type_id(structure_seq_type) ==
- BT_CTF_TYPE_ID_STRUCT,
+ BT_CTF_FIELD_TYPE_ID_STRUCT,
"bt_ctf_field_type_get_type_id returns a correct value with a structure type");
ok(structure_seq_type, "Create a structure type");
ok(bt_ctf_field_type_structure_add_field(structure_seq_type,
/* Create writer, writer stream class, stream, and clock */
writer = bt_ctf_writer_create(trace_path);
assert(writer);
+ ret = bt_ctf_writer_set_byte_order(writer, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
+ assert(!ret);
writer_trace = bt_ctf_writer_get_trace(writer);
ok(writer_trace, "bt_ctf_writer_get_trace() returns a trace");
writer_sc = bt_ctf_stream_class_create("writer_sc");
/* Create non-writer trace, stream class, stream, and clock */
non_writer_trace = bt_ctf_trace_create();
assert(non_writer_trace);
+ ret = bt_ctf_trace_set_native_byte_order(non_writer_trace,
+ BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
+ assert(!ret);
non_writer_sc = bt_ctf_stream_class_create("nonwriter_sc");
assert(non_writer_sc);
ret = bt_ctf_stream_class_set_event_header_type(non_writer_sc,
int64_t ret_int64_t;
struct bt_value *obj;
- if (argc < 3) {
- printf("Usage: tests-ctf-writer path_to_ctf_parser_test path_to_babeltrace\n");
+ if (argc < 2) {
+ printf("Usage: tests-ctf-writer path_to_babeltrace\n");
return -1;
}
trace = bt_ctf_writer_get_trace(writer);
ok(trace,
"bt_ctf_writer_get_trace returns a bt_ctf_trace object");
- ok(bt_ctf_trace_set_byte_order(trace, BT_CTF_BYTE_ORDER_BIG_ENDIAN) == 0,
+ ok(bt_ctf_trace_set_native_byte_order(trace, BT_CTF_BYTE_ORDER_BIG_ENDIAN) == 0,
"Set a trace's byte order to big endian");
ok(bt_ctf_trace_get_byte_order(trace) == BT_CTF_BYTE_ORDER_BIG_ENDIAN,
"bt_ctf_trace_get_byte_order returns a correct endianness");
stream_class);
ok(ret_field_type,
"bt_ctf_stream_class_get_event_header_type returns an event header type");
- ok(bt_ctf_field_type_get_type_id(ret_field_type) == BT_CTF_TYPE_ID_STRUCT,
+ ok(bt_ctf_field_type_get_type_id(ret_field_type) == BT_CTF_FIELD_TYPE_ID_STRUCT,
"Default event header type is a structure");
event_header_field_type =
bt_ctf_field_type_structure_get_field_type_by_name(
ok(event_header_field_type,
"Default event header type contains an \"id\" field");
ok(bt_ctf_field_type_get_type_id(
- event_header_field_type) == BT_CTF_TYPE_ID_INTEGER,
+ event_header_field_type) == BT_CTF_FIELD_TYPE_ID_INTEGER,
"Default event header \"id\" field is an integer");
bt_put(event_header_field_type);
event_header_field_type =
ok(event_header_field_type,
"Default event header type contains a \"timestamp\" field");
ok(bt_ctf_field_type_get_type_id(
- event_header_field_type) == BT_CTF_TYPE_ID_INTEGER,
+ event_header_field_type) == BT_CTF_FIELD_TYPE_ID_INTEGER,
"Default event header \"timestamp\" field is an integer");
bt_put(event_header_field_type);
bt_put(ret_field_type);
packet_header_type = bt_ctf_trace_get_packet_header_type(trace);
ok(packet_header_type,
"bt_ctf_trace_get_packet_header_type returns a packet header");
- ok(bt_ctf_field_type_get_type_id(packet_header_type) == BT_CTF_TYPE_ID_STRUCT,
+ ok(bt_ctf_field_type_get_type_id(packet_header_type) == BT_CTF_FIELD_TYPE_ID_STRUCT,
"bt_ctf_trace_get_packet_header_type returns a packet header of type struct");
ret_field_type = bt_ctf_field_type_structure_get_field_type_by_name(
packet_header_type, "magic");
packet_context_type = bt_ctf_stream_class_get_packet_context_type(stream_class);
ok(packet_context_type,
"bt_ctf_stream_class_get_packet_context_type returns a packet context type.");
- ok(bt_ctf_field_type_get_type_id(packet_context_type) == BT_CTF_TYPE_ID_STRUCT,
+ ok(bt_ctf_field_type_get_type_id(packet_context_type) == BT_CTF_FIELD_TYPE_ID_STRUCT,
"Packet context is a structure");
ok(bt_ctf_stream_class_set_packet_context_type(NULL, packet_context_type),
ok(metadata_string, "Get metadata string");
bt_ctf_writer_flush_metadata(writer);
- validate_metadata(argv[1], metadata_path);
- validate_trace(argv[2], trace_path);
bt_put(clock);
bt_put(ret_stream_class);
free(metadata_string);
bt_put(stream_class);
- recursive_rmdir(trace_path);
+ validate_trace(argv[1], trace_path);
+
+ //recursive_rmdir(trace_path);
return 0;
}