#include <babeltrace/ctf-writer/stream-class.h>
#include <babeltrace/ctf-ir/packet.h>
#include <babeltrace/ctf-ir/clock-class.h>
+#include <babeltrace/ctf-ir/trace.h>
#include <babeltrace/ref.h>
#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 601
+#define NR_TESTS 611
static int64_t current_time = 42;
"bt_ctf_stream_class_get_event_class_count handles NULL correctly");
ok(bt_ctf_stream_class_get_event_class_count(stream_class) == 1,
"bt_ctf_stream_class_get_event_class_count returns a correct number of event classes");
- ok(bt_ctf_stream_class_get_event_class(NULL, 0) == NULL,
+ ok(bt_ctf_stream_class_get_event_class_by_index(NULL, 0) == NULL,
"bt_ctf_stream_class_get_event_class handles NULL correctly");
- ok(bt_ctf_stream_class_get_event_class(stream_class, 8724) == NULL,
+ ok(bt_ctf_stream_class_get_event_class_by_index(stream_class, 8724) == NULL,
"bt_ctf_stream_class_get_event_class handles invalid indexes correctly");
- ret_event_class = bt_ctf_stream_class_get_event_class(stream_class, 0);
+ ret_event_class = bt_ctf_stream_class_get_event_class_by_index(stream_class, 0);
ok(ret_event_class == simple_event_class,
"bt_ctf_stream_class_get_event_class returns the correct event class");
bt_put(ret_event_class);
"bt_ctf_event_class_get_attribute_count handles a NULL event class");
ok(bt_ctf_event_class_get_attribute_count(event_class) == 4,
"bt_ctf_event_class_get_attribute_count returns the correct count");
- ok(!bt_ctf_event_class_get_attribute_name(NULL, 0),
+ ok(!bt_ctf_event_class_get_attribute_name_by_index(NULL, 0),
"bt_ctf_event_class_get_attribute_name handles a NULL event class correctly");
- ok(!bt_ctf_event_class_get_attribute_name(event_class, 4),
+ ok(!bt_ctf_event_class_get_attribute_name_by_index(event_class, 4),
"bt_ctf_event_class_get_attribute_name handles a too large index correctly");
- ok(!bt_ctf_event_class_get_attribute_value(NULL, 0),
+ ok(!bt_ctf_event_class_get_attribute_value_by_index(NULL, 0),
"bt_ctf_event_class_get_attribute_value handles a NULL event class correctly");
- ok(!bt_ctf_event_class_get_attribute_value(event_class, 4),
+ ok(!bt_ctf_event_class_get_attribute_value_by_index(event_class, 4),
"bt_ctf_event_class_get_attribute_value handles a too large index correctly");
memset(&attrs_count, 0, sizeof(attrs_count));
for (i = 0; i < 4; ++i) {
- ret_string = bt_ctf_event_class_get_attribute_name(event_class,
- i);
- obj = bt_ctf_event_class_get_attribute_value(event_class, i);
+ ret_string = bt_ctf_event_class_get_attribute_name_by_index(
+ event_class, i);
+ obj = bt_ctf_event_class_get_attribute_value_by_index(
+ event_class, i);
assert(ret_string && obj);
if (!strcmp(ret_string, "id")) {
"bt_ctf_event_class_get_stream_class returns the correct stream class");
bt_put(ret_stream_class);
- ok(bt_ctf_event_class_get_field_count(NULL) < 0,
+ ok(bt_ctf_event_class_get_payload_type_field_count(NULL) < 0,
"bt_ctf_event_class_get_field_count handles NULL correctly");
- ok(bt_ctf_event_class_get_field_count(event_class) == 3,
+ ok(bt_ctf_event_class_get_payload_type_field_count(event_class) == 3,
"bt_ctf_event_class_get_field_count returns a correct value");
- ok(bt_ctf_event_class_get_field(NULL, &ret_string,
+ ok(bt_ctf_event_class_get_payload_type_field_by_index(NULL, &ret_string,
&ret_field_type, 0) < 0,
"bt_ctf_event_class_get_field handles a NULL event class correctly");
- ok(bt_ctf_event_class_get_field(event_class, NULL,
+ ok(bt_ctf_event_class_get_payload_type_field_by_index(event_class, NULL,
&ret_field_type, 0) == 0,
"bt_ctf_event_class_get_field handles a NULL field name correctly");
bt_put(ret_field_type);
- ok(bt_ctf_event_class_get_field(event_class, &ret_string,
+ ok(bt_ctf_event_class_get_payload_type_field_by_index(event_class, &ret_string,
NULL, 0) == 0,
"bt_ctf_event_class_get_field handles a NULL field type correctly");
- ok(bt_ctf_event_class_get_field(event_class, &ret_string,
+ ok(bt_ctf_event_class_get_payload_type_field_by_index(event_class, &ret_string,
&ret_field_type, 42) < 0,
"bt_ctf_event_class_get_field handles an invalid index correctly");
- ok(bt_ctf_event_class_get_field(event_class, &ret_string,
+ ok(bt_ctf_event_class_get_payload_type_field_by_index(event_class, &ret_string,
&ret_field_type, 0) == 0,
"bt_ctf_event_class_get_field returns a field");
ok(bt_ctf_field_type_compare(ret_field_type, uint_35_type) == 0,
"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 non-writer trace, stream class, stream, and clock */
non_writer_trace = bt_ctf_trace_create();
assert(non_writer_trace);
- ret = bt_ctf_trace_set_byte_order(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");
bt_put(sc);
}
+static
+void test_static_trace(void)
+{
+ struct bt_ctf_trace *trace;
+ struct bt_ctf_stream_class *stream_class;
+ struct bt_ctf_stream_class *stream_class2;
+ struct bt_ctf_stream *stream;
+ struct bt_ctf_clock_class *clock_class;
+ int ret;
+
+ trace = bt_ctf_trace_create();
+ assert(trace);
+ ret = bt_ctf_trace_set_native_byte_order(trace,
+ BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
+ assert(ret == 0);
+ stream_class = bt_ctf_stream_class_create(NULL);
+ assert(stream_class);
+ ret = bt_ctf_trace_add_stream_class(trace, stream_class);
+ assert(ret == 0);
+ stream = bt_ctf_stream_create(stream_class, "hello");
+ ok(stream, "bt_ctf_stream_create() succeeds with a non-static trace");
+ bt_put(stream);
+ ok(!bt_ctf_trace_is_static(trace),
+ "bt_ctf_trace_is_static() returns the expected value");
+ ok(bt_ctf_trace_set_is_static(trace) == 0,
+ "bt_ctf_trace_set_is_static() succeeds");
+ ok(bt_ctf_trace_is_static(trace),
+ "bt_ctf_trace_is_static() returns the expected value");
+ clock_class = bt_ctf_clock_class_create("yes");
+ assert(clock_class);
+ stream_class2 = bt_ctf_stream_class_create(NULL);
+ assert(stream_class2);
+ ok(bt_ctf_trace_add_stream_class(trace, stream_class2),
+ "bt_ctf_trace_add_stream_class() fails with a static trace");
+ ok(bt_ctf_trace_add_clock_class(trace, clock_class),
+ "bt_ctf_trace_add_clock_class() fails with a static trace");
+ ok(!bt_ctf_stream_create(stream_class, "hello2"),
+ "bt_ctf_stream_create() fails with a static trace");
+
+ bt_put(trace);
+ bt_put(stream_class);
+ bt_put(stream_class2);
+ bt_put(clock_class);
+}
+
int main(int argc, char **argv)
{
char trace_path[] = "/tmp/ctfwriter_XXXXXX";
struct bt_ctf_clock_class *ret_clock_class;
struct bt_ctf_stream_class *stream_class, *ret_stream_class;
struct bt_ctf_stream *stream1;
+ struct bt_ctf_stream *stream;
const char *ret_string;
const unsigned char *ret_uuid;
unsigned char tmp_uuid[16] = { 0 };
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");
"bt_ctf_trace_get_environment_field_count returns a correct number of environment fields");
/* Test bt_ctf_trace_get_environment_field_name */
- ok(bt_ctf_trace_get_environment_field_name(NULL, 0) == NULL,
+ ok(bt_ctf_trace_get_environment_field_name_by_index(NULL, 0) == NULL,
"bt_ctf_trace_get_environment_field_name handles a NULL trace correctly");
- ok(bt_ctf_trace_get_environment_field_name(trace, -1) == NULL,
+ ok(bt_ctf_trace_get_environment_field_name_by_index(trace, -1) == NULL,
"bt_ctf_trace_get_environment_field_name handles an invalid index correctly (negative)");
- ok(bt_ctf_trace_get_environment_field_name(trace, 5) == NULL,
+ ok(bt_ctf_trace_get_environment_field_name_by_index(trace, 5) == NULL,
"bt_ctf_trace_get_environment_field_name handles an invalid index correctly (too large)");
- ret_string = bt_ctf_trace_get_environment_field_name(trace, 0);
+ ret_string = bt_ctf_trace_get_environment_field_name_by_index(trace, 0);
ok(ret_string && !strcmp(ret_string, "host"),
"bt_ctf_trace_get_environment_field_name returns a correct field name");
- ret_string = bt_ctf_trace_get_environment_field_name(trace, 1);
+ ret_string = bt_ctf_trace_get_environment_field_name_by_index(trace, 1);
ok(ret_string && !strcmp(ret_string, "test_env_int_obj"),
"bt_ctf_trace_get_environment_field_name returns a correct field name");
- ret_string = bt_ctf_trace_get_environment_field_name(trace, 2);
+ ret_string = bt_ctf_trace_get_environment_field_name_by_index(trace, 2);
ok(ret_string && !strcmp(ret_string, "test_env_str_obj"),
"bt_ctf_trace_get_environment_field_name returns a correct field name");
- ret_string = bt_ctf_trace_get_environment_field_name(trace, 3);
+ ret_string = bt_ctf_trace_get_environment_field_name_by_index(trace, 3);
ok(ret_string && !strcmp(ret_string, "test_env_int"),
"bt_ctf_trace_get_environment_field_name returns a correct field name");
- ret_string = bt_ctf_trace_get_environment_field_name(trace, 4);
+ ret_string = bt_ctf_trace_get_environment_field_name_by_index(trace, 4);
ok(ret_string && !strcmp(ret_string, "test_env_str"),
"bt_ctf_trace_get_environment_field_name returns a correct field name");
/* Test bt_ctf_trace_get_environment_field_value */
- ok(bt_ctf_trace_get_environment_field_value(NULL, 0) == NULL,
+ ok(bt_ctf_trace_get_environment_field_value_by_index(NULL, 0) == NULL,
"bt_ctf_trace_get_environment_field_value handles a NULL trace correctly");
- ok(bt_ctf_trace_get_environment_field_value(trace, -1) == NULL,
+ ok(bt_ctf_trace_get_environment_field_value_by_index(trace, -1) == NULL,
"bt_ctf_trace_get_environment_field_value handles an invalid index correctly (negative)");
- ok(bt_ctf_trace_get_environment_field_value(trace, 5) == NULL,
+ ok(bt_ctf_trace_get_environment_field_value_by_index(trace, 5) == NULL,
"bt_ctf_trace_get_environment_field_value handles an invalid index correctly (too large)");
- obj = bt_ctf_trace_get_environment_field_value(trace, 1);
+ obj = bt_ctf_trace_get_environment_field_value_by_index(trace, 1);
ret = bt_value_integer_get(obj, &ret_int64_t);
ok(!ret && ret_int64_t == 23,
"bt_ctf_trace_get_environment_field_value succeeds in getting an integer value");
BT_PUT(obj);
- obj = bt_ctf_trace_get_environment_field_value(trace, 2);
+ obj = bt_ctf_trace_get_environment_field_value_by_index(trace, 2);
ret = bt_value_string_get(obj, &ret_string);
ok(!ret && ret_string && !strcmp(ret_string, "the value"),
"bt_ctf_trace_get_environment_field_value succeeds in getting a string value");
"bt_ctf_trace_set_environment_field_integer succeeds with an existing name");
ok(bt_ctf_trace_get_environment_field_count(trace) == 5,
"bt_ctf_trace_set_environment_field_integer with an existing key does not increase the environment size");
- obj = bt_ctf_trace_get_environment_field_value(trace, 3);
+ obj = bt_ctf_trace_get_environment_field_value_by_index(trace, 3);
ret = bt_value_integer_get(obj, &ret_int64_t);
ok(!ret && ret_int64_t == 654321,
"bt_ctf_trace_get_environment_field_value successfully replaces an existing field");
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),
/* Instantiate a stream and append events */
ret = bt_ctf_writer_add_clock(writer, clock);
assert(ret == 0);
+ ok(bt_ctf_trace_get_stream_count(trace) == 0,
+ "bt_ctf_trace_get_stream_count() succeeds and returns the correct value (0)");
stream1 = bt_ctf_writer_create_stream(writer, stream_class);
ok(stream1, "Instanciate a stream class from writer");
+ ok(bt_ctf_trace_get_stream_count(trace) == 1,
+ "bt_ctf_trace_get_stream_count() succeeds and returns the correct value (1)");
+ stream = bt_ctf_trace_get_stream_by_index(trace, 0);
+ ok(stream == stream1,
+ "bt_ctf_trace_get_stream_by_index() succeeds and returns the correct value");
+ BT_PUT(stream);
/*
* Creating a stream through a writer adds the given stream
"bt_ctf_trace_get_clock_class_count correctly handles NULL");
ok(bt_ctf_trace_get_clock_class_count(trace) == 1,
"bt_ctf_trace_get_clock_class_count returns the correct number of clocks");
- ok(!bt_ctf_trace_get_clock_class(NULL, 0),
+ ok(!bt_ctf_trace_get_clock_class_by_index(NULL, 0),
"bt_ctf_trace_get_clock_class correctly handles NULL");
- ok(!bt_ctf_trace_get_clock_class(trace, -1),
+ ok(!bt_ctf_trace_get_clock_class_by_index(trace, -1),
"bt_ctf_trace_get_clock_class correctly handles negative indexes");
- ok(!bt_ctf_trace_get_clock_class(trace, 1),
+ ok(!bt_ctf_trace_get_clock_class_by_index(trace, 1),
"bt_ctf_trace_get_clock_class correctly handles out of bound accesses");
- ret_clock_class = bt_ctf_trace_get_clock_class(trace, 0);
+ ret_clock_class = bt_ctf_trace_get_clock_class_by_index(trace, 0);
ok(strcmp(bt_ctf_clock_class_get_name(ret_clock_class),
bt_ctf_clock_get_name(clock)) == 0,
"bt_ctf_trace_get_clock_class returns the right clock instance");
test_custom_event_header_stream(writer, clock);
+ test_static_trace();
+
metadata_string = bt_ctf_writer_get_metadata_string(writer);
ok(metadata_string, "Get metadata string");
projects / babeltrace.git / blobdiff