[babeltrace.git] / tests / plugins / src.ctf.fs / succeed / gen-trace-simple.c

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright (C) 2019 Philippe Proulx <pproulx@efficios.com>
 */

#include <stdint.h>
#include <babeltrace2-ctf-writer/writer.h>
#include <babeltrace2-ctf-writer/clock.h>
#include <babeltrace2-ctf-writer/clock-class.h>
#include <babeltrace2-ctf-writer/stream.h>
#include <babeltrace2-ctf-writer/event.h>
#include <babeltrace2-ctf-writer/event-types.h>
#include <babeltrace2-ctf-writer/event-fields.h>
#include <babeltrace2-ctf-writer/stream-class.h>
#include <babeltrace2-ctf-writer/trace.h>

#include "common/assert.h"

struct config {
	struct bt_ctf_writer *writer;
	struct bt_ctf_trace *trace;
	struct bt_ctf_clock *clock;
	struct bt_ctf_stream_class *sc;
	struct bt_ctf_stream *stream;
	struct bt_ctf_event_class *ec;
};

static
void fini_config(struct config *cfg)
{
	bt_ctf_object_put_ref(cfg->stream);
	bt_ctf_object_put_ref(cfg->sc);
	bt_ctf_object_put_ref(cfg->ec);
	bt_ctf_object_put_ref(cfg->clock);
	bt_ctf_object_put_ref(cfg->trace);
	bt_ctf_object_put_ref(cfg->writer);
}

static
void configure_writer(struct config *cfg, const char *path)
{
	struct bt_ctf_field_type *ft;
	int ret;

	cfg->writer = bt_ctf_writer_create(path);
	BT_ASSERT(cfg->writer);
	cfg->trace = bt_ctf_writer_get_trace(cfg->writer);
	BT_ASSERT(cfg->trace);
	cfg->clock = bt_ctf_clock_create("default");
	BT_ASSERT(cfg->clock);
	ret = bt_ctf_writer_add_clock(cfg->writer, cfg->clock);
	BT_ASSERT(ret == 0);
	ret = bt_ctf_writer_set_byte_order(cfg->writer,
		BT_CTF_BYTE_ORDER_BIG_ENDIAN);
	BT_ASSERT(ret == 0);
	cfg->sc = bt_ctf_stream_class_create("hello");
	BT_ASSERT(cfg->sc);
	ret = bt_ctf_stream_class_set_clock(cfg->sc, cfg->clock);
	BT_ASSERT(ret == 0);
	cfg->ec = bt_ctf_event_class_create("ev");
	BT_ASSERT(cfg->ec);
	ft = bt_ctf_field_type_integer_create(8);
	BT_ASSERT(ft);
	ret = bt_ctf_field_type_integer_set_is_signed(ft, BT_CTF_TRUE);
	BT_ASSERT(ret == 0);
	ret = bt_ctf_event_class_add_field(cfg->ec, ft, "first");
	BT_ASSERT(ret == 0);
	bt_ctf_object_put_ref(ft);
	ft = bt_ctf_field_type_string_create();
	BT_ASSERT(ft);
	ret = bt_ctf_event_class_add_field(cfg->ec, ft, "second");
	BT_ASSERT(ret == 0);
	bt_ctf_object_put_ref(ft);
	ret = bt_ctf_stream_class_add_event_class(cfg->sc, cfg->ec);
	BT_ASSERT(ret == 0);
	cfg->stream = bt_ctf_writer_create_stream(cfg->writer, cfg->sc);
	BT_ASSERT(cfg->stream);
}

static
void write_stream(struct config *cfg)
{
	struct bt_ctf_event *ev;
	struct bt_ctf_field *field;
	uint64_t i;
	int ret;

	for (i = 0; i < 25; i++) {
		ev = bt_ctf_event_create(cfg->ec);
		BT_ASSERT(ev);
		field = bt_ctf_event_get_payload(ev, "first");
		BT_ASSERT(field);
		ret = bt_ctf_field_integer_signed_set_value(field, -23 + i);
		BT_ASSERT(ret == 0);
		bt_ctf_object_put_ref(field);
		field = bt_ctf_event_get_payload(ev, "second");
		BT_ASSERT(field);
		ret = bt_ctf_field_string_set_value(field, "saluuuut");
		BT_ASSERT(ret == 0);
		bt_ctf_object_put_ref(field);
		ret = bt_ctf_clock_set_time(cfg->clock, 3600 + i * 5000);
		BT_ASSERT(ret == 0);
		ret = bt_ctf_stream_append_event(cfg->stream, ev);
		BT_ASSERT(ret == 0);
		bt_ctf_object_put_ref(ev);
	}

	ret = bt_ctf_stream_flush(cfg->stream);
	BT_ASSERT(ret == 0);
}

int main(int argc, char **argv)
{
	struct config cfg = {0};

	BT_ASSERT(argc >= 2);
	configure_writer(&cfg, argv[1]);
	write_stream(&cfg);
	fini_config(&cfg);
	return 0;
}
Commit	Line	Data
e30aed9e	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
e30aed9e	3	*
0235b0db	4	* Copyright (C) 2019 Philippe Proulx <pproulx@efficios.com>
e30aed9e PP	5	*/
	6
	7	#include <stdint.h>
217cf9d3 PP	8	#include <babeltrace2-ctf-writer/writer.h>
	9	#include <babeltrace2-ctf-writer/clock.h>
	10	#include <babeltrace2-ctf-writer/clock-class.h>
	11	#include <babeltrace2-ctf-writer/stream.h>
	12	#include <babeltrace2-ctf-writer/event.h>
	13	#include <babeltrace2-ctf-writer/event-types.h>
	14	#include <babeltrace2-ctf-writer/event-fields.h>
	15	#include <babeltrace2-ctf-writer/stream-class.h>
	16	#include <babeltrace2-ctf-writer/trace.h>
e30aed9e PP	17
	18	#include "common/assert.h"
	19
	20	struct config {
	21	struct bt_ctf_writer *writer;
	22	struct bt_ctf_trace *trace;
	23	struct bt_ctf_clock *clock;
	24	struct bt_ctf_stream_class *sc;
	25	struct bt_ctf_stream *stream;
	26	struct bt_ctf_event_class *ec;
	27	};
	28
	29	static
	30	void fini_config(struct config *cfg)
	31	{
	32	bt_ctf_object_put_ref(cfg->stream);
	33	bt_ctf_object_put_ref(cfg->sc);
	34	bt_ctf_object_put_ref(cfg->ec);
	35	bt_ctf_object_put_ref(cfg->clock);
	36	bt_ctf_object_put_ref(cfg->trace);
	37	bt_ctf_object_put_ref(cfg->writer);
	38	}
	39
	40	static
	41	void configure_writer(struct config cfg, const char path)
	42	{
	43	struct bt_ctf_field_type *ft;
	44	int ret;
	45
	46	cfg->writer = bt_ctf_writer_create(path);
	47	BT_ASSERT(cfg->writer);
	48	cfg->trace = bt_ctf_writer_get_trace(cfg->writer);
	49	BT_ASSERT(cfg->trace);
	50	cfg->clock = bt_ctf_clock_create("default");
	51	BT_ASSERT(cfg->clock);
	52	ret = bt_ctf_writer_add_clock(cfg->writer, cfg->clock);
	53	BT_ASSERT(ret == 0);
	54	ret = bt_ctf_writer_set_byte_order(cfg->writer,
	55	BT_CTF_BYTE_ORDER_BIG_ENDIAN);
	56	BT_ASSERT(ret == 0);
	57	cfg->sc = bt_ctf_stream_class_create("hello");
	58	BT_ASSERT(cfg->sc);
	59	ret = bt_ctf_stream_class_set_clock(cfg->sc, cfg->clock);
	60	BT_ASSERT(ret == 0);
	61	cfg->ec = bt_ctf_event_class_create("ev");
	62	BT_ASSERT(cfg->ec);
	63	ft = bt_ctf_field_type_integer_create(8);
	64	BT_ASSERT(ft);
00409097	65	ret = bt_ctf_field_type_integer_set_is_signed(ft, BT_CTF_TRUE);
e30aed9e PP	66	BT_ASSERT(ret == 0);
	67	ret = bt_ctf_event_class_add_field(cfg->ec, ft, "first");
	68	BT_ASSERT(ret == 0);
	69	bt_ctf_object_put_ref(ft);
	70	ft = bt_ctf_field_type_string_create();
	71	BT_ASSERT(ft);
	72	ret = bt_ctf_event_class_add_field(cfg->ec, ft, "second");
	73	BT_ASSERT(ret == 0);
	74	bt_ctf_object_put_ref(ft);
	75	ret = bt_ctf_stream_class_add_event_class(cfg->sc, cfg->ec);
	76	BT_ASSERT(ret == 0);
	77	cfg->stream = bt_ctf_writer_create_stream(cfg->writer, cfg->sc);
	78	BT_ASSERT(cfg->stream);
	79	}
	80
	81	static
	82	void write_stream(struct config *cfg)
	83	{
	84	struct bt_ctf_event *ev;
	85	struct bt_ctf_field *field;
	86	uint64_t i;
	87	int ret;
	88
	89	for (i = 0; i < 25; i++) {
	90	ev = bt_ctf_event_create(cfg->ec);
	91	BT_ASSERT(ev);
	92	field = bt_ctf_event_get_payload(ev, "first");
	93	BT_ASSERT(field);
	94	ret = bt_ctf_field_integer_signed_set_value(field, -23 + i);
	95	BT_ASSERT(ret == 0);
	96	bt_ctf_object_put_ref(field);
	97	field = bt_ctf_event_get_payload(ev, "second");
	98	BT_ASSERT(field);
	99	ret = bt_ctf_field_string_set_value(field, "saluuuut");
	100	BT_ASSERT(ret == 0);
	101	bt_ctf_object_put_ref(field);
	102	ret = bt_ctf_clock_set_time(cfg->clock, 3600 + i * 5000);
	103	BT_ASSERT(ret == 0);
	104	ret = bt_ctf_stream_append_event(cfg->stream, ev);
	105	BT_ASSERT(ret == 0);
	106	bt_ctf_object_put_ref(ev);
	107	}
	108
	109	ret = bt_ctf_stream_flush(cfg->stream);
	110	BT_ASSERT(ret == 0);
	111	}
	112
	113	int main(int argc, char **argv)
	114	{
	115	struct config cfg = {0};
	116
	117	BT_ASSERT(argc >= 2);
	118	configure_writer(&cfg, argv[1]);
	119	write_stream(&cfg);
	120	fini_config(&cfg);
	121	return 0;
	122	}