* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#define _GNU_SOURCE
#include <babeltrace/ctf-writer/writer.h>
#include <babeltrace/ctf-writer/clock.h>
#include <babeltrace/ctf-writer/stream.h>
#include <babeltrace/ctf-writer/event-fields.h>
#include <babeltrace/ctf/events.h>
#include <unistd.h>
-#include <stdlib.h>
+#include <babeltrace/compat/stdlib.h>
#include <stdio.h>
#include <sys/utsname.h>
-#include <limits.h>
+#include <babeltrace/compat/limits.h>
+#include <babeltrace/compat/stdio.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
-#include <dirent.h>
+#include <babeltrace/compat/dirent.h>
#include "tap/tap.h"
+#include <sys/stat.h>
#define METADATA_LINE_SIZE 512
#define SEQUENCE_TEST_LENGTH 10
goto result;
}
- execl(parser_path, "ctf-parser-test", NULL);
+ execl(parser_path, "ctf-parser-test", (char *) NULL);
perror("# Could not launch the ctf metadata parser process");
exit(-1);
}
rewind(metadata_fp);
/* Output the metadata and parser output as diagnostic */
- while (getline(&line, &len, metadata_fp) > 0) {
+ while (bt_getline(&line, &len, metadata_fp) > 0) {
diag("%s", line);
}
rewind(parser_output_fp);
- while (getline(&line, &len, parser_output_fp) > 0) {
+ while (bt_getline(&line, &len, parser_output_fp) > 0) {
diag("%s", line);
}
goto result;
}
- execl(parser_path, "babeltrace", trace_path, NULL);
+ execl(parser_path, "babeltrace", trace_path, (char *) NULL);
perror("# Could not launch the babeltrace process");
exit(-1);
}
diag("malloc error");
}
rewind(babeltrace_output_fp);
- while (getline(&line, &len, babeltrace_output_fp) > 0) {
+ while (bt_getline(&line, &len, babeltrace_output_fp) > 0) {
diag("%s", line);
}
bt_ctf_field_type_integer_create(12);
struct bt_ctf_field_type *float_type =
bt_ctf_field_type_floating_point_create();
+ struct bt_ctf_field_type *enum_type =
+ bt_ctf_field_type_enumeration_create(uint_12_type);
struct bt_ctf_event *simple_event;
struct bt_ctf_field *integer_field;
struct bt_ctf_field *float_field;
+ struct bt_ctf_field *enum_field;
+ struct bt_ctf_field *enum_container_field;
bt_ctf_field_type_set_alignment(float_type, 32);
bt_ctf_field_type_floating_point_set_exponent_digits(float_type, 11);
bt_ctf_field_type_floating_point_set_mantissa_digits(float_type, 53);
+
+ ok(bt_ctf_field_type_enumeration_add_mapping(enum_type,
+ "escaping; \"test\"", 0, 0) == 0,
+ "Accept enumeration mapping strings containing quotes");
+ ok(bt_ctf_field_type_enumeration_add_mapping(enum_type,
+ "\tanother \'escaping\'\n test\"", 1, 4) == 0,
+ "Accept enumeration mapping strings containing special characters");
+ ok(bt_ctf_field_type_enumeration_add_mapping(enum_type,
+ "event clock int float", 5, 22) == 0,
+ "Accept enumeration mapping strings containing reserved keywords");
+ ok(bt_ctf_event_class_add_field(simple_event_class, enum_type,
+ "enum_field") == 0, "Add enumeration field to event");
+
ok(uint_12_type, "Create an unsigned integer type");
bt_ctf_event_class_add_field(simple_event_class, uint_12_type,
"integer_field");
float_field = bt_ctf_event_get_payload(simple_event, "float_field");
bt_ctf_field_floating_point_set_value(float_field, 3.1415);
+ enum_field = bt_ctf_field_create(enum_type);
+ enum_container_field = bt_ctf_field_enumeration_get_container(
+ enum_field);
+ ok(bt_ctf_field_unsigned_integer_set_value(
+ enum_container_field, 1) == 0,
+ "Set enumeration container value");
+ bt_ctf_event_set_payload(simple_event, "enum_field", enum_field);
ok(bt_ctf_clock_set_time(clock, current_time) == 0, "Set clock time");
bt_ctf_event_put(simple_event);
bt_ctf_field_type_put(uint_12_type);
bt_ctf_field_type_put(float_type);
+ bt_ctf_field_type_put(enum_type);
bt_ctf_field_put(integer_field);
bt_ctf_field_put(float_field);
+ bt_ctf_field_put(enum_field);
+ bt_ctf_field_put(enum_container_field);
}
void append_complex_event(struct bt_ctf_stream_class *stream_class,
struct bt_ctf_field *uint_12;
struct bt_ctf_field *int_16;
struct bt_ctf_field *string;
+ struct bt_ctf_field *enumeration;
struct bt_ctf_field_type *composite_structure_type;
struct bt_ctf_field_type *structure_seq_type;
struct bt_ctf_field_type *string_type;
struct bt_ctf_field_type *int_16_type;
struct bt_ctf_field_type *uint_12_type =
bt_ctf_field_type_integer_create(12);
+ struct bt_ctf_field_type *enumeration_type;
+ struct bt_ctf_field_type *enumeration_sequence_type;
+ struct bt_ctf_field_type *enumeration_array_type;
ok(uint_12_type, "Create an unsigned integer type");
ok(bt_ctf_field_type_integer_set_base(uint_12_type,
ok(bt_ctf_field_string_set_value(string, "A value") == 0,
"Set a string's value");
+ enumeration_type = bt_ctf_field_type_enumeration_create(uint_12_type);
+ ok(enumeration_type,
+ "Create an enumeration type with an unsigned 12-bit integer as container");
+ enumeration_sequence_type = bt_ctf_field_type_sequence_create(
+ enumeration_type, "count");
+ ok(!enumeration_sequence_type,
+ "Check enumeration types are validated when creating a sequence");
+ enumeration_array_type = bt_ctf_field_type_array_create(
+ enumeration_type, 10);
+ ok(!enumeration_array_type,
+ "Check enumeration types are validated when creating an array");
+ ok(bt_ctf_field_type_structure_add_field(composite_structure_type,
+ enumeration_type, "enumeration"),
+ "Check enumeration types are validated when adding them as structure members");
+ enumeration = bt_ctf_field_create(enumeration_type);
+ ok(!enumeration,
+ "Check enumeration types are validated before instantiation");
+
bt_ctf_field_put(string);
bt_ctf_field_put(uint_12);
bt_ctf_field_put(int_16);
+ bt_ctf_field_put(enumeration);
bt_ctf_field_type_put(composite_structure_type);
bt_ctf_field_type_put(structure_seq_type);
bt_ctf_field_type_put(string_type);
bt_ctf_field_type_put(uint_8_type);
bt_ctf_field_type_put(int_16_type);
bt_ctf_field_type_put(uint_12_type);
+ bt_ctf_field_type_put(enumeration_type);
+ bt_ctf_field_type_put(enumeration_sequence_type);
+ bt_ctf_field_type_put(enumeration_array_type);
}
void packet_resize_test(struct bt_ctf_stream_class *stream_class,
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;
struct bt_ctf_stream_class *stream_class;
struct bt_ctf_stream *stream1;
+ int ret;
if (argc < 3) {
printf("Usage: tests-ctf-writer path_to_ctf_parser_test path_to_babeltrace\n");
plan_no_plan();
- if (!mkdtemp(trace_path)) {
+ if (!bt_mkdtemp(trace_path)) {
perror("# perror");
}
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);
NULL),
"bt_ctf_writer_add_environment_field error with NULL field value");
- if (uname(&name)) {
+ /* On Solaris, uname() can return any positive value on success */
+ if (uname(&name) < 0) {
perror("uname");
return -1;
}
struct dirent *entry;
while ((entry = readdir(trace_dir))) {
- if (entry->d_type == DT_REG) {
- unlinkat(dirfd(trace_dir), entry->d_name, 0);
+ struct stat st;
+ char filename[PATH_MAX];
+
+ if (snprintf(filename, sizeof(filename), "%s/%s",
+ trace_path, entry->d_name) <= 0) {
+ continue;
+ }
+
+ if (stat(entry->d_name, &st)) {
+ continue;
+ }
+
+ if (S_ISREG(st.st_mode)) {
+ unlinkat(bt_dirfd(trace_dir), entry->d_name, 0);
}
}
projects / babeltrace.git / blobdiff