result:
ok(ret == 0, "Metadata string is valid");
- if (ret && metadata_fd > 0 && parser_output_fd > 0) {
+ 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;
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) {
free(line);
close_fp:
- fclose(metadata_fp);
- fclose(parser_output_fp);
+ if (metadata_fp) {
+ if (fclose(metadata_fp)) {
+ diag("fclose failure");
+ }
+ }
+ if (parser_output_fp) {
+ if (fclose(parser_output_fp)) {
+ diag("fclose failure");
+ }
+ }
}
- close(parser_output_fd);
- close(metadata_fd);
+ if (parser_output_fd >= 0) {
+ if (close(parser_output_fd)) {
+ diag("close error");
+ }
+ }
+ if (metadata_fd >= 0) {
+ if (close(metadata_fd)) {
+ diag("close error");
+ }
+ }
}
void validate_trace(char *parser_path, char *trace_path)
result:
ok(ret == 0, "Babeltrace could read the resulting trace");
- if (ret && babeltrace_output_fd > 0) {
+ if (ret && babeltrace_output_fd >= 0) {
char *line;
size_t len = METADATA_LINE_SIZE;
FILE *babeltrace_output_fp = NULL;
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 (getline(&line, &len, babeltrace_output_fp) > 0) {
diag("%s", line);
free(line);
close_fp:
- fclose(babeltrace_output_fp);
+ if (babeltrace_output_fp) {
+ if (fclose(babeltrace_output_fp)) {
+ diag("fclose error");
+ }
+ }
}
- close(babeltrace_output_fd);
+ if (babeltrace_output_fd >= 0) {
+ if (close(babeltrace_output_fd)) {
+ diag("close error");
+ }
+ }
}
void append_simple_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") == 0,
+ "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,